static int cs53l30_mute_stream(struct snd_soc_dai *dai, int mute, int stream) { struct cs53l30_private *priv = snd_soc_codec_get_drvdata(dai->codec); gpiod_set_value_cansleep(priv->mute_gpio, mute); return 0; }
static int rfkill_gpio_set_power(void *data, bool blocked) { struct rfkill_gpio_data *rfkill = data; if (!blocked && !IS_ERR(rfkill->clk) && !rfkill->clk_enabled) clk_enable(rfkill->clk); gpiod_set_value_cansleep(rfkill->shutdown_gpio, !blocked); gpiod_set_value_cansleep(rfkill->reset_gpio, !blocked); if (blocked && !IS_ERR(rfkill->clk) && rfkill->clk_enabled) clk_disable(rfkill->clk); rfkill->clk_enabled = !blocked; return 0; }
static int tm2_mic_bias(struct snd_soc_dapm_widget *w, struct snd_kcontrol *kcontrol, int event) { struct snd_soc_card *card = w->dapm->card; struct tm2_machine_priv *priv = snd_soc_card_get_drvdata(card); switch (event) { case SND_SOC_DAPM_PRE_PMU: gpiod_set_value_cansleep(priv->gpio_mic_bias, 1); break; case SND_SOC_DAPM_POST_PMD: gpiod_set_value_cansleep(priv->gpio_mic_bias, 0); break; } return 0; }
static void gpio_vibrator_stop(struct gpio_vibrator *vibrator) { gpiod_set_value_cansleep(vibrator->gpio, 0); if (vibrator->vcc_on) { regulator_disable(vibrator->vcc); vibrator->vcc_on = false; } }
static int ektf2127_start(struct input_dev *dev) { struct ektf2127_ts *ts = input_get_drvdata(dev); enable_irq(ts->client->irq); gpiod_set_value_cansleep(ts->power_gpios, 1); return 0; }
static int wm8524_mute_stream(struct snd_soc_dai *dai, int mute, int stream) { struct wm8524_priv *wm8524 = snd_soc_component_get_drvdata(dai->component); if (wm8524->mute) gpiod_set_value_cansleep(wm8524->mute, mute); return 0; }
static int tpd_read_edid(struct omap_dss_device *dssdev, u8 *edid, int len) { struct panel_drv_data *ddata = to_panel_data(dssdev); struct omap_dss_device *in = ddata->in; int r; if (!gpiod_get_value_cansleep(ddata->hpd_gpio)) return -ENODEV; gpiod_set_value_cansleep(ddata->ls_oe_gpio, 1); r = in->ops.hdmi->read_edid(in, edid, len); gpiod_set_value_cansleep(ddata->ls_oe_gpio, 0); return r; }
static void silead_ts_set_power(struct i2c_client *client, enum silead_ts_power state) { struct silead_ts_data *data = i2c_get_clientdata(client); if (data->gpio_power) { gpiod_set_value_cansleep(data->gpio_power, state); msleep(SILEAD_POWER_SLEEP); } }
static void gpio_poweroff_do_poweroff(void) { BUG_ON(!reset_gpio); /* drive it active, also inactive->active edge */ gpiod_direction_output(reset_gpio, 1); mdelay(active_delay); /* drive inactive, also active->inactive edge */ gpiod_set_value_cansleep(reset_gpio, 0); mdelay(inactive_delay); /* drive it active, also inactive->active edge */ gpiod_set_value_cansleep(reset_gpio, 1); /* give it some time */ mdelay(timeout); WARN_ON(1); }
static int sun4i_codec_spk_event(struct snd_soc_dapm_widget *w, struct snd_kcontrol *k, int event) { struct sun4i_codec *scodec = snd_soc_card_get_drvdata(w->dapm->card); if (scodec->gpio_pa) gpiod_set_value_cansleep(scodec->gpio_pa, !!SND_SOC_DAPM_EVENT_ON(event)); return 0; }
static int cs35l33_i2c_remove(struct i2c_client *client) { struct cs35l33_private *cs35l33 = i2c_get_clientdata(client); gpiod_set_value_cansleep(cs35l33->reset_gpio, 0); pm_runtime_disable(&client->dev); regulator_bulk_disable(cs35l33->num_core_supplies, cs35l33->core_supplies); return 0; }
static int cs35l32_i2c_remove(struct i2c_client *i2c_client) { struct cs35l32_private *cs35l32 = i2c_get_clientdata(i2c_client); snd_soc_unregister_codec(&i2c_client->dev); /* Hold down reset */ if (cs35l32->reset_gpio) gpiod_set_value_cansleep(cs35l32->reset_gpio, 0); return 0; }
static int phy_mdm6600_power_off(struct phy *x) { struct phy_mdm6600 *ddata = phy_get_drvdata(x); struct gpio_desc *enable_gpio = ddata->ctrl_gpios[PHY_MDM6600_ENABLE]; if (!ddata->enabled) return -ENODEV; gpiod_set_value_cansleep(enable_gpio, 0); return 0; }
static int __maybe_unused cs35l33_runtime_resume(struct device *dev) { struct cs35l33_private *cs35l33 = dev_get_drvdata(dev); int ret; dev_dbg(dev, "%s\n", __func__); if (cs35l33->reset_gpio) gpiod_set_value_cansleep(cs35l33->reset_gpio, 0); ret = regulator_bulk_enable(cs35l33->num_core_supplies, cs35l33->core_supplies); if (ret != 0) { dev_err(dev, "Failed to enable core supplies: %d\n", ret); return ret; } regcache_cache_only(cs35l33->regmap, false); if (cs35l33->reset_gpio) gpiod_set_value_cansleep(cs35l33->reset_gpio, 1); msleep(CS35L33_BOOT_DELAY); ret = regcache_sync(cs35l33->regmap); if (ret != 0) { dev_err(dev, "Failed to restore register cache\n"); goto err; } return 0; err: regcache_cache_only(cs35l33->regmap, true); regulator_bulk_disable(cs35l33->num_core_supplies, cs35l33->core_supplies); return ret; }
static int nokia_reset(struct hci_uart *hu) { struct nokia_bt_dev *btdev = hu->priv; struct device *dev = &btdev->serdev->dev; int err; /* reset routine */ gpiod_set_value_cansleep(btdev->reset, 1); gpiod_set_value_cansleep(btdev->wakeup_bt, 1); msleep(100); /* safety check */ err = gpiod_get_value_cansleep(btdev->wakeup_host); if (err == 1) { dev_err(dev, "reset: host wakeup not low!"); return -EPROTO; } /* flush queue */ serdev_device_write_flush(btdev->serdev); /* init uart */ nokia_flow_control(btdev->serdev, false); serdev_device_set_baudrate(btdev->serdev, INIT_BAUD_RATE); gpiod_set_value_cansleep(btdev->reset, 0); /* wait for cts */ err = serdev_device_wait_for_cts(btdev->serdev, true, 200); if (err < 0) { dev_err(dev, "CTS not received: %d", err); return err; } nokia_flow_control(btdev->serdev, true); return 0; }
static int xilinx_csc_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct resource *res; struct xilinx_csc *csc; int ret; csc = devm_kzalloc(dev, sizeof(*csc), GFP_KERNEL); if (!csc) return -ENOMEM; csc->dev = dev; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); csc->base = devm_ioremap_resource(dev, res); if (IS_ERR(csc->base)) return -ENOMEM; platform_set_drvdata(pdev, csc); ret = xcsc_parse_of(csc); if (ret < 0) return ret; ret = clk_prepare_enable(csc->aclk); if (ret) { dev_err(csc->dev, "failed to enable clock %d\n", ret); return ret; } gpiod_set_value_cansleep(csc->rst_gpio, XCSC_RESET_DEASSERT); csc->bridge.enable = &xilinx_csc_bridge_enable; csc->bridge.disable = &xilinx_csc_bridge_disable; csc->bridge.set_input = &xilinx_csc_bridge_set_input; csc->bridge.get_input_fmts = &xilinx_csc_bridge_get_input_fmts; csc->bridge.set_output = &xilinx_csc_bridge_set_output; csc->bridge.get_output_fmts = &xilinx_csc_bridge_get_output_fmts; csc->bridge.of_node = dev->of_node; ret = xlnx_bridge_register(&csc->bridge); if (ret) { dev_info(csc->dev, "Bridge registration failed\n"); goto err_clk; } dev_info(csc->dev, "Xilinx VPSS CSC DRM experimental driver probed\n"); return 0; err_clk: clk_disable_unprepare(csc->aclk); return ret; }
static int pixcir_set_power_mode(struct pixcir_i2c_ts_data *ts, enum pixcir_power_mode mode) { struct device *dev = &ts->client->dev; int ret; if (mode == PIXCIR_POWER_ACTIVE || mode == PIXCIR_POWER_IDLE) { if (ts->gpio_wake) gpiod_set_value_cansleep(ts->gpio_wake, 1); } ret = i2c_smbus_read_byte_data(ts->client, PIXCIR_REG_POWER_MODE); if (ret < 0) { dev_err(dev, "%s: can't read reg 0x%x : %d\n", __func__, PIXCIR_REG_POWER_MODE, ret); return ret; } ret &= ~PIXCIR_POWER_MODE_MASK; ret |= mode; /* Always AUTO_IDLE */ ret |= PIXCIR_POWER_ALLOW_IDLE; ret = i2c_smbus_write_byte_data(ts->client, PIXCIR_REG_POWER_MODE, ret); if (ret < 0) { dev_err(dev, "%s: can't write reg 0x%x : %d\n", __func__, PIXCIR_REG_POWER_MODE, ret); return ret; } if (mode == PIXCIR_POWER_HALT) { if (ts->gpio_wake) gpiod_set_value_cansleep(ts->gpio_wake, 0); } return 0; }
static int cs53l30_i2c_remove(struct i2c_client *client) { struct cs53l30_private *cs53l30 = i2c_get_clientdata(client); snd_soc_unregister_codec(&client->dev); /* Hold down reset */ gpiod_set_value_cansleep(cs53l30->reset_gpio, 0); regulator_bulk_disable(ARRAY_SIZE(cs53l30->supplies), cs53l30->supplies); return 0; }
static int cs53l30_runtime_suspend(struct device *dev) { struct cs53l30_private *cs53l30 = dev_get_drvdata(dev); regcache_cache_only(cs53l30->regmap, true); /* Hold down reset */ gpiod_set_value_cansleep(cs53l30->reset_gpio, 0); regulator_bulk_disable(ARRAY_SIZE(cs53l30->supplies), cs53l30->supplies); return 0; }
static int msm_otg_vbus_notifier(struct notifier_block *nb, unsigned long event, void *ptr) { struct msm_usb_cable *vbus = container_of(nb, struct msm_usb_cable, nb); struct msm_otg *motg = container_of(vbus, struct msm_otg, vbus); if (event) set_bit(B_SESS_VLD, &motg->inputs); else clear_bit(B_SESS_VLD, &motg->inputs); if (test_bit(B_SESS_VLD, &motg->inputs)) { /* Switch D+/D- lines to Device connector */ gpiod_set_value_cansleep(motg->switch_gpio, 0); } else { /* Switch D+/D- lines to Hub */ gpiod_set_value_cansleep(motg->switch_gpio, 1); } schedule_work(&motg->sm_work); return NOTIFY_DONE; }
static int __maybe_unused cs35l34_runtime_suspend(struct device *dev) { struct cs35l34_private *cs35l34 = dev_get_drvdata(dev); regcache_cache_only(cs35l34->regmap, true); regcache_mark_dirty(cs35l34->regmap); gpiod_set_value_cansleep(cs35l34->reset_gpio, 0); regulator_bulk_disable(cs35l34->num_core_supplies, cs35l34->core_supplies); return 0; }
static int xdmsc_s_stream(struct v4l2_subdev *subdev, int enable) { struct xdmsc_dev *xdmsc = to_xdmsc(subdev); if (!enable) { dev_dbg(xdmsc->xvip.dev, "%s : Off", __func__); gpiod_set_value_cansleep(xdmsc->rst_gpio, XDEMOSAIC_RESET_ASSERT); gpiod_set_value_cansleep(xdmsc->rst_gpio, XDEMOSAIC_RESET_DEASSERT); return 0; } xdmsc_write(xdmsc, XDEMOSAIC_WIDTH, xdmsc->formats[XVIP_PAD_SINK].width); xdmsc_write(xdmsc, XDEMOSAIC_HEIGHT, xdmsc->formats[XVIP_PAD_SINK].height); xdmsc_write(xdmsc, XDEMOSAIC_INPUT_BAYER_FORMAT, xdmsc->bayer_fmt); /* Start Demosaic Video IP */ xdmsc_write(xdmsc, XDEMOSAIC_AP_CTRL, XDEMOSAIC_STREAM_ON); return 0; }
static int cs35l34_i2c_remove(struct i2c_client *client) { struct cs35l34_private *cs35l34 = i2c_get_clientdata(client); snd_soc_unregister_codec(&client->dev); if (cs35l34->reset_gpio) gpiod_set_value_cansleep(cs35l34->reset_gpio, 0); pm_runtime_disable(&client->dev); regulator_bulk_disable(cs35l34->num_core_supplies, cs35l34->core_supplies); return 0; }
static int bdw_rt5677_event_hp(struct snd_soc_dapm_widget *w, struct snd_kcontrol *k, int event) { struct snd_soc_dapm_context *dapm = w->dapm; struct snd_soc_card *card = dapm->card; struct bdw_rt5677_priv *bdw_rt5677 = snd_soc_card_get_drvdata(card); if (SND_SOC_DAPM_EVENT_ON(event)) msleep(70); gpiod_set_value_cansleep(bdw_rt5677->gpio_hp_en, SND_SOC_DAPM_EVENT_ON(event)); return 0; }
static void panel_encoder_dpms(struct drm_encoder *encoder, int mode) { struct panel_encoder *panel_encoder = to_panel_encoder(encoder); struct backlight_device *backlight = panel_encoder->mod->backlight; struct gpio_desc *gpio = panel_encoder->mod->enable_gpio; if (backlight) { backlight->props.power = mode == DRM_MODE_DPMS_ON ? FB_BLANK_UNBLANK : FB_BLANK_POWERDOWN; backlight_update_status(backlight); } if (gpio) gpiod_set_value_cansleep(gpio, mode == DRM_MODE_DPMS_ON ? 1 : 0); }
static void opa362_disable(struct omap_dss_device *dssdev) { struct panel_drv_data *ddata = to_panel_data(dssdev); struct omap_dss_device *in = ddata->in; dev_dbg(dssdev->dev, "disable\n"); if (!omapdss_device_is_enabled(dssdev)) return; if (ddata->enable_gpio) gpiod_set_value_cansleep(ddata->enable_gpio, 0); in->ops.atv->disable(in); dssdev->state = OMAP_DSS_DISPLAY_DISABLED; }
static void panel_dpi_disable(struct omap_dss_device *dssdev) { struct panel_drv_data *ddata = to_panel_data(dssdev); struct omap_dss_device *src = dssdev->src; if (!omapdss_device_is_enabled(dssdev)) return; backlight_disable(ddata->backlight); gpiod_set_value_cansleep(ddata->enable_gpio, 0); regulator_disable(ddata->vcc_supply); src->ops->disable(src); dssdev->state = OMAP_DSS_DISPLAY_DISABLED; }
static int cs35l32_runtime_suspend(struct device *dev) { struct cs35l32_private *cs35l32 = dev_get_drvdata(dev); regcache_cache_only(cs35l32->regmap, true); regcache_mark_dirty(cs35l32->regmap); /* Hold down reset */ if (cs35l32->reset_gpio) gpiod_set_value_cansleep(cs35l32->reset_gpio, 0); /* remove power */ regulator_bulk_disable(ARRAY_SIZE(cs35l32->supplies), cs35l32->supplies); return 0; }
static int tse850_put_mux1(struct snd_kcontrol *kctrl, struct snd_ctl_elem_value *ucontrol) { struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kctrl); struct snd_soc_card *card = dapm->card; struct tse850_priv *tse850 = snd_soc_card_get_drvdata(card); struct soc_enum *e = (struct soc_enum *)kctrl->private_value; unsigned int val = ucontrol->value.enumerated.item[0]; if (val >= e->items) return -EINVAL; gpiod_set_value_cansleep(tse850->loop1, val); tse850->loop1_cache = val; return snd_soc_dapm_put_enum_double(kctrl, ucontrol); }
static int gpio_vibrator_start(struct gpio_vibrator *vibrator) { struct device *pdev = vibrator->input->dev.parent; int err; if (!vibrator->vcc_on) { err = regulator_enable(vibrator->vcc); if (err) { dev_err(pdev, "failed to enable regulator: %d\n", err); return err; } vibrator->vcc_on = true; } gpiod_set_value_cansleep(vibrator->gpio, 1); return 0; }