static void android_irrc_enable_pwm(struct timed_irrc_data *irrc, int PWM_CLK, int duty)
{
int rc;
cancel_delayed_work_sync(&irrc->gpio_off_work); //android_irrc_disable_pwm
if(g_pwm_enabled == true) {
INFO_MSG("pwm already enabled !!!\n");
return;
}
if (irrc->vreg != NULL) {
rc = regulator_enable(irrc->vreg);
ERR_MSG("regulator_enabled1\n");
if (rc < 0)
ERR_MSG("regulator_enable failed\n");
}
/*if (irrc->vreg2 != NULL) {
rc = regulator_enable(irrc->vreg2);
ERR_MSG("irrc->vreg2 set!!\n");
if (rc < 0)
ERR_MSG("regulator_enable failed2\n");
}*/
if((PWM_CLK == 0) || (duty == 100)){
INFO_MSG("gpio set to high!!!\n");
rc = pinctrl_select_state(irrc->pctrl, irrc->active_state);
if(rc < 0) {
ERR_MSG("select active state failed\n");
} else {
ERR_MSG("state changed to active\n");
}
gpio_direction_output(irrc->pwm_gpio, 1);
gpio_set_value(irrc->pwm_gpio, 1);
gpio_high_flag = 1;
} else if((PWM_CLK < 23) || (PWM_CLK > 1200) || (duty > 60) || (duty < 20) ){
INFO_MSG("Out of range ! \n");
} else {
INFO_MSG("gpio set to gp!!!\n");
rc = pinctrl_select_state(irrc->pctrl, irrc->suspended_state);
if(rc < 0){
ERR_MSG("select suspended state failed\n");
} else {
ERR_MSG("state changed to suspended\n");
}
gpio_direction_output(irrc->pwm_gpio, 1);
//gpio_set_value(irrc->pwm_gpio, 1); no need
clk_set_rate(irrc->gp_clk, irrc->clk_rate);
clk_prepare_enable(irrc->gp_clk);
android_irrc_set_pwm(1, PWM_CLK, duty);
gpio_high_flag = 0;
}
g_pwm_enabled = true;
}
int mtkcam_gpio_set(int PinIdx, int PwrType, int Val)
{
int ret = 0;
switch (PwrType) {
case CAMRST:
if (PinIdx == 0) {
if (Val == 0)
pinctrl_select_state(camctrl, cam0_rst_l);
else
pinctrl_select_state(camctrl, cam0_rst_h);
} else {
if (Val == 0)
pinctrl_select_state(camctrl, cam1_rst_l);
else
pinctrl_select_state(camctrl, cam1_rst_h);
}
break;
default:
PK_DBG("PwrType(%d) is invalid !!\n", PwrType);
break;
};
PK_DBG("PinIdx(%d) PwrType(%d) val(%d)\n", PinIdx, PwrType, Val);
return ret;
}
static int tegra_sdhci_set_padctrl(struct sdhci_host *host, int voltage)
{
struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
struct sdhci_tegra *tegra_host = sdhci_pltfm_priv(pltfm_host);
int ret;
if (!tegra_host->pad_control_available)
return 0;
if (voltage == MMC_SIGNAL_VOLTAGE_180) {
ret = pinctrl_select_state(tegra_host->pinctrl_sdmmc,
tegra_host->pinctrl_state_1v8);
if (ret < 0)
dev_err(mmc_dev(host->mmc),
"setting 1.8V failed, ret: %d\n", ret);
} else {
ret = pinctrl_select_state(tegra_host->pinctrl_sdmmc,
tegra_host->pinctrl_state_3v3);
if (ret < 0)
dev_err(mmc_dev(host->mmc),
"setting 3.3V failed, ret: %d\n", ret);
}
return ret;
}
/*
* We provide an interface via debugfs to switch between host and device modes
* depending on user input.
* This is useful in special cases, such as uses TYPE-A receptacle but also
* wants to support dual-role mode.
* It generates cable state changes by pulling up/down IDPIN and
* notifies driver to switch mode by "extcon-usb-gpio".
* NOTE: when use MICRO receptacle, should not enable this interface.
*/
static void ssusb_mode_manual_switch(struct ssusb_mtk *ssusb, int to_host)
{
struct otg_switch_mtk *otg_sx = &ssusb->otg_switch;
if (to_host)
pinctrl_select_state(otg_sx->id_pinctrl, otg_sx->id_ground);
else
pinctrl_select_state(otg_sx->id_pinctrl, otg_sx->id_float);
}
static int ci13xxx_msm_install_wake_gpio(struct platform_device *pdev,
struct resource *res)
{
int wake_irq;
int ret;
struct pinctrl_state *set_state;
dev_dbg(&pdev->dev, "ci13xxx_msm_install_wake_gpio\n");
_udc_ctxt.wake_gpio = res->start;
if (_udc_ctxt.ci13xxx_pinctrl) {
set_state = pinctrl_lookup_state(_udc_ctxt.ci13xxx_pinctrl,
"ci13xxx_active");
if (IS_ERR(set_state)) {
pr_err("cannot get ci13xxx pinctrl active state\n");
return PTR_ERR(set_state);
}
pinctrl_select_state(_udc_ctxt.ci13xxx_pinctrl, set_state);
}
gpio_request(_udc_ctxt.wake_gpio, "USB_RESUME");
gpio_direction_input(_udc_ctxt.wake_gpio);
wake_irq = gpio_to_irq(_udc_ctxt.wake_gpio);
if (wake_irq < 0) {
dev_err(&pdev->dev, "could not register USB_RESUME GPIO.\n");
return -ENXIO;
}
dev_dbg(&pdev->dev, "_udc_ctxt.gpio_irq = %d and irq = %d\n",
_udc_ctxt.wake_gpio, wake_irq);
ret = request_irq(wake_irq, ci13xxx_msm_resume_irq,
IRQF_TRIGGER_RISING | IRQF_ONESHOT, "usb resume", NULL);
if (ret < 0) {
dev_err(&pdev->dev, "could not register USB_RESUME IRQ.\n");
goto gpio_free;
}
disable_irq(wake_irq);
_udc_ctxt.wake_irq = wake_irq;
return 0;
gpio_free:
gpio_free(_udc_ctxt.wake_gpio);
if (_udc_ctxt.ci13xxx_pinctrl) {
set_state = pinctrl_lookup_state(_udc_ctxt.ci13xxx_pinctrl,
"ci13xxx_sleep");
if (IS_ERR(set_state))
pr_err("cannot get ci13xxx pinctrl sleep state\n");
else
pinctrl_select_state(_udc_ctxt.ci13xxx_pinctrl,
set_state);
}
_udc_ctxt.wake_gpio = 0;
return ret;
}
static int config_irq(int n, int t) {
int ret;
if(n == 2) {
trigger1_type = t;
ret = pinctrl_select_state(pinctrl, pin_irq1);
if(ret<0) {
printk("pinctrl select state pin irq[%d] error \n", n);
}
irq1 = gpio_to_irq(pin[n]);
printk("%s : requesting IRQ1 %d name = %s \n", __func__, irq1, "irq1");
ret = request_irq(irq1, vdev_irq1_handler,
IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_NO_SUSPEND , "irq1", vdev_dev);
if(ret < 0) {
printk("request irq1 error\n");
return -1;
}
} else if(n == 7) {
trigger2_type = t;
ret = pinctrl_select_state(pinctrl, pin_irq2);
if(ret<0) {
printk("pinctrl select state pin irq[%d] error \n", n);
}
irq2 = gpio_to_irq(pin[n]);
printk("%s : requesting IRQ2 %d name = %s \n", __func__, irq2, "irq2");
ret = request_irq(irq2, vdev_irq2_handler,
IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_NO_SUSPEND , "irq2", vdev_dev);
if(ret < 0) {
printk("request irq2 error\n");
return -1;
}
} else if(n == 9) {
trigger3_type = t;
ret = pinctrl_select_state(pinctrl, pin_irq3);
if(ret<0) {
printk("pinctrl select state pin irq[%d] error \n", n);
}
irq3 = gpio_to_irq(pin[n]);
printk("%s : requesting IRQ3 %d name = %s \n", __func__, irq3, "irq3");
ret = request_irq(irq3, vdev_irq3_handler,
IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_NO_SUSPEND , "irq3", vdev_dev);
if(ret < 0) {
printk("request irq3 error\n");
return -1;
}
}
device_init_wakeup(&pn547_dev->client->dev, 1);
return ret;
}
static int c55_ctrl_suspend(struct platform_device *dev, pm_message_t state)
{
struct c55_ctrl_data *cdata = dev_get_drvdata(&dev->dev);
struct m4sensorhub_data *m4sensorhub = m4sensorhub_client_get_drvdata();
if (cdata->c55_mode != C55_OFF) {
dev_warn(&dev->dev, "C55 still ON when going into suspend\n");
/* Disable C55->AP IRQ when turning off C55 */
if (cdata->c55_ap_int_enabled) {
disable_irq_nosync(
__gpio_to_irq(cdata->c55_ap_int_gpio));
cdata->c55_ap_int_enabled = 0;
}
if (m4sensorhub_reg_write_1byte
(m4sensorhub, M4SH_REG_USERSETTINGS_AUDIOSTATUS,
AUDIO_STATUS_OFF, 0xFF) != 1) {
dev_err(&dev->dev,
"Unable to set screen status to 0x00\n");
}
/* AP->C55 interrupt needs to be set low when C55 is off
* for current drain reasons */
gpio_set_value(cdata->ap_c55_int_gpio, 0);
cdata->c55_mode = C55_OFF;
}
pinctrl_select_state(cdata->pctrl, cdata->states[C55_OFF]);
return 0;
}
static int c55_ctrl_pin_setup(struct device *dev, struct c55_ctrl_data *cdata)
{
int i, ret = 0;
cdata->pctrl = devm_pinctrl_get(dev);
if (IS_ERR(cdata->pctrl)) {
ret = PTR_ERR(cdata->pctrl);
dev_dbg(dev, "no pinctrl handle\n");
}
for (i = 0; !ret && (i < C55_MODE_MAX); i++) {
cdata->states[i] = pinctrl_lookup_state(cdata->pctrl,
c55_pin_state_labels[i]);
if (IS_ERR(cdata->states[i])) {
ret = PTR_ERR(cdata->states[i]);
dev_dbg(dev, "no %s pinctrl state\n",
c55_pin_state_labels[i]);
}
}
if (!ret) {
ret = pinctrl_select_state(cdata->pctrl,
cdata->states[C55_OFF]);
if (ret)
dev_dbg(dev, "failed to activate %s pinctrl state\n",
c55_pin_state_labels[C55_OFF]);
}
return ret;
}
/**
* Will try to select the set of pins (GPIOS) defined in a pin control node of
* the device tree named @p name.
*
* The node can contain several eg. GPIOs that is controlled when selecting it.
* The node may activate or deactivate the pins it contains, the action is
* defined in the device tree node itself and not here. The states used
* internally is fetched at probe time.
*
* @see pctl_names
* @see fpc1020_probe
*/
static int select_pin_ctl(struct fpc1020_data *fpc1020, const char *name)
{
struct device *dev = fpc1020->dev;
size_t i;
int rc;
for (i = 0; i < ARRAY_SIZE(fpc1020->pinctrl_state); i++) {
const char *n = pctl_names[i];
if (!strncmp(n, name, strlen(n))) {
rc = pinctrl_select_state(fpc1020->fingerprint_pinctrl,
fpc1020->pinctrl_state[i]);
if (rc)
dev_err(dev, "cannot select '%s'\n", name);
else
dev_dbg(dev, "Selected '%s'\n", name);
goto exit;
}
}
rc = -EINVAL;
dev_err(dev, "%s:'%s' not found\n", __func__, name);
exit:
return rc;
}
static int twi_request_gpio(struct sunxi_i2c *i2c)
{
int ret = 0;
I2C_DBG("Pinctrl init %d ... [%s]\n", i2c->bus_num, i2c->adap.dev.parent->init_name);
if (!twi_chan_is_enable(i2c->bus_num))
return -1;
i2c->pctrl = devm_pinctrl_get(i2c->adap.dev.parent);
if (IS_ERR(i2c->pctrl)) {
I2C_ERR("TWI%d devm_pinctrl_get() failed! return %ld\n", i2c->bus_num, PTR_ERR(i2c->pctrl));
return -1;
}
i2c->pctrl_state = pinctrl_lookup_state(i2c->pctrl, PINCTRL_STATE_DEFAULT);
if (IS_ERR(i2c->pctrl_state)) {
I2C_ERR("TWI%d pinctrl_lookup_state() failed! return %p \n", i2c->bus_num, i2c->pctrl_state);
return -1;
}
ret = pinctrl_select_state(i2c->pctrl, i2c->pctrl_state);
if (ret < 0)
I2C_ERR("TWI%d pinctrl_select_state() failed! return %d \n", i2c->bus_num, ret);
return ret;
}
static int isdbt_pinctrl_init(void)
{
struct pinctrl *tdmb_pinctrl;
struct pinctrl_state *gpio_state_suspend;
tdmb_pinctrl = devm_pinctrl_get(&(IsdbCtrlInfo.pdev->dev));
if(IS_ERR_OR_NULL(tdmb_pinctrl)) {
pr_err("%s: Getting pinctrl handle failed\n", __func__);
return -EINVAL;
}
gpio_state_suspend
= pinctrl_lookup_state(tdmb_pinctrl, "isdbt_gpio_suspend");
if(IS_ERR_OR_NULL(gpio_state_suspend)) {
pr_err("%s: [dtv]Failed to get the suspend state pinctrl handle\n", __func__);
return -EINVAL;
}
if(pinctrl_select_state(tdmb_pinctrl, gpio_state_suspend)) {
pr_err("%s: [dtv]error on pinctrl_select_state DTV GPIOs\n", __func__);
return -EINVAL;
}
else {
printk("%s: success to set pinctrl_select_state for DTV GPIOss\n", __func__);
}
return 0;
}
static int msm_flash_lm3642_i2c_remove(struct i2c_client *client)
{
struct msm_camera_sensor_board_info *flashdata = NULL;
struct msm_camera_power_ctrl_t *power_info = NULL;
int rc = 0 ;
LM3642_DBG("%s entry\n", __func__);
flashdata = fctrl.flashdata;
power_info = &flashdata->power_info;
rc = msm_camera_request_gpio_table(
power_info->gpio_conf->cam_gpio_req_tbl,
power_info->gpio_conf->cam_gpio_req_tbl_size, 0);
if (rc < 0) {
pr_err("%s: request gpio failed\n", __func__);
return rc;
}
if (fctrl.pinctrl_info.use_pinctrl == true) {
rc = pinctrl_select_state(fctrl.pinctrl_info.pinctrl,
fctrl.pinctrl_info.gpio_state_suspend);
if (rc)
pr_err("%s:%d cannot set pin to suspend state",
__func__, __LINE__);
}
return rc;
}
static int pinctrl_init(struct i2c_client *client)
{
struct lge_touch_data *ts = i2c_get_clientdata(client);
/* Get pinctrl if target uses pinctrl */
ts->ts_pinctrl = devm_pinctrl_get(&(client->dev));
if (IS_ERR(ts->ts_pinctrl)) {
if (PTR_ERR(ts->ts_pinctrl) == -EPROBE_DEFER) {
LGTC_ERR("ts_pinctrl == -EPROBE_DEFER\n");
return -EPROBE_DEFER;
}
LGTC_DBG("Target does not use pinctrl(ts->ts_pinctrl == NULL) \n");
ts->ts_pinctrl = NULL;
}
if (ts->ts_pinctrl) {
ts->ts_pinset_state_active = pinctrl_lookup_state(ts->ts_pinctrl, "pmx_ts_active");
if (IS_ERR(ts->ts_pinset_state_active))
LGTC_DBG("cannot get ts pinctrl active state\n");
ts->ts_pinset_state_suspend = pinctrl_lookup_state(ts->ts_pinctrl, "pmx_ts_suspend");
if (IS_ERR(ts->ts_pinset_state_suspend))
LGTC_DBG("cannot get ts pinctrl active state\n");
if (ts->ts_pinset_state_active) {
DO_SAFE(pinctrl_select_state(ts->ts_pinctrl, ts->ts_pinset_state_active), error);
} else {
LGTC_DBG("pinctrl active == NULL \n");
}
}
return NO_ERROR;
error:
return ERROR;
}
static void dummy_codec_device_init(void)
{
#ifdef CONFIG_USE_OF
int ret;
struct pinctrl_state *s;
p = pinctrl_get(dummy_codec_dev);
if (IS_ERR(p))
return;
s = pinctrl_lookup_state(p, "dummy_codec_audio");
if (IS_ERR(s)) {
pinctrl_put(p);
return;
}
ret = pinctrl_select_state(p, s);
if (ret < 0) {
pinctrl_put(p);
return;
}
printk("=%s==,dummy_codec_audio init done\n",__func__);
#else
/* audio pinmux */
// pinmux_set(&rt5631_pinmux_set);
/* GPIOA_19 PULL_UP_REG0 bit19 */
// aml_set_reg32_bits(P_PAD_PULL_UP_REG0, 1, 19, 1);
#endif
}
int msm_gpioset_activate(enum pinctrl_client client, char *keyword)
{
int ret = 0;
int gp_set = 0;
int active_set = 0;
gp_set = msm_get_gpioset_index(client, keyword);
if (gp_set < 0) {
pr_err("%s: gpio set name does not exist\n",
__func__);
return gp_set;
}
if (!gpioset_info[client].gpioset_state[gp_set]) {
/*
* If pinctrl pointer is not valid,
* no need to proceed further
*/
active_set = pinctrl_info[client].active_set;
if (IS_ERR(pinctrl_info[client].cdc_lines[active_set]))
return 0;
pinctrl_info[client].active_set |= (1 << gp_set);
active_set = pinctrl_info[client].active_set;
pr_debug("%s: pinctrl.active_set: %d\n", __func__, active_set);
/* Select the appropriate pinctrl state */
ret = pinctrl_select_state(pinctrl_info[client].pinctrl,
pinctrl_info[client].cdc_lines[active_set]);
}
gpioset_info[client].gpioset_state[gp_set]++;
return ret;
}
static void htc_config_bt_off(void)
{
int rc = 0;
if (gpio_bt_reg_on < 0) {
printk(KERN_INFO "[BT]bt_reg_on:%d !!\n", gpio_bt_reg_on);
}
bluesleep_set_bt_pwr_state(0);
rc = gpio_direction_output(gpio_bt_reg_on, 0);
if (rc) printk(KERN_INFO "[BT]set REG_ON 0 fail! %d\n", rc);
rc = pinctrl_select_state(bt_pinctrl, bt_wake_host_set_state_off);
if (rc) printk("[BT] cannot set BT pinctrl gpio state off\n");
mdelay(2);
msm_hs_uart_gpio_config_ext(0);
printk(KERN_INFO "[BT]== R OFF ==\n");
}
static int usdhi6_set_pinstates(struct usdhi6_host *host, int voltage)
{
if (IS_ERR(host->pins_uhs))
return 0;
switch (voltage) {
case MMC_SIGNAL_VOLTAGE_180:
case MMC_SIGNAL_VOLTAGE_120:
return pinctrl_select_state(host->pinctrl,
host->pins_uhs);
default:
return pinctrl_select_state(host->pinctrl,
host->pins_default);
}
}
static int gpio_keys_pinctrl_configure(struct gpio_keys_drvdata *ddata,
bool active)
{
struct pinctrl_state *set_state;
int retval;
if (active) {
set_state =
pinctrl_lookup_state(ddata->key_pinctrl,
"tlmm_gpio_key_active");
if (IS_ERR(set_state)) {
dev_err(&ddata->input->dev,
"cannot get ts pinctrl active state\n");
return PTR_ERR(set_state);
}
} else {
set_state =
pinctrl_lookup_state(ddata->key_pinctrl,
"tlmm_gpio_key_suspend");
if (IS_ERR(set_state)) {
dev_err(&ddata->input->dev,
"cannot get gpiokey pinctrl sleep state\n");
return PTR_ERR(set_state);
}
}
retval = pinctrl_select_state(ddata->key_pinctrl, set_state);
if (retval) {
dev_err(&ddata->input->dev,
"cannot set ts pinctrl active state\n");
return retval;
}
return 0;
}
static int aw2013_configure_gpio(struct aw2013_led *led, bool on)
{
struct pinctrl *pinctrl;
struct pinctrl_state *pinctrl_state;
int rc;
pinctrl = devm_pinctrl_get(&led->client->dev);
if (IS_ERR_OR_NULL(pinctrl)) {
dev_err(&led->client->dev,
"Failed to get pinctrl\n");
return -EFAULT;
}
pinctrl_state = pinctrl_lookup_state(pinctrl,
on ? "aw2013_led_default" : "aw2013_led_suspend");
if (IS_ERR_OR_NULL(pinctrl_state)) {
dev_err(&led->client->dev,
"Failed to look up pinctrl state\n");
return -EFAULT;
}
rc = pinctrl_select_state(pinctrl, pinctrl_state);
if (rc) {
dev_err(&led->client->dev,
"Failed to select pinctrl state\n");
return -EIO;
}
return 0;
}
static int mdss_dsi_pinctrl_set_state(
struct mdss_dsi_ctrl_pdata *ctrl_pdata,
bool active)
{
struct pinctrl_state *pin_state;
int rc = -EFAULT;
if (IS_ERR_OR_NULL(ctrl_pdata->pin_res.pinctrl))
return PTR_ERR(ctrl_pdata->pin_res.pinctrl);
pin_state = active ? ctrl_pdata->pin_res.gpio_state_active
: ctrl_pdata->pin_res.gpio_state_suspend;
if (!IS_ERR_OR_NULL(pin_state)) {
rc = pinctrl_select_state(ctrl_pdata->pin_res.pinctrl,
pin_state);
if (rc)
pr_err("%s: can not set %s pins\n", __func__,
active ? MDSS_PINCTRL_STATE_DEFAULT
: MDSS_PINCTRL_STATE_SLEEP);
} else {
pr_err("%s: invalid '%s' pinstate\n", __func__,
active ? MDSS_PINCTRL_STATE_DEFAULT
: MDSS_PINCTRL_STATE_SLEEP);
}
return rc;
}
static int enable_msp(struct ux500_msp *msp, struct ux500_msp_config *config)
{
int status = 0, retval = 0;
u32 reg_val_DMACR, reg_val_GCR;
unsigned long flags;
/* Check msp state whether in RUN or CONFIGURED Mode */
if (msp->msp_state == MSP_STATE_IDLE) {
spin_lock_irqsave(&msp_rxtx_lock, flags);
if (msp->pinctrl_rxtx_ref == 0 &&
!(IS_ERR(msp->pinctrl_p) || IS_ERR(msp->pinctrl_def))) {
retval = pinctrl_select_state(msp->pinctrl_p,
msp->pinctrl_def);
if (retval)
pr_err("could not set MSP defstate\n");
}
if (!retval)
msp->pinctrl_rxtx_ref++;
spin_unlock_irqrestore(&msp_rxtx_lock, flags);
}
/* Configure msp with protocol dependent settings */
configure_protocol(msp, config);
setup_bitclk(msp, config);
if (config->multichannel_configured == 1) {
status = configure_multichannel(msp, config);
if (status)
dev_warn(msp->dev,
"%s: WARN: configure_multichannel failed (%d)!\n",
__func__, status);
}
/* Make sure the correct DMA-directions are configured */
if ((config->direction & MSP_DIR_RX) && (!msp->dma_cfg_rx)) {
dev_err(msp->dev, "%s: ERROR: MSP RX-mode is not configured!",
__func__);
return -EINVAL;
}
if ((config->direction == MSP_DIR_TX) && (!msp->dma_cfg_tx)) {
dev_err(msp->dev, "%s: ERROR: MSP TX-mode is not configured!",
__func__);
return -EINVAL;
}
reg_val_DMACR = readl(msp->registers + MSP_DMACR);
if (config->direction & MSP_DIR_RX)
reg_val_DMACR |= RX_DMA_ENABLE;
if (config->direction & MSP_DIR_TX)
reg_val_DMACR |= TX_DMA_ENABLE;
writel(reg_val_DMACR, msp->registers + MSP_DMACR);
writel(config->iodelay, msp->registers + MSP_IODLY);
/* Enable frame generation logic */
reg_val_GCR = readl(msp->registers + MSP_GCR);
writel(reg_val_GCR | FRAME_GEN_ENABLE, msp->registers + MSP_GCR);
return status;
}
void s5p_v4l2_int_src_ext_hpd(struct hdmi_device *hdev)
{
int ret = 0;
ret = pinctrl_select_state(hdev->pinctrl, hdev->pin_ext);
if (ret)
dev_err(hdev->dev, "failed to set external hpd interrupt");
}
static void IicPortDisable(UBYTE Port)
{
PINHigh(Port, INPUT_PORT_BUF);
PINInput(Port, INPUT_PORT_PIN6);
pinctrl_select_state(Device1Lms2012Compat->pinctrl[Port],
Device1Lms2012Compat->pinctrl_default[Port]);
}
static int c55_ctrl_resume(struct platform_device *dev)
{
struct c55_ctrl_data *cdata = dev_get_drvdata(&dev->dev);
pinctrl_select_state(cdata->pctrl, cdata->states[C55_ON]);
return 0;
}
static void i2c_fsl_unprepare_recovery(struct i2c_adapter *adapter)
{
int ret;
ret = pinctrl_select_state(adapter->dev.parent, "default");
if (ret)
dev_err(adapter->dev.parent, "pinctrl failed: %s\n", strerror(-ret));
}
static void IicPortEnable(UBYTE Port)
{
pinctrl_select_state(Device1Lms2012Compat->pinctrl[Port],
Device1Lms2012Compat->pinctrl_i2c[Port]);
PINLow(Port, INPUT_PORT_BUF);
// PINHigh(Port, IIC_PORT_CLOCK);
PINHigh(Port, INPUT_PORT_PIN6);
}
int gf_pinctrl_set(struct gf_dev *gf_dev, bool active)
{
int ret = 0;
GF_LOG_INFO("start\n");
if (active) {
ret = pinctrl_select_state(gf_dev->gf_pctrl.pinctrl,
gf_dev->gf_pctrl.gpio_state_active);
} else {
ret = pinctrl_select_state(gf_dev->gf_pctrl.pinctrl,
gf_dev->gf_pctrl.gpio_state_suspend);
}
GF_LOG_INFO("set %s = %d\n", active? "avtive" : "suspend", ret);
return ret;
}
void gf_irq_enable(struct gf_dev *gf_dev)
{
int ret = 0;
gpio_direction_input(gf_dev->irq_gpio);
ret = pinctrl_select_state(gf_dev->gf_pctrl.pinctrl,
gf_dev->gf_pctrl.gpio_int_active);
gf_irq_op(gf_dev->irq, GF_INT_ENABLE);
}
static void otg_int_init(void)
{
#ifdef ID_PIN_USE_EX_EINT
int ret = 0;
#ifndef CONFIG_MTK_FPGA
#ifdef CONFIG_OF
#if defined(CONFIG_MTK_LEGACY)
mt_set_gpio_mode(iddig_pin, iddig_pin_mode);
mt_set_gpio_dir(iddig_pin, GPIO_DIR_IN);
mt_set_gpio_pull_enable(iddig_pin, GPIO_PULL_ENABLE);
mt_set_gpio_pull_select(iddig_pin, GPIO_PULL_UP);
#else
pr_debug("****%s:%d before Init IDDIG KS!!!!!\n", __func__, __LINE__);
pinctrl_iddig = pinctrl_lookup_state(pinctrl, "iddig_irq_init");
if (IS_ERR(pinctrl_iddig)) {
ret = PTR_ERR(pinctrl_iddig);
dev_err(mtk_musb->controller, "Cannot find usb pinctrl iddig_irq_init\n");
}
pinctrl_select_state(pinctrl, pinctrl_iddig);
pr_debug("****%s:%d end Init IDDIG KS!!!!!\n", __func__, __LINE__);
#endif
#else
mt_set_gpio_mode(GPIO_OTG_IDDIG_EINT_PIN, GPIO_OTG_IDDIG_EINT_PIN_M_IDDIG);
mt_set_gpio_dir(GPIO_OTG_IDDIG_EINT_PIN, GPIO_DIR_IN);
mt_set_gpio_pull_enable(GPIO_OTG_IDDIG_EINT_PIN, GPIO_PULL_ENABLE);
mt_set_gpio_pull_select(GPIO_OTG_IDDIG_EINT_PIN, GPIO_PULL_UP);
#endif
#endif
#if defined(CONFIG_MTK_LEGACY)
mt_gpio_set_debounce(IDDIG_EINT_PIN, 64000);
usb_iddig_number = mt_gpio_to_irq(IDDIG_EINT_PIN);
pr_debug("USB IDDIG IRQ LINE %d, %d!!\n", IDDIG_EINT_PIN, mt_gpio_to_irq(IDDIG_EINT_PIN));
ret = request_irq(usb_iddig_number, mt_usb_ext_iddig_int, IRQF_TRIGGER_LOW, "USB_IDDIG", NULL);
#else
/*gpio_request(iddig_pin, "USB_IDDIG");*/
gpio_set_debounce(iddig_pin, 64000);
usb_iddig_number = mt_gpio_to_irq(iddig_pin);
ret = request_irq(usb_iddig_number, mt_usb_ext_iddig_int, IRQF_TRIGGER_LOW, "USB_IDDIG", NULL);
#endif
if (ret > 0)
pr_err("USB IDDIG IRQ LINE not available!!\n");
else
pr_debug("USB IDDIG IRQ LINE available!!\n");
#else
u32 phy_id_pull = 0;
phy_id_pull = __raw_readl(U2PHYDTM1);
phy_id_pull |= ID_PULL_UP;
__raw_writel(phy_id_pull, U2PHYDTM1);
musb_writel(mtk_musb->mregs, USB_L1INTM, IDDIG_INT_STATUS|musb_readl(mtk_musb->mregs, USB_L1INTM));
#endif
}
/*
* use SEL_I2C2 to configure pcf8575@26 to set/unset LS_OE and CT_HPD, and use
* SEL_HDMI to read edid via the HDMI ddc lines
*/
static void hdmi_i2c2_hack_demux(struct device *dev, int sel)
{
struct platform_device *pdev = to_platform_device(dev);
struct panel_drv_data *ddata = platform_get_drvdata(pdev);
/*
* switch to I2C2 or HDMI DDC internal pinmux and drive MCASP8_AXR2
* to low or high to select I2C2 or HDMI path respectively
*/
if (sel == SEL_I2C2) {
pinctrl_select_state(ddata->pins, ddata->pin_state_i2c);
dra7_mcasp_hdmi_gpio_set(mcasp, false);
} else {
pinctrl_select_state(ddata->pins, ddata->pin_state_ddc);
dra7_mcasp_hdmi_gpio_set(mcasp, true);
}
/* let it propogate */
udelay(5);
}
