本文整理汇总了C++中regulator_enable函数的典型用法代码示例。如果您正苦于以下问题:C++ regulator_enable函数的具体用法?C++ regulator_enable怎么用?C++ regulator_enable使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了regulator_enable函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: __ads7846_enable
/* Must be called with ts->lock held */
static void __ads7846_enable(struct ads7846 *ts)
{
regulator_enable(ts->reg);
ads7846_restart(ts);
}
示例2: akm8975_power_on
static int akm8975_power_on(void)
{
if (akm8975_regulator)
return regulator_enable(akm8975_regulator);
return -ENXIO;
}
示例3: usbphy_attach
static int
usbphy_attach(device_t dev)
{
struct usbphy_softc * sc;
int rid, rv;
phandle_t node;
sc = device_get_softc(dev);
sc->dev = dev;
rid = 0;
sc->mem_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid,
RF_ACTIVE | RF_SHAREABLE);
if (sc->mem_res == NULL) {
device_printf(dev, "Cannot allocate memory resources\n");
return (ENXIO);
}
rid = 1;
sc->pads_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid,
RF_ACTIVE | RF_SHAREABLE);
if (sc->mem_res == NULL) {
device_printf(dev, "Cannot allocate memory resources\n");
return (ENXIO);
}
node = ofw_bus_get_node(dev);
rv = hwreset_get_by_ofw_name(sc->dev, "usb", &sc->reset_usb);
if (rv != 0) {
device_printf(dev, "Cannot get 'usb' reset\n");
return (ENXIO);
}
rv = hwreset_get_by_ofw_name(sc->dev, "utmi-pads", &sc->reset_pads);
if (rv != 0) {
device_printf(dev, "Cannot get 'utmi-pads' reset\n");
return (ENXIO);
}
rv = clk_get_by_ofw_name(sc->dev, "reg", &sc->clk_reg);
if (rv != 0) {
device_printf(sc->dev, "Cannot get 'reg' clock\n");
return (ENXIO);
}
rv = clk_get_by_ofw_name(sc->dev, "pll_u", &sc->clk_pllu);
if (rv != 0) {
device_printf(sc->dev, "Cannot get 'pll_u' clock\n");
return (ENXIO);
}
rv = clk_get_by_ofw_name(sc->dev, "utmi-pads", &sc->clk_pads);
if (rv != 0) {
device_printf(sc->dev, "Cannot get 'utmi-pads' clock\n");
return (ENXIO);
}
rv = hwreset_deassert(sc->reset_usb);
if (rv != 0) {
device_printf(dev, "Cannot unreset 'usb' reset\n");
return (ENXIO);
}
rv = clk_enable(sc->clk_pllu);
if (rv != 0) {
device_printf(sc->dev, "Cannot enable 'pllu' clock\n");
return (ENXIO);
}
rv = clk_enable(sc->clk_reg);
if (rv != 0) {
device_printf(sc->dev, "Cannot enable 'reg' clock\n");
return (ENXIO);
}
if (OF_hasprop(node, "nvidia,has-utmi-pad-registers"))
sc->have_utmi_regs = true;
sc->dr_mode = usb_get_dr_mode(dev, node, "dr_mode");
if (sc->dr_mode == USB_DR_MODE_UNKNOWN)
sc->dr_mode = USB_DR_MODE_HOST;
sc->ifc_type = usb_get_ifc_mode(dev, node, "phy_type");
/* We supports only utmi phy mode for now .... */
if (sc->ifc_type != USB_IFC_TYPE_UTMI) {
device_printf(dev, "Unsupported phy type\n");
return (ENXIO);
}
rv = usbphy_utmi_read_params(sc, node);
if (rv < 0)
return rv;
if (OF_hasprop(node, "vbus-supply")) {
rv = regulator_get_by_ofw_property(sc->dev, "vbus-supply",
&sc->supply_vbus);
if (rv != 0) {
device_printf(sc->dev,
"Cannot get \"vbus\" regulator\n");
return (ENXIO);
}
rv = regulator_enable(sc->supply_vbus);
if (rv != 0) {
device_printf(sc->dev,
//.........这里部分代码省略.........
示例4: s5p_tv_probe
static int __devinit s5p_tv_probe(struct platform_device *pdev)
{
int irq_num;
int ret;
int i, retval;
/* Get csis power domain regulator */
s5ptv_status.tv_regulator = regulator_get(&pdev->dev, "pd");
if (IS_ERR(s5ptv_status.tv_regulator)) {
printk(KERN_ERR "%s %d: failed to get resource %s\n",
__func__, __LINE__, "s3c-tv20 pd");
return PTR_ERR(s5ptv_status.tv_regulator);
}
s5ptv_status.tv_tvout = regulator_get(NULL, "tvout");
if (IS_ERR(s5ptv_status.tv_tvout)) {
printk(KERN_ERR "%s %d: failed to get resource %s\n",
__func__, __LINE__, "s3c-tv20 tvout");
return PTR_ERR(s5ptv_status.tv_tvout);
}
#ifdef CONFIG_MACH_P1
s5ptv_status.tv_tv = regulator_get(NULL, "tv");
if (IS_ERR(s5ptv_status.tv_tv)) {
printk(KERN_ERR "%s %d: failed to get resource %s\n",
__func__, __LINE__, "s3c-tv20 tv");
return PTR_ERR(s5ptv_status.tv_tv);
}
regulator_enable(s5ptv_status.tv_tv);
#endif
s5ptv_status.dev_fb = &pdev->dev;
__s5p_sdout_probe(pdev, 0);
__s5p_vp_probe(pdev, 1);
__s5p_mixer_probe(pdev, 2);
#ifdef CONFIG_CPU_S5PC100
__s5p_hdmi_probe(pdev, 3);
__s5p_tvclk_probe(pdev, 4);
#endif
#ifdef CONFIG_CPU_S5PV210
tv_clk_get(pdev, &s5ptv_status);
s5p_tv_clk_gate(true);
__s5p_hdmi_probe(pdev, 3, 4);
__s5p_hdcp_init();
#endif
#if defined(CONFIG_MACH_P1)
retval = i2c_add_driver(&SII9234A_i2c_driver);
if (retval != 0)
printk(KERN_ERR "[MHL SII9234A] can't add i2c driver");
retval = i2c_add_driver(&SII9234B_i2c_driver);
if (retval != 0)
printk(KERN_ERR "[MHL SII9234B] can't add i2c driver");
retval = i2c_add_driver(&SII9234C_i2c_driver);
if (retval != 0)
printk(KERN_ERR "[MHL SII9234C] can't add i2c driver");
retval = i2c_add_driver(&SII9234_i2c_driver);
if (retval != 0)
printk(KERN_ERR "[MHL SII9234] can't add i2c driver");
#endif
#ifdef FIX_27M_UNSTABLE_ISSUE /* for smdkc100 pop */
writel(0x1, S5PC1XX_GPA0_BASE + 0x56c);
#endif
#ifdef I2C_BASE
/* for dev_dbg err. */
spin_lock_init(&slock_hpd);
/* for bh */
INIT_WORK(&ws_hpd, (void *)set_ddc_port);
#endif
/* check EINT init state */
#ifdef CONFIG_CPU_S5PC100
s3c_gpio_cfgpin(S5PC1XX_GPH0(5), S3C_GPIO_SFN(2));
s3c_gpio_setpull(S5PC1XX_GPH0(5), S3C_GPIO_PULL_UP);
s5ptv_status.hpd_status = gpio_get_value(S5PC1XX_GPH0(5)) ? \
false : true;
#endif
#ifdef CONFIG_CPU_S5PV210
#ifdef CONFIG_HDMI_HPD
s5ptv_status.hpd_status = 0;
#else
s5ptv_status.hpd_status = 0;
#endif
#endif
dev_info(&pdev->dev, "hpd status: cable %s\n",\
s5ptv_status.hpd_status ? "inserted":"removed/not connected");
/* Interrupt */
TVOUT_IRQ_INIT(irq_num, ret, pdev, 0, out, __s5p_mixer_irq, "mixer");
TVOUT_IRQ_INIT(irq_num, ret, pdev, 1, out_hdmi_irq, __s5p_hdmi_irq , \
"hdmi");
//.........这里部分代码省略.........
示例5: dwc3_otg_start_host
/**
* dwc3_otg_start_host - helper function for starting/stoping the host controller driver.
*
* @otg: Pointer to the otg_transceiver structure.
* @on: start / stop the host controller driver.
*
* Returns 0 on success otherwise negative errno.
*/
static int dwc3_otg_start_host(struct usb_otg *otg, int on)
{
struct dwc3_otg *dotg = container_of(otg, struct dwc3_otg, otg);
struct dwc3_ext_xceiv *ext_xceiv = dotg->ext_xceiv;
struct dwc3 *dwc = dotg->dwc;
struct usb_hcd *hcd;
int ret = 0;
if (!dwc->xhci)
return -EINVAL;
if (!dotg->vbus_otg) {
dotg->vbus_otg = devm_regulator_get(dwc->dev->parent,
"vbus_dwc3");
if (IS_ERR(dotg->vbus_otg)) {
dev_err(dwc->dev, "Failed to get vbus regulator\n");
ret = PTR_ERR(dotg->vbus_otg);
dotg->vbus_otg = 0;
return ret;
}
}
if (on) {
dev_dbg(otg->phy->dev, "%s: turn on host\n", __func__);
dwc3_otg_notify_host_mode(otg, on);
usb_phy_notify_connect(dotg->dwc->usb2_phy, USB_SPEED_HIGH);
ret = regulator_enable(dotg->vbus_otg);
if (ret) {
dev_err(otg->phy->dev, "unable to enable vbus_otg\n");
dwc3_otg_notify_host_mode(otg, 0);
return ret;
}
dwc3_set_mode(dwc, DWC3_GCTL_PRTCAP_HOST);
/*
* FIXME If micro A cable is disconnected during system suspend,
* xhci platform device will be removed before runtime pm is
* enabled for xhci device. Due to this, disable_depth becomes
* greater than one and runtimepm is not enabled for next microA
* connect. Fix this by calling pm_runtime_init for xhci device.
*/
pm_runtime_init(&dwc->xhci->dev);
ret = platform_device_add(dwc->xhci);
if (ret) {
dev_err(otg->phy->dev,
"%s: failed to add XHCI pdev ret=%d\n",
__func__, ret);
regulator_disable(dotg->vbus_otg);
dwc3_otg_notify_host_mode(otg, 0);
return ret;
}
hcd = platform_get_drvdata(dwc->xhci);
dwc3_otg_set_host(otg, &hcd->self);
/* re-init OTG EVTEN register as XHCI reset clears it */
if (ext_xceiv && !ext_xceiv->otg_capability)
dwc3_otg_reset(dotg);
dwc3_gadget_usb3_phy_suspend(dwc, true);
} else {
dev_dbg(otg->phy->dev, "%s: turn off host\n", __func__);
ret = regulator_disable(dotg->vbus_otg);
if (ret) {
dev_err(otg->phy->dev, "unable to disable vbus_otg\n");
return ret;
}
dbg_event(0xFF, "StHost get", 0);
pm_runtime_get(dwc->dev);
usb_phy_notify_disconnect(dotg->dwc->usb2_phy, USB_SPEED_HIGH);
dwc3_otg_notify_host_mode(otg, on);
dwc3_otg_set_host(otg, NULL);
platform_device_del(dwc->xhci);
/*
* Perform USB hardware RESET (both core reset and DBM reset)
* when moving from host to peripheral. This is required for
* peripheral mode to work.
*/
if (ext_xceiv && ext_xceiv->otg_capability &&
ext_xceiv->ext_block_reset)
ext_xceiv->ext_block_reset(ext_xceiv, true);
dwc3_gadget_usb3_phy_suspend(dwc, false);
dwc3_set_mode(dwc, DWC3_GCTL_PRTCAP_DEVICE);
/* re-init core and OTG registers as block reset clears these */
dwc3_post_host_reset_core_init(dwc);
//.........这里部分代码省略.........
示例6: ad7298_probe
static int ad7298_probe(struct spi_device *spi)
{
struct ad7298_platform_data *pdata = spi->dev.platform_data;
struct ad7298_state *st;
struct iio_dev *indio_dev = iio_device_alloc(sizeof(*st));
int ret;
if (indio_dev == NULL)
return -ENOMEM;
st = iio_priv(indio_dev);
if (pdata && pdata->ext_ref)
st->ext_ref = AD7298_EXTREF;
if (st->ext_ref) {
st->reg = regulator_get(&spi->dev, "vref");
if (IS_ERR(st->reg)) {
ret = PTR_ERR(st->reg);
goto error_free;
}
ret = regulator_enable(st->reg);
if (ret)
goto error_put_reg;
}
spi_set_drvdata(spi, indio_dev);
st->spi = spi;
indio_dev->name = spi_get_device_id(spi)->name;
indio_dev->dev.parent = &spi->dev;
indio_dev->modes = INDIO_DIRECT_MODE;
indio_dev->channels = ad7298_channels;
indio_dev->num_channels = ARRAY_SIZE(ad7298_channels);
indio_dev->info = &ad7298_info;
/* Setup default message */
st->scan_single_xfer[0].tx_buf = &st->tx_buf[0];
st->scan_single_xfer[0].len = 2;
st->scan_single_xfer[0].cs_change = 1;
st->scan_single_xfer[1].tx_buf = &st->tx_buf[1];
st->scan_single_xfer[1].len = 2;
st->scan_single_xfer[1].cs_change = 1;
st->scan_single_xfer[2].rx_buf = &st->rx_buf[0];
st->scan_single_xfer[2].len = 2;
spi_message_init(&st->scan_single_msg);
spi_message_add_tail(&st->scan_single_xfer[0], &st->scan_single_msg);
spi_message_add_tail(&st->scan_single_xfer[1], &st->scan_single_msg);
spi_message_add_tail(&st->scan_single_xfer[2], &st->scan_single_msg);
ret = iio_triggered_buffer_setup(indio_dev, NULL,
&ad7298_trigger_handler, NULL);
if (ret)
goto error_disable_reg;
ret = iio_device_register(indio_dev);
if (ret)
goto error_cleanup_ring;
return 0;
error_cleanup_ring:
iio_triggered_buffer_cleanup(indio_dev);
error_disable_reg:
if (st->ext_ref)
regulator_disable(st->reg);
error_put_reg:
if (st->ext_ref)
regulator_put(st->reg);
error_free:
iio_device_free(indio_dev);
return ret;
}
示例7: init_mali_clock
static mali_bool init_mali_clock(void)
{
mali_bool ret = MALI_TRUE;
gpu_power_state = 0;
if (mali_clock != 0)
return ret; // already initialized
mali_dvfs_lock = _mali_osk_lock_init(_MALI_OSK_LOCKFLAG_NONINTERRUPTABLE
| _MALI_OSK_LOCKFLAG_ONELOCK, 0, 0);
if (mali_dvfs_lock == NULL)
return _MALI_OSK_ERR_FAULT;
if (mali_clk_set_rate(mali_gpu_clk, GPU_MHZ) == MALI_FALSE)
{
ret = MALI_FALSE;
goto err_clock_get;
}
MALI_PRINT(("init_mali_clock mali_clock %p \n", mali_clock));
#ifdef CONFIG_REGULATOR
#if USING_MALI_PMM
g3d_regulator = regulator_get(&mali_gpu_device.dev, "vdd_g3d");
#else
g3d_regulator = regulator_get(NULL, "vdd_g3d");
#endif
if (IS_ERR(g3d_regulator))
{
MALI_PRINT( ("MALI Error : failed to get vdd_g3d\n"));
ret = MALI_FALSE;
goto err_regulator;
}
regulator_enable(g3d_regulator);
MALI_DEBUG_PRINT(1, ("= regulator_enable -> use cnt: %d \n",mali_regulator_get_usecount()));
mali_regulator_set_voltage(mali_gpu_vol, mali_gpu_vol);
#endif
MALI_DEBUG_PRINT(2, ("MALI Clock is set at mali driver\n"));
MALI_DEBUG_PRINT(3,("::clk_put:: %s mali_parent_clock - normal\n", __FUNCTION__));
MALI_DEBUG_PRINT(3,("::clk_put:: %s mpll_clock - normal\n", __FUNCTION__));
mali_clk_put(MALI_FALSE);
return MALI_TRUE;
#ifdef CONFIG_REGULATOR
err_regulator:
regulator_put(g3d_regulator);
#endif
err_clock_get:
mali_clk_put(MALI_TRUE);
return ret;
}
示例8: update_vdd
/* Update voltage level given the current votes. */
static int update_vdd(struct clk_vdd_class *vdd_class)
{
int level, rc = 0, i, ignore;
struct regulator **r = vdd_class->regulator;
int *uv = vdd_class->vdd_uv;
int *ua = vdd_class->vdd_ua;
int n_reg = vdd_class->num_regulators;
int cur_lvl = vdd_class->cur_level;
int max_lvl = vdd_class->num_levels - 1;
int cur_base = cur_lvl * n_reg;
int new_base;
/* aggregate votes */
for (level = max_lvl; level > 0; level--)
if (vdd_class->level_votes[level])
break;
if (level == cur_lvl)
return 0;
max_lvl = max_lvl * n_reg;
new_base = level * n_reg;
for (i = 0; i < vdd_class->num_regulators; i++) {
rc = regulator_set_voltage(r[i], uv[new_base + i],
uv[max_lvl + i]);
if (rc)
goto set_voltage_fail;
if (ua) {
rc = regulator_set_optimum_mode(r[i], ua[new_base + i]);
rc = rc > 0 ? 0 : rc;
if (rc)
goto set_mode_fail;
}
if (cur_lvl == 0 || cur_lvl == vdd_class->num_levels)
rc = regulator_enable(r[i]);
else if (level == 0)
rc = regulator_disable(r[i]);
if (rc)
goto enable_disable_fail;
}
if (vdd_class->set_vdd && !vdd_class->num_regulators)
rc = vdd_class->set_vdd(vdd_class, level);
if (!rc)
vdd_class->cur_level = level;
return rc;
enable_disable_fail:
/*
* set_optimum_mode could use voltage to derive mode. Restore
* previous voltage setting for r[i] first.
*/
if (ua) {
regulator_set_voltage(r[i], uv[cur_base + i], uv[max_lvl + i]);
regulator_set_optimum_mode(r[i], ua[cur_base + i]);
}
set_mode_fail:
regulator_set_voltage(r[i], uv[cur_base + i], uv[max_lvl + i]);
set_voltage_fail:
for (i--; i >= 0; i--) {
regulator_set_voltage(r[i], uv[cur_base + i], uv[max_lvl + i]);
if (ua)
regulator_set_optimum_mode(r[i], ua[cur_base + i]);
if (cur_lvl == 0 || cur_lvl == vdd_class->num_levels)
regulator_disable(r[i]);
else if (level == 0)
ignore = regulator_enable(r[i]);
}
return rc;
}
示例9: msm_gemini_platform_init
int msm_gemini_platform_init(struct platform_device *pdev,
struct resource **mem,
void **base,
int *irq,
irqreturn_t (*handler) (int, void *),
void *context)
{
int rc = -1;
int gemini_irq;
struct resource *gemini_mem, *gemini_io, *gemini_irq_res;
void *gemini_base;
struct msm_gemini_device *pgmn_dev =
(struct msm_gemini_device *) context;
gemini_mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!gemini_mem) {
GMN_PR_ERR("%s: no mem resource?\n", __func__);
return -ENODEV;
}
gemini_irq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
if (!gemini_irq_res) {
GMN_PR_ERR("no irq resource?\n");
return -ENODEV;
}
gemini_irq = gemini_irq_res->start;
gemini_io = request_mem_region(gemini_mem->start,
resource_size(gemini_mem), pdev->name);
if (!gemini_io) {
GMN_PR_ERR("%s: region already claimed\n", __func__);
return -EBUSY;
}
gemini_base = ioremap(gemini_mem->start, resource_size(gemini_mem));
if (!gemini_base) {
rc = -ENOMEM;
GMN_PR_ERR("%s: ioremap failed\n", __func__);
goto fail1;
}
pgmn_dev->hw_version = GEMINI_8X60;
rc = msm_cam_clk_enable(&pgmn_dev->pdev->dev, gemini_8x_clk_info,
pgmn_dev->gemini_clk, ARRAY_SIZE(gemini_8x_clk_info), 1);
if (rc < 0) {
pgmn_dev->hw_version = GEMINI_7X;
rc = msm_cam_clk_enable(&pgmn_dev->pdev->dev,
gemini_7x_clk_info, pgmn_dev->gemini_clk,
ARRAY_SIZE(gemini_7x_clk_info), 1);
if (rc < 0) {
GMN_PR_ERR("%s: clk failed rc = %d\n", __func__, rc);
goto fail2;
}
} else {
#ifndef CONFIG_ARCH_MSM8X60
rc = msm_cam_clk_enable(&pgmn_dev->pdev->dev,
gemini_imem_clk_info, &pgmn_dev->gemini_clk[2],
ARRAY_SIZE(gemini_imem_clk_info), 1);
if (!rc)
pgmn_dev->hw_version = GEMINI_8960;
#endif
}
if (pgmn_dev->hw_version != GEMINI_7X) {
if (pgmn_dev->gemini_fs == NULL) {
pgmn_dev->gemini_fs =
regulator_get(&pgmn_dev->pdev->dev, "vdd");
if (IS_ERR(pgmn_dev->gemini_fs)) {
pr_err("%s: Regulator FS_ijpeg get failed %ld\n",
__func__, PTR_ERR(pgmn_dev->gemini_fs));
pgmn_dev->gemini_fs = NULL;
goto gemini_fs_failed;
} else if (regulator_enable(pgmn_dev->gemini_fs)) {
pr_err("%s: Regulator FS_ijpeg enable failed\n",
__func__);
regulator_put(pgmn_dev->gemini_fs);
pgmn_dev->gemini_fs = NULL;
goto gemini_fs_failed;
}
}
}
msm_gemini_hw_init(gemini_base, resource_size(gemini_mem));
rc = request_irq(gemini_irq, handler, IRQF_TRIGGER_RISING, "gemini",
context);
if (rc) {
GMN_PR_ERR("%s: request_irq failed, %d\n", __func__,
gemini_irq);
goto fail3;
}
*mem = gemini_mem;
*base = gemini_base;
*irq = gemini_irq;
#ifdef CONFIG_MSM_MULTIMEDIA_USE_ION
gemini_client = msm_ion_client_create(-1, "camera/gemini");
#endif
GMN_DBG("%s:%d] success\n", __func__, __LINE__);
//.........这里部分代码省略.........
示例10: pmu_activate_sim
static bool pmu_activate_sim(Int32 volt)
{
bool bRet = FALSE;
// we pre-define three slection ==>BCM_SIM_VOLT_0, BCM_SIM_VOLT_1V8, BCM_SIM_VOLT_3V
switch((PMU_SIMVolt_t)volt)
{
case PMU_SIM3P0Volt:
{
//CLRREG8(&pWords, 0xc0);
if(!regulator_is_enabled(sim_regulator))
regulator_enable(sim_regulator);
regulator_set_voltage(sim_regulator,3000000,3000000);
pr_info("%s:PMU_SIM3P0Volt\n",__func__);
bRet= TRUE;
g_bPmuSimInited = TRUE;
}
break;
case PMU_SIM2P5Volt:
{
//CLRREG8(&pWords, 0xc0);
//bRet = WritePMUReg(PMU_REG_LCSIMDOCTRL, pWords);
//bRet = WritePMUReg(PMU_REG_SOPMODCTRL, 0x00);
KRIL_DEBUG(DBG_INFO,"---> BCMCpCmdHand: CAPI2_PMU_ActivateSIM -> set to 2.5V\n");
if(!regulator_is_enabled(sim_regulator))
regulator_enable(sim_regulator);
regulator_set_voltage(sim_regulator,2500000,2500000);
bRet= TRUE;
g_bPmuSimInited = TRUE;
pr_info("%s:PMU_SIM2P5Volt\n",__func__);
}
break;
case PMU_SIM1P8Volt:
{
//SETREG8(&pWords, 0xc0);
if(!regulator_is_enabled(sim_regulator))
regulator_enable(sim_regulator);
regulator_set_voltage(sim_regulator,1800000,1800000);
bRet= TRUE;
g_bPmuSimInited = TRUE;
pr_info("%s:PMU_SIM1P8Volt\n",__func__);
KRIL_DEBUG(DBG_INFO,"---> BCMCpCmdHand: CAPI2_PMU_ActivateSIM -> set to 1.8V\n");
}
break;
case PMU_SIM0P0Volt:
{
if(regulator_is_enabled(sim_regulator))
regulator_disable(sim_regulator);
pr_info("%s:PMU_SIM0P0Volt\n",__func__);
KRIL_DEBUG(DBG_INFO,"---> BCMCpCmdHand: CAPI2_PMU_ActivateSIM -> set to 0V\n");
bRet= TRUE;
}
break;
default:
{
KRIL_DEBUG(DBG_ERROR,"---> BCMCpCmdHand: CAPI2_PMU_ActivateSIM -> unknown Volt!\n");
bRet = FALSE;
}
}
if(bRet)
{
bRet = TRUE;
}
else
{
KRIL_DEBUG(DBG_ERROR," ---> BCMCpCmdHand: CAPI2_PMU_ActivateSIM fail!\n");
}
return bRet;
}
示例11: sdhci_kona_sdio_regulator_power
int sdhci_kona_sdio_regulator_power(struct sdio_dev *dev, int power_state)
{
int ret = 0;
struct device *pdev = dev->dev;
struct sdio_platform_cfg *hw_cfg = (struct sdio_platform_cfg *)pdev->platform_data;
/*
* Note that from the board file the appropriate regualtor names are
* populated. For example, in SD Card case there are two regulators to
* control
* vddo - That controls the power to the external card
* vddsdxc - That controls the power to the IO lines
* For the interfaces used for eMMC and WLAN only vddo is present.
* The understanding is that, if for some intefaces like WLAN if the
* regulator need not be switched OFF then from the board file do not
* populate the regulator names.
*/
if( hw_cfg->devtype==SDIO_DEV_TYPE_SDMMC ) {
if (dev->vdd_sdxc_regulator) {
if (power_state) {
dev_err(dev->dev, "Turning ON sdxc sd \r\n");
if(!regulator_is_enabled(dev->vdd_sdxc_regulator)) {
ret = regulator_enable(dev->vdd_sdxc_regulator);
}
} else {
dev_err(dev->dev, "Turning OFF sdxc sd \r\n");
ret = regulator_disable(dev->vdd_sdxc_regulator);
}
}
if (dev->vddo_sd_regulator) {
if (power_state) {
dev_err(dev->dev, "Turning ON vddo sd \r\n");
if(!regulator_is_enabled(dev->vddo_sd_regulator)) {
ret = regulator_enable(dev->vddo_sd_regulator);
}
} else{
dev_err(dev->dev, "Turning OFF vddo sd \r\n");
ret = regulator_disable(dev->vddo_sd_regulator);
}
}
if (power_state) {
if( hw_cfg->configure_sdio_pullup ) {
dev_err(dev->dev, "Pull-Up CMD/DAT Line \r\n");
mdelay(1);
hw_cfg->configure_sdio_pullup(1);
mdelay(1);
}
} else{
if( hw_cfg->configure_sdio_pullup ) {
dev_err(dev->dev, "Pull Down CMD/DAT Line\r\n");
hw_cfg->configure_sdio_pullup(0);
mdelay(1);
}
}
if (power_state)
udelay(STABLE_TIME_AFTER_POWER_ON_US);
else
mdelay(STABLE_TIME_AFTER_POWER_OFF_MS);
}
return ret;
}
示例12: sdhci_pltfm_regulator_init
static int sdhci_pltfm_regulator_init(struct platform_device *pdev,
struct sdio_platform_cfg *hw_cfg)
{
int ret;
struct sdio_dev *dev = platform_get_drvdata(pdev);
char devname[MAX_DEV_NAME_SIZE];
if (dev == NULL) {
printk(KERN_ERR "%s dev is null\n", __func__);
return -EINVAL;
}
snprintf(devname, sizeof(devname), "%s%d", DEV_NAME, pdev->id);
/* VDDMMC used for our low level regulator control. Valid for SD*/
dev->vddo_sd_regulator = regulator_get(&pdev->dev, "vddmmc");
if (IS_ERR(dev->vddo_sd_regulator)) {
pr_err("Unable to get vddmmc regulator, err: %ld\n",
PTR_ERR(dev->vddo_sd_regulator));
dev->vddo_sd_regulator = NULL;
return 0;
}
if (dev->vddo_sd_regulator)
ret = regulator_enable(dev->vddo_sd_regulator);
if (ret < 0) {
printk(KERN_ERR "Unable to enable vddmmc regulator\n");
goto err_put_vddmmc_reg;
}
printk(KERN_INFO "Found and enabled vddmmc regulator for %s\n",
devname);
/* VDDO */
dev->vdd_sdxc_regulator = regulator_get(&pdev->dev, "vddo");
if (IS_ERR(dev->vdd_sdxc_regulator)) {
pr_err("Unable to get vddo regulator, err: %ld\n",
PTR_ERR(dev->vdd_sdxc_regulator));
dev->vdd_sdxc_regulator = NULL;
ret = 0;
goto err_disable_vddmmc_reg;
}
if (dev->vdd_sdxc_regulator)
ret = regulator_enable(dev->vdd_sdxc_regulator);
if (ret < 0) {
printk(KERN_ERR "Unable to enable vddo regulator\n");
goto err_put_vddo_reg;
}
/* set to 3.3V by default */
if (dev->vdd_sdxc_regulator)
ret = regulator_set_voltage(dev->vdd_sdxc_regulator, 3000000, 3000000);
if (ret < 0) {
printk(KERN_ERR "Unable to set vddo regulator to 3.3V\n");
goto err_disable_vddo_reg;
}
printk(KERN_INFO "Found and enabled vddo regulator for %s\n", devname);
udelay(STABLE_TIME_AFTER_POWER_ON_US);
return 0;
err_disable_vddo_reg:
if (dev->vdd_sdxc_regulator)
regulator_disable(dev->vdd_sdxc_regulator);
err_put_vddo_reg:
if (dev->vdd_sdxc_regulator) {
regulator_put(dev->vdd_sdxc_regulator);
dev->vdd_sdxc_regulator = NULL;
}
err_disable_vddmmc_reg:
if (dev->vddo_sd_regulator)
regulator_disable(dev->vddo_sd_regulator);
err_put_vddmmc_reg:
if (dev->vddo_sd_regulator) {
regulator_put(dev->vddo_sd_regulator);
dev->vddo_sd_regulator = NULL;
}
return ret;
}
示例13: host_start
static int host_start(struct ci_hdrc *ci)
{
struct usb_hcd *hcd;
struct ehci_hcd *ehci;
struct ehci_ci_priv *priv;
int ret;
if (usb_disabled())
return -ENODEV;
hcd = usb_create_hcd(&ci_ehci_hc_driver, ci->dev, dev_name(ci->dev));
if (!hcd)
return -ENOMEM;
dev_set_drvdata(ci->dev, ci);
hcd->rsrc_start = ci->hw_bank.phys;
hcd->rsrc_len = ci->hw_bank.size;
hcd->regs = ci->hw_bank.abs;
hcd->has_tt = 1;
hcd->power_budget = ci->platdata->power_budget;
hcd->tpl_support = ci->platdata->tpl_support;
if (ci->phy)
hcd->phy = ci->phy;
else
hcd->usb_phy = ci->usb_phy;
ehci = hcd_to_ehci(hcd);
ehci->caps = ci->hw_bank.cap;
ehci->has_hostpc = ci->hw_bank.lpm;
ehci->has_tdi_phy_lpm = ci->hw_bank.lpm;
ehci->imx28_write_fix = ci->imx28_write_fix;
priv = (struct ehci_ci_priv *)ehci->priv;
priv->reg_vbus = NULL;
if (ci->platdata->reg_vbus && !ci_otg_is_fsm_mode(ci)) {
if (ci->platdata->flags & CI_HDRC_IMX_VBUS_EARLY_ON) {
ret = regulator_enable(ci->platdata->reg_vbus);
if (ret) {
dev_err(ci->dev,
"Failed to enable vbus regulator, ret=%d\n",
ret);
goto put_hcd;
}
} else {
priv->reg_vbus = ci->platdata->reg_vbus;
}
}
ret = usb_add_hcd(hcd, 0, 0);
if (ret) {
goto disable_reg;
} else {
struct usb_otg *otg = &ci->otg;
ci->hcd = hcd;
if (ci_otg_is_fsm_mode(ci)) {
hcd->self.otg_fsm = &ci->fsm;
otg->host = &hcd->self;
hcd->self.otg_port = 1;
}
}
if (ci->platdata->flags & CI_HDRC_DISABLE_STREAMING)
hw_write(ci, OP_USBMODE, USBMODE_CI_SDIS, USBMODE_CI_SDIS);
if (ci->platdata->notify_event &&
(ci->platdata->flags & CI_HDRC_IMX_IS_HSIC))
ci->platdata->notify_event
(ci, CI_HDRC_IMX_HSIC_ACTIVE_EVENT);
if (ci->platdata->flags & CI_HDRC_DISABLE_HOST_STREAMING)
hw_write(ci, OP_USBMODE, USBMODE_CI_SDIS, USBMODE_CI_SDIS);
ci_hdrc_ahb_config(ci);
return ret;
disable_reg:
if (ci->platdata->reg_vbus && !ci_otg_is_fsm_mode(ci) &&
(ci->platdata->flags & CI_HDRC_IMX_VBUS_EARLY_ON))
regulator_disable(ci->platdata->reg_vbus);
put_hcd:
usb_put_hcd(hcd);
return ret;
}
示例14: w1_gpio_probe
static int w1_gpio_probe(struct platform_device *pdev)
{
struct w1_bus_master *master;
struct w1_gpio_platform_data *pdata;
struct pinctrl *pinctrl;
int err;
pinctrl = devm_pinctrl_get_select_default(&pdev->dev);
if (IS_ERR(pinctrl))
dev_warn(&pdev->dev, "unable to select pin group\n");
if (of_have_populated_dt()) {
err = w1_gpio_probe_dt(pdev);
if (err < 0) {
dev_err(&pdev->dev, "Failed to parse DT\n");
return err;
}
}
pdata = pdev->dev.platform_data;
if (!pdata) {
dev_err(&pdev->dev, "No configuration data\n");
return -ENXIO;
}
master = kzalloc(sizeof(struct w1_bus_master), GFP_KERNEL);
if (!master) {
dev_err(&pdev->dev, "Out of memory\n");
return -ENOMEM;
}
err = gpio_request(pdata->pin, "w1");
if (err) {
dev_err(&pdev->dev, "gpio_request (pin) failed\n");
goto free_master;
}
if (gpio_is_valid(pdata->ext_pullup_enable_pin)) {
err = gpio_request_one(pdata->ext_pullup_enable_pin,
GPIOF_INIT_LOW, "w1 pullup");
if (err < 0) {
dev_err(&pdev->dev, "gpio_request_one "
"(ext_pullup_enable_pin) failed\n");
goto free_gpio;
}
}
master->data = pdata;
master->read_bit = w1_gpio_read_bit;
if (pdata->is_open_drain) {
gpio_direction_output(pdata->pin, 1);
master->write_bit = w1_gpio_write_bit_val;
} else {
gpio_direction_input(pdata->pin);
master->write_bit = w1_gpio_write_bit_dir;
}
err = w1_add_master_device(master);
if (err) {
dev_err(&pdev->dev, "w1_add_master device failed\n");
goto free_gpio_ext_pu;
}
/* voltage regulator support */
pdata->regulator_en = 0;
pdata->w1_gpio_vdd = regulator_get(&pdev->dev, "w1_vdd");
if (IS_ERR(pdata->w1_gpio_vdd)) {
pdata->w1_gpio_vdd = NULL;
dev_err(&pdev->dev,
"%s: Failed to get w1_vdd regulator\n",
__func__);
} else {
dev_err(&pdev->dev, "w1-vdd regulator is initially %s\n",
regulator_is_enabled(pdata->w1_gpio_vdd) ?
"on" : "off");
err = regulator_enable(pdata->w1_gpio_vdd);
if (err) {
pr_err("%s: Error %d enabling w1-vdd regulator\n",
__func__, err);
goto free_regulator;
} else {
pdata->regulator_en = 1;
}
}
if (pdata->enable_external_pullup)
pdata->enable_external_pullup(1);
if (gpio_is_valid(pdata->ext_pullup_enable_pin))
gpio_set_value(pdata->ext_pullup_enable_pin, 1);
platform_set_drvdata(pdev, master);
return 0;
free_regulator:
if (pdata->w1_gpio_vdd != NULL)
regulator_put(pdata->w1_gpio_vdd);
//.........这里部分代码省略.........
示例15: mdss_dsi_panel_power_on
int mdss_dsi_panel_power_on(struct mdss_panel_data *pdata, int enable)
{
int ret;
struct mdss_dsi_ctrl_pdata *ctrl_pdata = NULL;
if (pdata == NULL) {
pr_err("%s: Invalid input data\n", __func__);
return -EINVAL;
}
ctrl_pdata = container_of(pdata, struct mdss_dsi_ctrl_pdata,
panel_data);
pr_debug("%s: enable=%d\n", __func__, enable);
/* Z OLED power on start */
if (enable) {
if (ctrl_pdata->power_data.num_vreg > 0) {
ret = msm_dss_enable_vreg(
ctrl_pdata->power_data.vreg_config,
ctrl_pdata->power_data.num_vreg, 1);
if (ret) {
pr_err("%s:Failed to enable regulators.rc=%d\n",
__func__, ret);
return ret;
}
/*
* A small delay is needed here after enabling
* all regulators and before issuing panel reset
*/
msleep(20);
} else {
ret = regulator_set_optimum_mode(
(ctrl_pdata->shared_pdata).vdd_io_vreg, 100000);
if (ret < 0) {
pr_err("%s: vdd_io_vreg set opt mode failed.\n",
__func__);
return ret;
}
ret = regulator_set_optimum_mode(
(ctrl_pdata->shared_pdata).vdda_vreg, 100000);
if (ret < 0) {
pr_err("%s: vdda_vreg set opt mode failed.\n",
__func__);
return ret;
}
if (gpio_is_valid(ctrl_pdata->disp_en_gpio)) {
gpio_set_value((ctrl_pdata->disp_en_gpio), 1);
msleep(1);
} else
pr_err("%s:%d, disp_en_gpio is not valid\n",
__func__, __LINE__);
ret = regulator_enable(
(ctrl_pdata->shared_pdata).vdd_io_vreg);
if (ret) {
pr_err("%s: Failed to enable regulator.\n",
__func__);
return ret;
}
ret = regulator_enable(
(ctrl_pdata->shared_pdata).vdda_vreg);
if (ret) {
pr_err("%s: Failed to enable regulator.\n",
__func__);
return ret;
}
msleep(10);
}
/* Z OLED power off start */
} else {
msleep(20);
mdss_dsi_panel_reset(pdata, 0);
msleep(20);
if (ctrl_pdata->power_data.num_vreg > 0) {
ret = msm_dss_enable_vreg(
ctrl_pdata->power_data.vreg_config,
ctrl_pdata->power_data.num_vreg, 0);
if (ret) {
pr_err("%s: Failed to disable regs.rc=%d\n",
__func__, ret);
return ret;
}
} else {
ret = regulator_disable(
(ctrl_pdata->shared_pdata).vdda_vreg);
if (ret) {
pr_err("%s: Failed to disable regulator.\n",
__func__);
return ret;
}
#if 0
ret = regulator_disable(
(ctrl_pdata->shared_pdata).vdd_io_vreg);
//.........这里部分代码省略.........