本文整理汇总了C++中regulator_put函数的典型用法代码示例。如果您正苦于以下问题：C++ regulator_put函数的具体用法？C++ regulator_put怎么用？C++ regulator_put使用的例子？那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了regulator_put函数的15个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: yacd5c1sbdbc_vreg_init
//.........这里部分代码省略.........
#if 0
if (vreg_l16_2p8 == NULL) {
vreg_l16_2p8 = regulator_get(NULL, "8921_l16");
if (IS_ERR(vreg_l16_2p8)) {
printk("%s: vreg_l16_2p8 get failed \n", __func__);
vreg_l16_2p8 = NULL;
return -ENODEV;
}
rc = regulator_set_voltage(vreg_l16_2p8, 2800000, 2800000);
if (rc) {
printk("%s: unable to set vreg_l16_2p8 voltage to 2.8V\n", __func__);
goto fail;
}
}
if (vreg_s4_1p8 == NULL) {
vreg_s4_1p8 = regulator_get(NULL, "8921_s4");
if (IS_ERR(vreg_s4_1p8)) {
printk("%s: vreg_s4_1p8 get failed \n", __func__);
vreg_s4_1p8 = NULL;
return -ENODEV;
}
rc = regulator_set_voltage(vreg_s4_1p8, 1800000, 1800000);
if (rc) {
printk("%s: unable to set vreg_s4_1p8 voltage to 1.8V\n", __func__);
goto fail;
}
}
#endif
#if 1 //wsyang_temp for 2M
if (vreg_lvs5_1p8 == NULL) {
vreg_lvs5_1p8 = regulator_get(NULL, "8921_lvs5");
if (IS_ERR(vreg_lvs5_1p8)) {
printk("%s: vreg_lvs5_1p8 get failed \n", __func__);
vreg_lvs5_1p8 = NULL;
return -ENODEV;
}
// rc = regulator_set_voltage(vreg_lvs5_1p8, 1800000, 1800000);
// if (rc) {
// SKYCERR("%s: unable to set vreg_lvs5_1p8 voltage to 1.8V\n", __func__);
// goto fail;
// }
}
if (vreg_lvs6_1p8 == NULL) {
vreg_lvs6_1p8 = regulator_get(NULL, "8921_lvs6");
if (IS_ERR(vreg_lvs6_1p8)) {
printk("%s: vreg_lvs6_1p8 get failed \n", __func__);
vreg_lvs6_1p8 = NULL;
return -ENODEV;
}
// rc = regulator_set_voltage(vreg_lvs6_1p8, 1800000, 1800000);
// if (rc) {
// printk("%s: unable to set vreg_lvs6_1p8 voltage to 1.8V\n", __func__);
// goto fail;
// }
}
if (vreg_l11_2p85 == NULL) {
vreg_l11_2p85 = regulator_get(NULL, "8921_l11");
if (IS_ERR(vreg_l11_2p85)) {
printk("%s: vreg_l11_2p85 get failed \n", __func__);
vreg_l11_2p85 = NULL;
return -ENODEV;
}
rc = regulator_set_voltage(vreg_l11_2p85, 2800000, 2800000);
// rc = regulator_set_voltage(vreg_l11_2p85, 2850000, 2850000);
if (rc) {
printk("%s: unable to set vreg_l11_2p85 voltage to 2.8V\n", __func__);
goto fail;
}
}
#endif //wsyang_temp for 2M
return rc;
fail:
printk("%s Failed!:%d\n",__func__, __LINE__);
#if 0
if(vreg_l16_2p8) {
regulator_put(vreg_l16_2p8);
}
if(vreg_s4_1p8) {
regulator_put(vreg_s4_1p8);
}
#endif
if(vreg_lvs6_1p8) {
regulator_put(vreg_lvs6_1p8);
}
if(vreg_l11_2p85) {
regulator_put(vreg_l11_2p85);
}
if(vreg_lvs5_1p8) {
regulator_put(vreg_lvs5_1p8);
}
#endif
sensor_init_fail:
return -ENODEV;
}示例2: mop500_prox_deactivate
static void mop500_prox_deactivate(struct device *dev)
{
regulator_disable(prox_regulator);
regulator_put(prox_regulator);
}示例3: video_harden_regulator_disable
int video_harden_regulator_disable(video_harden_dev_id_enum dev_id)
{
int ret = 0;
printk(KERN_INFO "dev_id is %d.\n", dev_id);
ret = video_harden_device_id_check(dev_id);
if (ret != 0) {
return -1;
}
ret = down_interruptible(&video_harden_busy_lock);
if (0 != ret) {
printk(KERN_ERR "video_harden_busy_lock failed\n");
return -1;
}
if ((video_harden_regulator_vote.vcodec_bit == 0)
&& (video_harden_regulator_vote.jpeg_bit == 0)
&& (video_harden_regulator_vote.isp_bit == 0)) {
up(&video_harden_busy_lock);
printk(KERN_ERR "Video harden regulator disable is already done! skip.\n");
return -1;
}
switch (dev_id) {
case VIDEO_HARDEN_DEV_ID_VCODEC: /* VCODEC */
video_harden_regulator_vote.vcodec_bit = 0;
break;
case VIDEO_HARDEN_DEV_ID_JPEG: /* JPEG */
video_harden_regulator_vote.jpeg_bit = 0;
break;
case VIDEO_HARDEN_DEV_ID_ISP: /* ISP */
video_harden_regulator_vote.isp_bit = 0;
break;
default:
break;
}
if ((video_harden_regulator_vote.vcodec_bit == 0)
&& (video_harden_regulator_vote.jpeg_bit == 0)
&& (video_harden_regulator_vote.isp_bit == 0)) {
/* AO_SC SC_PW_MTCMOS_DIS0 [0x834]: VIDEO HARDEN power off */
if (NULL != media_pd_vdd) {
ret = regulator_disable(media_pd_vdd);
if (ret) {
up(&video_harden_busy_lock);
printk(KERN_ERR "Regulator vdec disable failed ret=%d.\n", ret);
return -1;
}
regulator_put(media_pd_vdd);
media_pd_vdd = NULL;
}
printk(KERN_INFO "video harden regulator disable is successful.\n");
} else {
printk(KERN_INFO "can't disable video harden Regulator, other module is runing on!.\n");
}
up(&video_harden_busy_lock);
printk(KERN_INFO "%s, g_video_harden_vote is 0x%x.\n",
__func__, *((unsigned int *)&video_harden_regulator_vote));
return ret;
}示例4: db5500_keypad_probe
//.........这里部分代码省略.........
ret = input_register_device(input);
if (ret) {
dev_err(&pdev->dev,
"unable to register input device: %d\n", ret);
goto out_freeinput;
}
keypad->irq = irq;
keypad->board = plat;
keypad->input = input;
keypad->base = base;
keypad->clk = clk;
INIT_DELAYED_WORK(&keypad->switch_work, db5500_gpio_switch_work);
INIT_DELAYED_WORK(&keypad->gpio_work, db5500_gpio_release_work);
clk_enable(keypad->clk);
if (!keypad->board->init) {
dev_err(&pdev->dev, "init funtion not defined\n");
ret = -EINVAL;
goto out_unregisterinput;
}
if (keypad->board->init() < 0) {
dev_err(&pdev->dev, "keyboard init config failed\n");
ret = -EINVAL;
goto out_unregisterinput;
}
if (!keypad->board->exit) {
dev_err(&pdev->dev, "exit funtion not defined\n");
ret = -EINVAL;
goto out_unregisterinput;
}
if (keypad->board->exit() < 0) {
dev_err(&pdev->dev, "keyboard exit config failed\n");
ret = -EINVAL;
goto out_unregisterinput;
}
for (i = 0; i < keypad->board->krow; i++) {
keypad->db5500_rows[i] = *plat->gpio_input_pins;
keypad->gpio_input_irq[i] =
GPIO_TO_IRQ(keypad->db5500_rows[i]);
plat->gpio_input_pins++;
}
for (i = 0; i < keypad->board->kcol; i++) {
keypad->db5500_cols[i] = *plat->gpio_output_pins;
plat->gpio_output_pins++;
}
for (i = 0; i < keypad->board->krow; i++) {
ret = request_threaded_irq(keypad->gpio_input_irq[i],
NULL, db5500_keypad_gpio_irq,
IRQF_TRIGGER_FALLING | IRQF_NO_SUSPEND,
"db5500-keypad-gpio", keypad);
if (ret) {
dev_err(&pdev->dev, "allocate gpio irq %d failed\n",
keypad->gpio_input_irq[i]);
goto out_unregisterinput;
}
enable_irq_wake(keypad->gpio_input_irq[i]);
}
ret = request_threaded_irq(keypad->irq, NULL, db5500_keypad_irq,
IRQF_ONESHOT, "db5500-keypad", keypad);
if (ret) {
dev_err(&pdev->dev, "allocate irq %d failed\n", keypad->irq);
goto out_unregisterinput;
}
platform_set_drvdata(pdev, keypad);
clk_disable(keypad->clk);
regulator_disable(keypad->regulator);
return 0;
out_unregisterinput:
input_unregister_device(input);
input = NULL;
clk_disable(keypad->clk);
out_freeinput:
input_free_device(input);
out_regulator_enable:
regulator_put(keypad->regulator);
out_regulator_get:
input_free_device(input);
out_freekeypad:
kfree(keypad);
out_freeclk:
clk_put(clk);
out_iounmap:
iounmap(base);
out_freerequest_memregions:
release_mem_region(res->start, resource_size(res));
out_ret:
return ret;
}示例5: tegra_vibrator_exit
static void tegra_vibrator_exit(void)
{
regulator_put(tegra_vibrator_regulator);
}示例6: msm_csid_release
static int msm_csid_release(struct csid_device *csid_dev)
{
uint32_t irq;
if (csid_dev->csid_state != CSID_POWER_UP) {
pr_err("%s: csid invalid state %d\n", __func__,
csid_dev->csid_state);
return -EINVAL;
}
CDBG("%s:%d, hw_version = 0x%x\n", __func__, __LINE__,
csid_dev->hw_version);
irq = msm_camera_io_r(csid_dev->base +
csid_dev->ctrl_reg->csid_reg.csid_irq_status_addr);
msm_camera_io_w(irq, csid_dev->base +
csid_dev->ctrl_reg->csid_reg.csid_irq_clear_cmd_addr);
msm_camera_io_w(0, csid_dev->base +
csid_dev->ctrl_reg->csid_reg.csid_irq_mask_addr);
disable_irq(csid_dev->irq->start);
if (csid_dev->hw_version == CSID_VERSION_V20) {
msm_cam_clk_enable(&csid_dev->pdev->dev, csid_clk_info,
csid_dev->csid_clk, csid_dev->num_clk, 0);
msm_camera_enable_vreg(&csid_dev->pdev->dev,
csid_8960_vreg_info, ARRAY_SIZE(csid_8960_vreg_info),
NULL, 0, &csid_dev->csi_vdd, 0);
msm_camera_config_vreg(&csid_dev->pdev->dev,
csid_8960_vreg_info, ARRAY_SIZE(csid_8960_vreg_info),
NULL, 0, &csid_dev->csi_vdd, 0);
} else if (csid_dev->hw_version == CSID_VERSION_V22) {
msm_cam_clk_enable(&csid_dev->pdev->dev,
csid_clk_info,
csid_dev->csid_clk,
csid_dev->num_clk, 0);
msm_camera_enable_vreg(&csid_dev->pdev->dev,
csid_vreg_info, ARRAY_SIZE(csid_vreg_info),
NULL, 0, &csid_dev->csi_vdd, 0);
msm_camera_config_vreg(&csid_dev->pdev->dev,
csid_vreg_info, ARRAY_SIZE(csid_vreg_info),
NULL, 0, &csid_dev->csi_vdd, 0);
} else if ((csid_dev->hw_version >= CSID_VERSION_V30 &&
csid_dev->hw_version < CSID_VERSION_V31) ||
(csid_dev->hw_version == CSID_VERSION_V40) ||
(csid_dev->hw_version == CSID_VERSION_V31_1) ||
(csid_dev->hw_version == CSID_VERSION_V31_3)) {
msm_cam_clk_enable(&csid_dev->pdev->dev, csid_clk_info,
csid_dev->csid_clk, csid_dev->num_clk, 0);
msm_camera_enable_vreg(&csid_dev->pdev->dev,
csid_vreg_info, ARRAY_SIZE(csid_vreg_info),
NULL, 0, &csid_dev->csi_vdd, 0);
msm_camera_config_vreg(&csid_dev->pdev->dev,
csid_vreg_info, ARRAY_SIZE(csid_vreg_info),
NULL, 0, &csid_dev->csi_vdd, 0);
} else if ((csid_dev->hw_version == CSID_VERSION_V31) ||
(csid_dev->hw_version == CSID_VERSION_V32) ||
(csid_dev->hw_version == CSID_VERSION_V33) ||
(csid_dev->hw_version == CSID_VERSION_V37) ||
(csid_dev->hw_version == CSID_VERSION_V34)) {
msm_cam_clk_enable(&csid_dev->pdev->dev, csid_clk_info,
csid_dev->csid_clk, csid_dev->num_clk, 0);
msm_camera_enable_vreg(&csid_dev->pdev->dev,
csid_vreg_info, ARRAY_SIZE(csid_vreg_info),
NULL, 0, &csid_dev->csi_vdd, 0);
msm_camera_config_vreg(&csid_dev->pdev->dev,
csid_vreg_info, ARRAY_SIZE(csid_vreg_info),
NULL, 0, &csid_dev->csi_vdd, 0);
} else {
pr_err("%s:%d, invalid hw version : 0x%x", __func__, __LINE__,
csid_dev->hw_version);
return -EINVAL;
}
if (!IS_ERR_OR_NULL(csid_dev->reg_ptr)) {
regulator_disable(csid_dev->reg_ptr);
regulator_put(csid_dev->reg_ptr);
}
iounmap(csid_dev->base);
csid_dev->base = NULL;
csid_dev->csid_state = CSID_POWER_DOWN;
return 0;
}示例7: acpuclk_cortex_init
int __init acpuclk_cortex_init(struct platform_device *pdev,
struct acpuclk_drv_data *data)
{
unsigned long max_cpu_khz = 0;
int i, rc;
acpuclk_init_data = data;
mutex_init(&acpuclk_init_data->lock);
bus_perf_client = msm_bus_scale_register_client(
acpuclk_init_data->bus_scale);
if (!bus_perf_client) {
pr_err("Unable to register bus client\n");
BUG();
}
for (i = 0; i < NUM_SRC; i++) {
if (!acpuclk_init_data->src_clocks[i].name)
continue;
acpuclk_init_data->src_clocks[i].clk =
clk_get(&pdev->dev,
acpuclk_init_data->src_clocks[i].name);
BUG_ON(IS_ERR(acpuclk_init_data->src_clocks[i].clk));
/*
* Prepare the PLLs because we enable/disable them
* in atomic context during power collapse/restore.
*/
BUG_ON(clk_prepare(acpuclk_init_data->src_clocks[i].clk));
}
/* Improve boot time by ramping up CPU immediately */
for (i = 0; acpuclk_init_data->freq_tbl[i].khz != 0 &&
acpuclk_init_data->freq_tbl[i].use_for_scaling; i++)
max_cpu_khz = acpuclk_init_data->freq_tbl[i].khz;
/* Initialize regulators */
rc = increase_vdd(acpuclk_init_data->freq_tbl[i].vdd_cpu,
acpuclk_init_data->freq_tbl[i].vdd_mem);
if (rc)
goto err_vdd;
rc = regulator_enable(acpuclk_init_data->vdd_mem);
if (rc) {
dev_err(&pdev->dev, "regulator_enable for mem failed\n");
goto err_vdd;
}
rc = regulator_enable(acpuclk_init_data->vdd_cpu);
if (rc) {
dev_err(&pdev->dev, "regulator_enable for cpu failed\n");
goto err_vdd_cpu;
}
acpuclk_cortex_set_rate(0, max_cpu_khz, SETRATE_INIT);
acpuclk_register(&acpuclk_cortex_data);
cpufreq_table_init();
return 0;
err_vdd_cpu:
regulator_disable(acpuclk_init_data->vdd_mem);
err_vdd:
regulator_put(acpuclk_init_data->vdd_mem);
regulator_put(acpuclk_init_data->vdd_cpu);
for (i = 0; i < NUM_SRC; i++) {
if (!acpuclk_init_data->src_clocks[i].name)
continue;
clk_unprepare(acpuclk_init_data->src_clocks[i].clk);
clk_put(acpuclk_init_data->src_clocks[i].clk);
}
return rc;
}示例8: msm_jpeg_platform_init
//.........这里部分代码省略.........
}
pgmn_dev->jpeg_fs = regulator_get(&pgmn_dev->pdev->dev, "vdd");
rc = regulator_enable(pgmn_dev->jpeg_fs);
if (rc) {
JPEG_PR_ERR("%s:%d]jpeg regulator get failed\n",
__func__, __LINE__);
goto fail_fs;
}
rc = msm_cam_clk_enable(&pgmn_dev->pdev->dev, jpeg_8x_clk_info,
pgmn_dev->jpeg_clk, ARRAY_SIZE(jpeg_8x_clk_info), 1);
if (rc < 0) {
JPEG_PR_ERR("%s: clk failed rc = %d\n", __func__, rc);
goto fail_clk;
}
pgmn_dev->hw_version = readl_relaxed(jpeg_base +
JPEG_HW_VERSION);
JPEG_DBG_HIGH("%s:%d] jpeg HW version 0x%x", __func__, __LINE__,
pgmn_dev->hw_version);
pgmn_dev->jpeg_vbif = ioremap(VBIF_BASE_ADDRESS, VBIF_REGION_SIZE);
if (!pgmn_dev->jpeg_vbif) {
rc = -ENOMEM;
JPEG_PR_ERR("%s:%d] ioremap failed\n", __func__, __LINE__);
goto fail_vbif;
}
JPEG_DBG("%s:%d] jpeg_vbif 0x%x", __func__, __LINE__,
(uint32_t)pgmn_dev->jpeg_vbif);
#ifdef CONFIG_MSM_IOMMU
for (i = 0; i < pgmn_dev->iommu_cnt; i++) {
rc = iommu_attach_device(pgmn_dev->domain,
pgmn_dev->iommu_ctx_arr[i]);
if (rc < 0) {
rc = -ENODEV;
JPEG_PR_ERR("%s: Device attach failed\n", __func__);
goto fail_iommu;
}
JPEG_DBG("%s:%d] dom 0x%x ctx 0x%x", __func__, __LINE__,
(uint32_t)pgmn_dev->domain,
(uint32_t)pgmn_dev->iommu_ctx_arr[i]);
}
#endif
set_vbif_params(pgmn_dev, pgmn_dev->jpeg_vbif);
rc = request_irq(jpeg_irq, handler, IRQF_TRIGGER_RISING, "jpeg",
context);
if (rc) {
JPEG_PR_ERR("%s: request_irq failed, %d\n", __func__,
jpeg_irq);
goto fail_request_irq;
}
*mem = jpeg_mem;
*base = jpeg_base;
*irq = jpeg_irq;
pgmn_dev->jpeg_client = msm_ion_client_create(-1, "camera/jpeg");
JPEG_DBG("%s:%d] success\n", __func__, __LINE__);
pgmn_dev->state = MSM_JPEG_INIT;
return rc;
fail_request_irq:
#ifdef CONFIG_MSM_IOMMU
for (i = 0; i < pgmn_dev->iommu_cnt; i++) {
JPEG_PR_ERR("%s:%d] dom 0x%x ctx 0x%x", __func__, __LINE__,
(uint32_t)pgmn_dev->domain,
(uint32_t)pgmn_dev->iommu_ctx_arr[i]);
iommu_detach_device(pgmn_dev->domain,
pgmn_dev->iommu_ctx_arr[i]);
}
#endif
fail_iommu:
iounmap(pgmn_dev->jpeg_vbif);
fail_vbif:
msm_cam_clk_enable(&pgmn_dev->pdev->dev, jpeg_8x_clk_info,
pgmn_dev->jpeg_clk, ARRAY_SIZE(jpeg_8x_clk_info), 0);
fail_clk:
rc = regulator_disable(pgmn_dev->jpeg_fs);
if (!rc)
regulator_put(pgmn_dev->jpeg_fs);
else
JPEG_PR_ERR("%s:%d] regulator disable failed %d",
__func__, __LINE__, rc);
pgmn_dev->jpeg_fs = NULL;
fail_fs:
iounmap(jpeg_base);
fail_remap:
release_mem_region(jpeg_mem->start, resource_size(jpeg_mem));
JPEG_DBG("%s:%d] fail\n", __func__, __LINE__);
return rc;
}示例9: msm_camera_config_vreg
int msm_camera_config_vreg(struct device *dev, struct camera_vreg_t *cam_vreg,
int num_vreg, enum msm_camera_vreg_name_t *vreg_seq,
int num_vreg_seq, struct regulator **reg_ptr, int config)
{
int i = 0, j = 0;
int rc = 0;
struct camera_vreg_t *curr_vreg;
if (num_vreg_seq > num_vreg) {
pr_err("%s:%d vreg sequence invalid\n", __func__, __LINE__);
return -EINVAL;
}
if (!num_vreg_seq)
num_vreg_seq = num_vreg;
if (config) {
for (i = 0; i < num_vreg_seq; i++) {
if (vreg_seq) {
j = vreg_seq[i];
if (j >= num_vreg)
continue;
} else
j = i;
curr_vreg = &cam_vreg[j];
reg_ptr[j] = regulator_get(dev,
curr_vreg->reg_name);
if (IS_ERR(reg_ptr[j])) {
pr_err("%s: %s get failed\n",
__func__,
curr_vreg->reg_name);
reg_ptr[j] = NULL;
goto vreg_get_fail;
}
if (curr_vreg->type == REG_LDO) {
rc = regulator_set_voltage(
reg_ptr[j],
curr_vreg->min_voltage,
curr_vreg->max_voltage);
if (rc < 0) {
pr_err("%s: %s set voltage failed\n",
__func__,
curr_vreg->reg_name);
goto vreg_set_voltage_fail;
}
if (curr_vreg->op_mode >= 0) {
rc = regulator_set_optimum_mode(
reg_ptr[j],
curr_vreg->op_mode);
if (rc < 0) {
pr_err(
"%s:%s set optimum mode fail\n",
__func__,
curr_vreg->reg_name);
goto vreg_set_opt_mode_fail;
}
}
}
}
} else {
for (i = num_vreg_seq-1; i >= 0; i--) {
if (vreg_seq) {
j = vreg_seq[i];
if (j >= num_vreg)
continue;
} else
j = i;
curr_vreg = &cam_vreg[j];
if (reg_ptr[j]) {
if (curr_vreg->type == REG_LDO) {
if (curr_vreg->op_mode >= 0) {
regulator_set_optimum_mode(
reg_ptr[j], 0);
}
regulator_set_voltage(
reg_ptr[j], 0, curr_vreg->
max_voltage);
}
regulator_put(reg_ptr[j]);
reg_ptr[j] = NULL;
}
}
}
return 0;
vreg_unconfig:
if (curr_vreg->type == REG_LDO)
regulator_set_optimum_mode(reg_ptr[j], 0);
vreg_set_opt_mode_fail:
if (curr_vreg->type == REG_LDO)
regulator_set_voltage(reg_ptr[j], 0,
curr_vreg->max_voltage);
vreg_set_voltage_fail:
regulator_put(reg_ptr[j]);
reg_ptr[j] = NULL;
vreg_get_fail:
for (i--; i >= 0; i--) {
if (vreg_seq) {
//.........这里部分代码省略.........
示例10: msm_camera_config_single_vreg
int msm_camera_config_single_vreg(struct device *dev,
struct camera_vreg_t *cam_vreg, struct regulator **reg_ptr, int config)
{
int rc = 0;
if (config) {
if (cam_vreg->type == REG_SUB_LDO) {
if (cam_vreg->sub_reg_name == NULL) {
pr_err("%s : can't find sub reg name", __func__);
goto vreg_get_fail;
}
CDBG("%s enable %s\n", __func__, cam_vreg->sub_reg_name);
} else {
if (cam_vreg->reg_name == NULL) {
pr_err("%s : can't find reg name", __func__);
goto vreg_get_fail;
}
CDBG("%s enable %s\n", __func__, cam_vreg->reg_name);
}
if (cam_vreg->type == REG_SUB_LDO) {
*reg_ptr = regulator_get(dev, cam_vreg->sub_reg_name);
if (IS_ERR(*reg_ptr)) {
pr_err("%s: %s get failed\n", __func__,
cam_vreg->sub_reg_name);
*reg_ptr = NULL;
goto vreg_get_fail;
}
} else {
*reg_ptr = regulator_get(dev, cam_vreg->reg_name);
if (IS_ERR(*reg_ptr)) {
pr_err("%s: %s get failed\n", __func__,
cam_vreg->reg_name);
*reg_ptr = NULL;
goto vreg_get_fail;
}
}
if (cam_vreg->type == REG_LDO || cam_vreg->type == REG_SUB_LDO) {
rc = regulator_set_voltage(
*reg_ptr, cam_vreg->min_voltage,
cam_vreg->max_voltage);
if (rc < 0) {
if (cam_vreg->type == REG_SUB_LDO)
pr_err("%s: %s set voltage failed\n",
__func__, cam_vreg->sub_reg_name);
else
pr_err("%s: %s set voltage failed\n",
__func__, cam_vreg->reg_name);
goto vreg_set_voltage_fail;
}
if (cam_vreg->op_mode >= 0) {
rc = regulator_set_optimum_mode(*reg_ptr,
cam_vreg->op_mode);
if (rc < 0) {
if (cam_vreg->type == REG_SUB_LDO)
pr_err(
"%s: %s set optimum mode failed\n",
__func__, cam_vreg->sub_reg_name);
else
pr_err(
"%s: %s set optimum mode failed\n",
__func__, cam_vreg->reg_name);
goto vreg_set_opt_mode_fail;
}
}
}
rc = regulator_enable(*reg_ptr);
if (rc < 0) {
if (cam_vreg->type == REG_SUB_LDO)
pr_err("%s: %s enable failed\n",
__func__, cam_vreg->sub_reg_name);
else
pr_err("%s: %s enable failed\n",
__func__, cam_vreg->reg_name);
goto vreg_unconfig;
}
} else {
if (*reg_ptr) {
if (cam_vreg->type == REG_SUB_LDO)
CDBG("%s disable %s\n", __func__, cam_vreg->sub_reg_name);
else
CDBG("%s disable %s\n", __func__, cam_vreg->reg_name);
regulator_disable(*reg_ptr);
if (cam_vreg->type == REG_LDO || cam_vreg->type == REG_SUB_LDO) {
if (cam_vreg->op_mode >= 0)
regulator_set_optimum_mode(*reg_ptr, 0);
regulator_set_voltage(
*reg_ptr, 0, cam_vreg->max_voltage);
}
regulator_put(*reg_ptr);
*reg_ptr = NULL;
} else {
if (cam_vreg->type == REG_SUB_LDO)
pr_err("%s can't disable %s\n", __func__, cam_vreg->sub_reg_name);
else
pr_err("%s can't disable %s\n", __func__, cam_vreg->reg_name);
//.........这里部分代码省略.........
示例11: pwm_ir_tx_remove
static void pwm_ir_tx_remove(struct pwm_ir_dev *dev)
{
if (dev->reg)
regulator_put(dev->reg);
pwm_free(dev->pwm);
}示例12: yacd5c1sbdbc_sensor_power_down
int32_t yacd5c1sbdbc_sensor_power_down(struct msm_sensor_ctrl_t *s_ctrl)
{
int32_t rc = 0;
pr_err("%s\n", __func__);
#if 1//wsyang_temp
if(booting_skip_check == 1) {// except AF_power_down for booting
if (s_ctrl->func_tbl->sensor_stop_stream) {
s_ctrl->func_tbl->sensor_stop_stream(s_ctrl);
msleep(20);
}
}
else {
booting_skip_check = 1;
}
#endif
#if 0
msm_sensor_probe_off(&s_ctrl->sensor_i2c_client->client->dev);
#else
msm_sensor_power_down(s_ctrl);
pr_err(" %s : msm_sensor_power_down : rc = %d E\n",__func__, rc);
#endif
if (sgpio_ctrl(sgpios, CAMIO_RST_N, 0) < 0) rc = -EIO;
mdelay(1); /* > 20 cycles (approx. 0.64us) */
if (sgpio_ctrl(sgpios, CAMIO_STB_N, 0) < 0) rc = -EIO;
if (svreg_ctrl(svregs, CAMV_CORE_1P8V, 0) < 0) rc = -EIO;
if (svreg_ctrl(svregs, CAMV_A_2P8V, 0) < 0) rc = -EIO;
if (svreg_ctrl(svregs, CAMV_IO_1P8V, 0) < 0) rc = -EIO;
if (sgpio_ctrl(sgpios, CAM1_IOVDD_EN, 0) < 0) rc = -EIO;
svreg_release(svregs, CAMV_MAX);
sgpio_release(sgpios, CAMIO_MAX);
#ifdef CONFIG_PANTECH_CAMERA_TUNER
kfree(yacd5c1sbdbc_recommend_tuner_settings);
#endif
pr_err("%s X (%d)\n", __func__, rc);
return rc;
#if 0
/* Reset *********************************************************/
gpio_set_value_cansleep(data->sensor_platform_info->sensor_reset, 0);
usleep_range(1000, 2000);
gpio_free(data->sensor_platform_info->sensor_reset);
mdelay(1);
/* Standby *********************************************************/
if(data->sensor_platform_info->sensor_pwd)
{
gpio_set_value_cansleep(data->sensor_platform_info->sensor_pwd, 0);
gpio_free(data->sensor_platform_info->sensor_pwd);
}
mdelay(1);
/* VREG disable *****************************************************/
rc = regulator_disable(vreg_lvs6_1p8);
if (rc){
printk("%s: Disable regulator vreg_lvs6_1p8 failed\n", __func__);
goto fail;
}
regulator_put(vreg_lvs6_1p8);
vreg_lvs6_1p8 = NULL;
mdelay(1);
rc = regulator_disable(vreg_l11_2p85);
if (rc){
printk("%s: Disable regulator vreg_l11_2p85 failed\n", __func__);
goto fail;
}
regulator_put(vreg_l11_2p85);
vreg_l11_2p85 = NULL;
mdelay(1);
rc = regulator_disable(vreg_lvs5_1p8);
if (rc){
printk("%s: Disable regulator vreg_lvs5_1p8 failed\n", __func__);
goto fail;
}
regulator_put(vreg_lvs5_1p8);
vreg_lvs5_1p8 = NULL;
mdelay(1);
/* LDO disable ******************************************************/
gpio_set_value_cansleep(CAM1_IOVDD_EN, 0);
gpio_free(CAM1_IOVDD_EN);
mdelay(1);
#if 0
gpio_set_value_cansleep(CAM1_AVDD_EN, 0);
gpio_free(CAM1_AVDD_EN);
mdelay(1);
gpio_set_value_cansleep(CAM1_DVDD_EN, 0);
gpio_free(CAM1_DVDD_EN);
mdelay(1);
#endif
return 0;
//.........这里部分代码省略.........
示例13: yacd5c1sbdbc_sensor_power_up
//.........这里部分代码省略.........
return rc;
#if 0
/* LDO enable ******************************************************/
rc = gpio_request(CAM1_IOVDD_EN, "yacd5c1sbdbc");
if (!rc) {
printk("%s:%d\n", __func__, __LINE__);
gpio_direction_output(CAM1_IOVDD_EN, 1);
} else {
printk("%s: gpio CAM1_IOVDD_EN request fail", __func__);
}
mdelay(1);
#if 0
rc = gpio_request(CAM1_AVDD_EN, "yacd5c1sbdbc");
if (!rc) {
printk("%s:%d\n", __func__, __LINE__);
gpio_direction_output(CAM1_AVDD_EN, 1);
} else {
printk("%s: gpio CAM1_AVDD_EN request fail", __func__);
}
mdelay(1);
rc = gpio_request(CAM1_DVDD_EN, "yacd5c1sbdbc");
if (!rc) {
printk("%s:%d\n", __func__, __LINE__);
gpio_direction_output(CAM1_DVDD_EN, 1);
} else {
printk("%s: gpio CAM1_DVDD_EN request fail", __func__);
}
mdelay(1);
#endif
/* VREG enable *****************************************************/
rc = regulator_enable(vreg_lvs5_1p8);
if (rc) {
printk("%s: Enable regulator vreg_lvs5_1p8 failed\n", __func__);
goto fail;
}
mdelay(1);
rc = regulator_enable(vreg_l11_2p85);
if (rc) {
printk("%s: Enable regulator vreg_l11_2p85 failed\n", __func__);
goto fail;
}
mdelay(1);
rc = regulator_enable(vreg_lvs6_1p8);
if (rc) {
printk("%s: Enable regulator vreg_lvs6_1p8 failed\n", __func__);
goto fail;
}
mdelay(1);
/* Standby *********************************************************/
rc = gpio_request(data->sensor_platform_info->sensor_pwd, "yacd5c1sbdbc");
if (!rc) {
printk("%s:Standby\n", __func__);
//gpio_set_value(SENSOR_STANDBY,1);
gpio_set_value_cansleep(data->sensor_platform_info->sensor_pwd, 0);
gpio_direction_output(data->sensor_platform_info->sensor_pwd, 1);
} else {
printk("%s: gpio Standby request fail", __func__);
}
mdelay(1);
/* MCLK set ********************************************************/
printk(" msm_camio_clk_rate_set E\n");
msm_camio_clk_rate_set(MSM_SENSOR_MCLK_24HZ);
printk(" msm_camio_clk_rate_set X\n");
mdelay(1);
/* Reset *********************************************************/
rc = gpio_request(data->sensor_platform_info->sensor_reset, "yacd5c1sbdbc");
if (!rc) {
printk("%s: reset sensor\n", __func__);
gpio_direction_output(data->sensor_platform_info->sensor_reset, 0);
usleep_range(1000, 2000);
gpio_set_value_cansleep(data->sensor_platform_info->sensor_reset, 1);
usleep_range(4000, 5000);
} else {
printk("%s: gpio Reset request fail", __func__);
}
return rc;
fail:
printk("%s Failed!:%d\n",__func__, __LINE__);
if(vreg_lvs6_1p8) {
regulator_put(vreg_lvs6_1p8);
}
if(vreg_l11_2p85) {
regulator_put(vreg_l11_2p85);
}
if(vreg_lvs5_1p8){
regulator_put(vreg_lvs5_1p8);
}
return rc;
#endif
}示例14: apds9900_power_init
static int apds9900_power_init(struct apds9900_priv *alsps, bool on)
{
int ret;
printk("%s on%d\n",__func__,on);
if (!on) {
if (regulator_count_voltages(alsps->vdd) > 0)
regulator_set_voltage(alsps->vdd,
0, STK3X1X_VDD_MAX_UV);
regulator_put(alsps->vdd);
if (regulator_count_voltages(alsps->vio) > 0)
regulator_set_voltage(alsps->vio,
0, STK3X1X_VIO_MAX_UV);
regulator_put(alsps->vio);
} else {
printk("regulator_get \n");
alsps->vdd = regulator_get(&alsps->client->dev, "vdd");
if (IS_ERR(alsps->vdd)) {
ret = PTR_ERR(alsps->vdd);
dev_err(&alsps->client->dev,
"Regulator get failed vdd ret=%d\n", ret);
return ret;
}
printk("regulator_count_voltages\n");
if (regulator_count_voltages(alsps->vdd) > 0) {
ret = regulator_set_voltage(alsps->vdd,
STK3X1X_VDD_MIN_UV,
STK3X1X_VDD_MAX_UV);
if (ret) {
dev_err(&alsps->client->dev,
"Regulator set failed vdd ret=%d\n",
ret);
goto reg_vdd_put;
}
}
printk("regulator_count vio\n");
alsps->vio = regulator_get(&alsps->client->dev, "vio");
if (IS_ERR(alsps->vio)) {
ret = PTR_ERR(alsps->vio);
dev_err(&alsps->client->dev,
"Regulator get failed vio ret=%d\n", ret);
goto reg_vdd_set;
}
if (regulator_count_voltages(alsps->vio) > 0) {
ret = regulator_set_voltage(alsps->vio,
STK3X1X_VIO_MIN_UV,
STK3X1X_VIO_MAX_UV);
if (ret) {
dev_err(&alsps->client->dev,
"Regulator set failed vio ret=%d\n", ret);
goto reg_vio_put;
}
}
}
return 0;
reg_vio_put:
regulator_put(alsps->vio);
reg_vdd_set:
if (regulator_count_voltages(alsps->vdd) > 0)
regulator_set_voltage(alsps->vdd, 0, STK3X1X_VDD_MAX_UV);
reg_vdd_put:
regulator_put(alsps->vdd);
return ret;
}示例15: tegra_camera_probe
static int tegra_camera_probe(struct platform_device *pdev)
{
int err;
struct tegra_camera_dev *dev;
dev_info(&pdev->dev, "%s\n", __func__);
dev = devm_kzalloc(&pdev->dev, sizeof(struct tegra_camera_dev),
GFP_KERNEL);
if (!dev) {
err = -ENOMEM;
dev_err(&pdev->dev, "%s: unable to allocate memory\n",
__func__);
goto alloc_err;
}
mutex_init(&dev->tegra_camera_lock);
/* Powergate VE when boot */
mutex_lock(&dev->tegra_camera_lock);
#ifndef CONFIG_ARCH_TEGRA_2x_SOC
err = tegra_powergate_partition(TEGRA_POWERGATE_VENC);
if (err)
dev_err(&pdev->dev, "%s: powergate failed.\n", __func__);
#endif
mutex_unlock(&dev->tegra_camera_lock);
dev->dev = &pdev->dev;
/* Get regulator pointer */
#ifdef CONFIG_ARCH_TEGRA_2x_SOC
dev->reg = regulator_get(&pdev->dev, "vcsi");
#else
dev->reg = regulator_get(&pdev->dev, "avdd_dsi_csi");
#endif
if (IS_ERR_OR_NULL(dev->reg)) {
if (dev->reg == ERR_PTR(-ENODEV)) {
dev->reg = NULL;
dev_info(&pdev->dev, "%s: no regulator device, overriding\n",
__func__);
} else {
dev_err(&pdev->dev, "%s: couldn't get regulator\n",
__func__);
return PTR_ERR(dev->reg);
}
}
dev->misc_dev.minor = MISC_DYNAMIC_MINOR;
dev->misc_dev.name = TEGRA_CAMERA_NAME;
dev->misc_dev.fops = &tegra_camera_fops;
dev->misc_dev.parent = &pdev->dev;
err = misc_register(&dev->misc_dev);
if (err) {
dev_err(&pdev->dev, "%s: Unable to register misc device!\n",
TEGRA_CAMERA_NAME);
goto misc_register_err;
}
err = tegra_camera_clk_get(pdev, "isp", &dev->isp_clk);
if (err)
goto misc_register_err;
err = tegra_camera_clk_get(pdev, "vi", &dev->vi_clk);
if (err)
goto vi_clk_get_err;
err = tegra_camera_clk_get(pdev, "vi_sensor", &dev->vi_sensor_clk);
if (err)
goto vi_sensor_clk_get_err;
err = tegra_camera_clk_get(pdev, "csus", &dev->csus_clk);
if (err)
goto csus_clk_get_err;
err = tegra_camera_clk_get(pdev, "csi", &dev->csi_clk);
if (err)
goto csi_clk_get_err;
err = tegra_camera_clk_get(pdev, "emc", &dev->emc_clk);
if (err)
goto emc_clk_get_err;
/* dev is set in order to restore in _remove */
platform_set_drvdata(pdev, dev);
return 0;
emc_clk_get_err:
clk_put(dev->emc_clk);
csi_clk_get_err:
clk_put(dev->csus_clk);
csus_clk_get_err:
clk_put(dev->vi_sensor_clk);
vi_sensor_clk_get_err:
clk_put(dev->vi_clk);
vi_clk_get_err:
clk_put(dev->isp_clk);
misc_register_err:
regulator_put(dev->reg);
alloc_err:
return err;
}