/* Enable/Disable IHF ext amplifier */ int spk_amp_event(struct snd_soc_dapm_widget *w, struct snd_kcontrol *k, int event) { if (mc_dev_ctx->spk_pin <= 0) return 0; switch (event) { case SND_SOC_DAPM_POST_PMU: xgold_debug("%s: SND_SOC_DAPM_PRE_PMU\n", __func__); if (mc_dev_ctx->spk_pin > 0) gpiod_set_value(gpio_to_desc(mc_dev_ctx->spk_pin), 1); break; case SND_SOC_DAPM_PRE_PMD: xgold_debug("%s: SND_SOC_DAPM_PRE_PMD\n", __func__); if (mc_dev_ctx->spk_pin > 0) gpiod_set_value(gpio_to_desc(mc_dev_ctx->spk_pin), 0); break; default: break; } return 0; }
/* * Enables given plates and measures touch parameters using ADC */ static int adc_ts_measure(struct iio_channel *channel, struct gpio_desc *plate_p, struct gpio_desc *plate_m) { int i, value = 0, val = 0; int error; gpiod_set_value(plate_p, 1); gpiod_set_value(plate_m, 1); usleep_range(COLI_TOUCH_MIN_DELAY_US, COLI_TOUCH_MAX_DELAY_US); for (i = 0; i < COLI_TOUCH_NO_OF_AVGS; i++) { error = iio_read_channel_raw(channel, &val); if (error < 0) { value = error; goto error_iio_read; } value += val; } value /= COLI_TOUCH_NO_OF_AVGS; error_iio_read: gpiod_set_value(plate_p, 0); gpiod_set_value(plate_m, 0); return value; }
static int __adp1653_set_power(struct adp1653_flash *flash, int on) { int ret; if (flash->platform_data->power) { ret = flash->platform_data->power(&flash->subdev, on); if (ret < 0) return ret; } else { gpiod_set_value(flash->platform_data->enable_gpio, on); if (on) /* Some delay is apparently required. */ udelay(20); } if (!on) return 0; ret = adp1653_init_device(flash); if (ret >= 0) return ret; if (flash->platform_data->power) flash->platform_data->power(&flash->subdev, 0); else gpiod_set_value(flash->platform_data->enable_gpio, 0); return ret; }
static void __mmc_pwrseq_emmc_reset(struct mmc_pwrseq_emmc *pwrseq) { gpiod_set_value(pwrseq->reset_gpio, 1); udelay(1); gpiod_set_value(pwrseq->reset_gpio, 0); udelay(200); }
static void at803x_link_change_notify(struct phy_device *phydev) { struct at803x_priv *priv = phydev->priv; /* * Conduct a hardware reset for AT8030 every time a link loss is * signalled. This is necessary to circumvent a hardware bug that * occurs when the cable is unplugged while TX packets are pending * in the FIFO. In such cases, the FIFO enters an error mode it * cannot recover from by software. */ if (phydev->drv->phy_id == ATH8030_PHY_ID) { if (phydev->state == PHY_NOLINK) { if (priv->gpiod_reset && !priv->phy_reset) { struct at803x_context context; at803x_context_save(phydev, &context); gpiod_set_value(priv->gpiod_reset, 0); msleep(1); gpiod_set_value(priv->gpiod_reset, 1); msleep(1); at803x_context_restore(phydev, &context); dev_dbg(&phydev->dev, "%s(): phy was reset\n", __func__); priv->phy_reset = true; } } else { priv->phy_reset = false; } } }
/** * sta350_set_bias_level - DAPM callback * @codec: the codec device * @level: DAPM power level * * This is called by ALSA to put the codec into low power mode * or to wake it up. If the codec is powered off completely * all registers must be restored after power on. */ static int sta350_set_bias_level(struct snd_soc_codec *codec, enum snd_soc_bias_level level) { struct sta350_priv *sta350 = snd_soc_codec_get_drvdata(codec); int ret; dev_dbg(codec->dev, "level = %d\n", level); switch (level) { case SND_SOC_BIAS_ON: break; case SND_SOC_BIAS_PREPARE: /* Full power on */ regmap_update_bits(sta350->regmap, STA350_CONFF, STA350_CONFF_PWDN | STA350_CONFF_EAPD, STA350_CONFF_PWDN | STA350_CONFF_EAPD); break; case SND_SOC_BIAS_STANDBY: if (codec->dapm.bias_level == SND_SOC_BIAS_OFF) { ret = regulator_bulk_enable( ARRAY_SIZE(sta350->supplies), sta350->supplies); if (ret < 0) { dev_err(codec->dev, "Failed to enable supplies: %d\n", ret); return ret; } sta350_startup_sequence(sta350); sta350_cache_sync(codec); } /* Power down */ regmap_update_bits(sta350->regmap, STA350_CONFF, STA350_CONFF_PWDN | STA350_CONFF_EAPD, 0); break; case SND_SOC_BIAS_OFF: /* The chip runs through the power down sequence for us */ regmap_update_bits(sta350->regmap, STA350_CONFF, STA350_CONFF_PWDN | STA350_CONFF_EAPD, 0); /* power down: low */ if (sta350->gpiod_power_down) gpiod_set_value(sta350->gpiod_power_down, 0); if (sta350->gpiod_nreset) gpiod_set_value(sta350->gpiod_nreset, 0); regulator_bulk_disable(ARRAY_SIZE(sta350->supplies), sta350->supplies); break; } codec->dapm.bias_level = level; return 0; }
static void nop_reset(struct usb_phy_generic *nop) { if (!nop->gpiod_reset) return; gpiod_set_value(nop->gpiod_reset, 1); usleep_range(10000, 20000); gpiod_set_value(nop->gpiod_reset, 0); }
static int sta32x_startup_sequence(struct sta32x_priv *sta32x) { if (sta32x->gpiod_nreset) { gpiod_set_value(sta32x->gpiod_nreset, 0); mdelay(1); gpiod_set_value(sta32x->gpiod_nreset, 1); mdelay(1); } return 0; }
static void sis_ts_reset(struct sis_ts_data *ts) { if (ts->reset_gpio) { /* Get out of reset */ usleep_range(1000, 2000); gpiod_set_value(ts->reset_gpio, 1); usleep_range(1000, 2000); gpiod_set_value(ts->reset_gpio, 0); msleep(100); } }
static void send_bits(struct pimhyp3_ts_data *ts, uint16_t data, uint16_t count) { int x; int mask = 1 << (count-1); for(x = 0; x < count; x++){ gpiod_set_value(ts->gpiod_mosi,(data & mask) > 0); data <<= 1; gpiod_set_value(ts->gpiod_int, 0); udelay(uDELAY); gpiod_set_value(ts->gpiod_int, 1); udelay(uDELAY); } gpiod_set_value(ts->gpiod_mosi,0); }
static int sta350_startup_sequence(struct sta350_priv *sta350) { if (sta350->gpiod_power_down) gpiod_set_value(sta350->gpiod_power_down, 1); if (sta350->gpiod_nreset) { gpiod_set_value(sta350->gpiod_nreset, 0); mdelay(1); gpiod_set_value(sta350->gpiod_nreset, 1); mdelay(1); } return 0; }
static void edp_ctrl_phy_aux_enable(struct edp_ctrl *ctrl, int enable) { if (enable) { edp_regulator_enable(ctrl); edp_clk_enable(ctrl, EDP_CLK_MASK_AUX_CHAN); msm_edp_phy_ctrl(ctrl->phy, 1); msm_edp_aux_ctrl(ctrl->aux, 1); gpiod_set_value(ctrl->panel_en_gpio, 1); } else { gpiod_set_value(ctrl->panel_en_gpio, 0); msm_edp_aux_ctrl(ctrl->aux, 0); msm_edp_phy_ctrl(ctrl->phy, 0); edp_clk_disable(ctrl, EDP_CLK_MASK_AUX_CHAN); edp_regulator_disable(ctrl); } }
static int st_nci_spi_enable(void *phy_id) { struct st_nci_spi_phy *phy = phy_id; gpiod_set_value(phy->gpiod_reset, 0); usleep_range(10000, 15000); gpiod_set_value(phy->gpiod_reset, 1); usleep_range(80000, 85000); if (phy->ndlc->powered == 0 && phy->irq_active == 0) { enable_irq(phy->spi_dev->irq); phy->irq_active = true; } return 0; }
/* * Requires arche_pdata->platform_state_mutex to be held */ static int arche_platform_coldboot_seq(struct arche_platform_drvdata *arche_pdata) { int ret; if (arche_pdata->state == ARCHE_PLATFORM_STATE_ACTIVE) return 0; dev_info(arche_pdata->dev, "Booting from cold boot state\n"); svc_reset_onoff(arche_pdata->svc_reset, arche_pdata->is_reset_act_hi); gpiod_set_value(arche_pdata->svc_sysboot, 0); usleep_range(100, 200); ret = clk_prepare_enable(arche_pdata->svc_ref_clk); if (ret) { dev_err(arche_pdata->dev, "failed to enable svc_ref_clk: %d\n", ret); return ret; } /* bring SVC out of reset */ svc_reset_onoff(arche_pdata->svc_reset, !arche_pdata->is_reset_act_hi); arche_platform_set_state(arche_pdata, ARCHE_PLATFORM_STATE_ACTIVE); return 0; }
/* * Requires arche_pdata->platform_state_mutex to be held */ static int arche_platform_fw_flashing_seq(struct arche_platform_drvdata *arche_pdata) { int ret; if (arche_pdata->state == ARCHE_PLATFORM_STATE_FW_FLASHING) return 0; dev_info(arche_pdata->dev, "Switching to FW flashing state\n"); svc_reset_onoff(arche_pdata->svc_reset, arche_pdata->is_reset_act_hi); gpiod_set_value(arche_pdata->svc_sysboot, 1); usleep_range(100, 200); ret = clk_prepare_enable(arche_pdata->svc_ref_clk); if (ret) { dev_err(arche_pdata->dev, "failed to enable svc_ref_clk: %d\n", ret); return ret; } svc_reset_onoff(arche_pdata->svc_reset, !arche_pdata->is_reset_act_hi); arche_platform_set_state(arche_pdata, ARCHE_PLATFORM_STATE_FW_FLASHING); return 0; }
static int write_vmem(struct fbtft_par *par, size_t offset, size_t len) { u16 *vmem16 = (u16 *)par->info->screen_buffer; u8 *buf = par->txbuf.buf; int x, y, i; int ret; for (x = 0; x < par->info->var.xres; x++) { for (y = 0; y < par->info->var.yres / 8; y++) { *buf = 0x00; for (i = 0; i < 8; i++) *buf |= (vmem16[(y * 8 + i) * par->info->var.xres + x] ? 1 : 0) << i; buf++; } } /* Write data */ gpiod_set_value(par->gpio.dc, 1); ret = par->fbtftops.write(par, par->txbuf.buf, par->info->var.xres * par->info->var.yres / 8); if (ret < 0) dev_err(par->info->device, "write failed and returned: %d\n", ret); return ret; }
static int clk_gpio_mux_set_parent(struct clk_hw *hw, u8 index) { struct clk_gpio *clk = to_clk_gpio(hw); gpiod_set_value(clk->gpiod, index); return 0; }
static int clk_gpio_gate_enable(struct clk_hw *hw) { struct clk_gpio *clk = to_clk_gpio(hw); gpiod_set_value(clk->gpiod, 1); return 0; }
static int s6e8aa0_power_on(struct s6e8aa0 *ctx) { int ret; ret = regulator_bulk_enable(ARRAY_SIZE(ctx->supplies), ctx->supplies); if (ret < 0) return ret; msleep(ctx->power_on_delay); gpiod_set_value(ctx->reset_gpio, 0); usleep_range(10000, 11000); gpiod_set_value(ctx->reset_gpio, 1); msleep(ctx->reset_delay); return 0; }
static void bcma_hci_platform_power_gpio(struct bcma_device *dev, bool val) { struct bcma_hcd_device *usb_dev = bcma_get_drvdata(dev); if (IS_ERR_OR_NULL(usb_dev->gpio_desc)) return; gpiod_set_value(usb_dev->gpio_desc, val); }
/** * sta32x_set_bias_level - DAPM callback * @codec: the codec device * @level: DAPM power level * * This is called by ALSA to put the codec into low power mode * or to wake it up. If the codec is powered off completely * all registers must be restored after power on. */ static int sta32x_set_bias_level(struct snd_soc_codec *codec, enum snd_soc_bias_level level) { int ret; struct sta32x_priv *sta32x = snd_soc_codec_get_drvdata(codec); dev_dbg(codec->dev, "level = %d\n", level); switch (level) { case SND_SOC_BIAS_ON: break; case SND_SOC_BIAS_PREPARE: /* Full power on */ regmap_update_bits(sta32x->regmap, STA32X_CONFF, STA32X_CONFF_PWDN | STA32X_CONFF_EAPD, STA32X_CONFF_PWDN | STA32X_CONFF_EAPD); break; case SND_SOC_BIAS_STANDBY: if (snd_soc_codec_get_bias_level(codec) == SND_SOC_BIAS_OFF) { ret = regulator_bulk_enable(ARRAY_SIZE(sta32x->supplies), sta32x->supplies); if (ret != 0) { dev_err(codec->dev, "Failed to enable supplies: %d\n", ret); return ret; } sta32x_startup_sequence(sta32x); sta32x_cache_sync(codec); sta32x_watchdog_start(sta32x); } /* Power down */ regmap_update_bits(sta32x->regmap, STA32X_CONFF, STA32X_CONFF_PWDN | STA32X_CONFF_EAPD, 0); break; case SND_SOC_BIAS_OFF: /* The chip runs through the power down sequence for us. */ regmap_update_bits(sta32x->regmap, STA32X_CONFF, STA32X_CONFF_PWDN | STA32X_CONFF_EAPD, 0); msleep(300); sta32x_watchdog_stop(sta32x); if (sta32x->gpiod_nreset) gpiod_set_value(sta32x->gpiod_nreset, 0); regulator_bulk_disable(ARRAY_SIZE(sta32x->supplies), sta32x->supplies); break; } return 0; }
static int hx711_reset(struct hx711_data *hx711_data) { int ret; int val = gpiod_get_value(hx711_data->gpiod_dout); if (val) { /* * an examination with the oszilloscope indicated * that the first value read after the reset is not stable * if we reset too short; * the shorter the reset cycle * the less reliable the first value after reset is; * there were no problems encountered with a value * of 10 ms or higher */ gpiod_set_value(hx711_data->gpiod_pd_sck, 1); msleep(10); gpiod_set_value(hx711_data->gpiod_pd_sck, 0); ret = hx711_wait_for_ready(hx711_data); if (ret) return ret; /* * after a reset the gain is 128 so we do a dummy read * to set the gain for the next read */ ret = hx711_read(hx711_data); if (ret < 0) return ret; /* * after a dummy read we need to wait vor readiness * for not mixing gain pulses with the clock */ ret = hx711_wait_for_ready(hx711_data); if (ret) return ret; } return val; }
static int s6e3ha2_power_on(struct s6e3ha2 *ctx) { int ret; ret = regulator_bulk_enable(ARRAY_SIZE(ctx->supplies), ctx->supplies); if (ret < 0) return ret; msleep(120); gpiod_set_value(ctx->enable_gpio, 0); usleep_range(5000, 6000); gpiod_set_value(ctx->enable_gpio, 1); gpiod_set_value(ctx->reset_gpio, 1); usleep_range(5000, 6000); gpiod_set_value(ctx->reset_gpio, 0); usleep_range(5000, 6000); return 0; }
static int nokia_close(struct hci_uart *hu) { struct nokia_bt_dev *btdev = hu->priv; struct device *dev = &btdev->serdev->dev; dev_dbg(dev, "close device"); btdev->initialized = false; skb_queue_purge(&btdev->txq); kfree_skb(btdev->rx_skb); /* disable module */ gpiod_set_value(btdev->reset, 1); gpiod_set_value(btdev->wakeup_bt, 0); pm_runtime_disable(&btdev->serdev->dev); serdev_device_close(btdev->serdev); return 0; }
/* * Enable touch detection using falling edge detection on XM */ static void vf50_ts_enable_touch_detection(struct vf50_touch_device *vf50_ts) { /* Enable plate YM (needs to be strong GND, high active) */ gpiod_set_value(vf50_ts->gpio_ym, 1); /* * Let the platform mux to idle state in order to enable * Pull-Up on GPIO */ pinctrl_pm_select_idle_state(&vf50_ts->pdev->dev); /* Wait for the pull-up to be stable on high */ usleep_range(COLI_PULLUP_MIN_DELAY_US, COLI_PULLUP_MAX_DELAY_US); }
void usb_gen_phy_shutdown(struct usb_phy *phy) { struct usb_phy_generic *nop = dev_get_drvdata(phy->dev); gpiod_set_value(nop->gpiod_reset, 1); if (!IS_ERR(nop->clk)) clk_disable_unprepare(nop->clk); if (!IS_ERR(nop->vcc)) { if (regulator_disable(nop->vcc)) dev_err(phy->dev, "Failed to disable power\n"); } }
static int hx711_cycle(struct hx711_data *hx711_data) { int val; /* * if preempted for more then 60us while PD_SCK is high: * hx711 is going in reset * ==> measuring is false */ preempt_disable(); gpiod_set_value(hx711_data->gpiod_pd_sck, 1); val = gpiod_get_value(hx711_data->gpiod_dout); /* * here we are not waiting for 0.2 us as suggested by the datasheet, * because the oscilloscope showed in a test scenario * at least 1.15 us for PD_SCK high (T3 in datasheet) * and 0.56 us for PD_SCK low on TI Sitara with 800 MHz */ gpiod_set_value(hx711_data->gpiod_pd_sck, 0); preempt_enable(); return val; }
static void rx51_ext_control(struct snd_soc_dapm_context *dapm) { struct snd_soc_card *card = dapm->card; struct rx51_audio_pdata *pdata = snd_soc_card_get_drvdata(card); int hp = 0, hs = 0, tvout = 0; switch (rx51_jack_func) { case RX51_JACK_TVOUT: tvout = 1; hp = 1; break; case RX51_JACK_HS: hs = 1; case RX51_JACK_HP: hp = 1; break; } snd_soc_dapm_mutex_lock(dapm); if (rx51_spk_func) snd_soc_dapm_enable_pin_unlocked(dapm, "Ext Spk"); else snd_soc_dapm_disable_pin_unlocked(dapm, "Ext Spk"); if (rx51_dmic_func) snd_soc_dapm_enable_pin_unlocked(dapm, "DMic"); else snd_soc_dapm_disable_pin_unlocked(dapm, "DMic"); if (hp) snd_soc_dapm_enable_pin_unlocked(dapm, "Headphone Jack"); else snd_soc_dapm_disable_pin_unlocked(dapm, "Headphone Jack"); if (hs) snd_soc_dapm_enable_pin_unlocked(dapm, "HS Mic"); else snd_soc_dapm_disable_pin_unlocked(dapm, "HS Mic"); gpiod_set_value(pdata->tvout_selection_gpio, tvout); snd_soc_dapm_sync_unlocked(dapm); snd_soc_dapm_mutex_unlock(dapm); }
/* * si4713_powerdown - Powers the device down * @sdev: si4713_device structure for the device we are communicating */ static int si4713_powerdown(struct si4713_device *sdev) { int err; u8 resp[SI4713_PWDN_NRESP]; if (!sdev->power_state) return 0; err = si4713_send_command(sdev, SI4713_CMD_POWER_DOWN, NULL, 0, resp, ARRAY_SIZE(resp), DEFAULT_TIMEOUT); if (!err) { v4l2_dbg(1, debug, &sdev->sd, "Power down response: 0x%02x\n", resp[0]); v4l2_dbg(1, debug, &sdev->sd, "Device in reset mode\n"); if (sdev->gpio_reset) gpiod_set_value(sdev->gpio_reset, 0); if (sdev->vdd) { err = regulator_disable(sdev->vdd); if (err) { v4l2_err(&sdev->sd, "Failed to disable vdd: %d\n", err); } } if (sdev->vio) { err = regulator_disable(sdev->vio); if (err) { v4l2_err(&sdev->sd, "Failed to disable vio: %d\n", err); } } sdev->power_state = POWER_OFF; } return err; }
static void asc_set_mctrl(struct uart_port *port, unsigned int mctrl) { struct asc_port *ascport = to_asc_port(port); /* * This routine is used for seting signals of: DTR, DCD, CTS and RTS. * We use ASC's hardware for CTS/RTS when hardware flow-control is * enabled, however if the RTS line is required for another purpose, * commonly controlled using HUP from userspace, then we need to toggle * it manually, using GPIO. * * Some boards also have DTR and DCD implemented using PIO pins, code to * do this should be hooked in here. */ if (!ascport->rts) return; /* If HW flow-control is enabled, we can't fiddle with the RTS line */ if (asc_in(port, ASC_CTL) & ASC_CTL_CTSENABLE) return; gpiod_set_value(ascport->rts, mctrl & TIOCM_RTS); }