static int qrf6285_init_regs(void) { struct regulator_bulk_data regs[ARRAY_SIZE(vreg_info)]; int i, rc; for (i = 0; i < ARRAY_SIZE(regs); i++) { regs[i].supply = vreg_info[i].vreg_id; regs[i].min_uV = vreg_info[i].level_min; regs[i].max_uV = vreg_info[i].level_max; } rc = regulator_bulk_get(NULL, ARRAY_SIZE(regs), regs); if (rc) { pr_err("%s: could not get regulators: %d\n", __func__, rc); goto out; } for (i = 0; i < ARRAY_SIZE(regs); i++) vreg_info[i].reg = regs[i].consumer; return 0; out: return rc; }
void __init msm_camera_vreg_init(void) { int rc; platform_add_devices(camera_devices, ARRAY_SIZE(camera_devices)); if (!machine_is_msm7627a_qrd1()) register_i2c_devices(); rc = regulator_bulk_get(NULL, ARRAY_SIZE(regs_camera), regs_camera); if (rc) { pr_err("%s: could not get regulators: %d\n", __func__, rc); return; } rc = regulator_bulk_set_voltage(ARRAY_SIZE(regs_camera), regs_camera); if (rc) { pr_err("%s: could not set voltages: %d\n", __func__, rc); return; } if (machine_is_msm7627a_qrd1()) i2c_register_board_info(MSM_GSBI0_QUP_I2C_BUS_ID, i2c_camera_devices_qrd, ARRAY_SIZE(i2c_camera_devices_qrd)); else i2c_register_board_info(MSM_GSBI0_QUP_I2C_BUS_ID, i2c_camera_devices, ARRAY_SIZE(i2c_camera_devices)); }
static int ft5x06_ts_power_on(bool on) { int rc; rc = regulator_bulk_get(NULL, ARRAY_SIZE(regs_ft5x06), regs_ft5x06); if (rc) { printk("%s: could not get regulators: %d\n", __func__, rc); } rc = regulator_bulk_set_voltage(ARRAY_SIZE(regs_ft5x06), regs_ft5x06); if (rc) { printk("%s: could not set voltages: %d\n", __func__, rc); } rc = on ? regulator_bulk_enable(ARRAY_SIZE(regs_ft5x06), regs_ft5x06) : regulator_bulk_disable(ARRAY_SIZE(regs_ft5x06), regs_ft5x06); if (rc) pr_err("%s: could not %sable regulators: %d\n", __func__, on ? "en" : "dis", rc); else msleep(50); return rc; }
static int wm8741_probe(struct snd_soc_codec *codec) { struct wm8741_priv *wm8741 = snd_soc_codec_get_drvdata(codec); int ret = 0; int i; for (i = 0; i < ARRAY_SIZE(wm8741->supplies); i++) wm8741->supplies[i].supply = wm8741_supply_names[i]; ret = regulator_bulk_get(codec->dev, ARRAY_SIZE(wm8741->supplies), wm8741->supplies); if (ret != 0) { dev_err(codec->dev, "Failed to request supplies: %d\n", ret); goto err; } ret = regulator_bulk_enable(ARRAY_SIZE(wm8741->supplies), wm8741->supplies); if (ret != 0) { dev_err(codec->dev, "Failed to enable supplies: %d\n", ret); goto err_get; } ret = snd_soc_codec_set_cache_io(codec, 7, 9, wm8741->control_type); if (ret != 0) { dev_err(codec->dev, "Failed to set cache I/O: %d\n", ret); goto err_enable; } ret = wm8741_reset(codec); if (ret < 0) { dev_err(codec->dev, "Failed to issue reset\n"); goto err_enable; } /* Change some default settings - latch VU */ snd_soc_update_bits(codec, WM8741_DACLLSB_ATTENUATION, WM8741_UPDATELL, WM8741_UPDATELL); snd_soc_update_bits(codec, WM8741_DACLMSB_ATTENUATION, WM8741_UPDATELM, WM8741_UPDATELM); snd_soc_update_bits(codec, WM8741_DACRLSB_ATTENUATION, WM8741_UPDATERL, WM8741_UPDATERL); snd_soc_update_bits(codec, WM8741_DACRMSB_ATTENUATION, WM8741_UPDATERM, WM8741_UPDATERM); snd_soc_add_controls(codec, wm8741_snd_controls, ARRAY_SIZE(wm8741_snd_controls)); wm8741_add_widgets(codec); dev_dbg(codec->dev, "Successful registration\n"); return ret; err_enable: regulator_bulk_disable(ARRAY_SIZE(wm8741->supplies), wm8741->supplies); err_get: regulator_bulk_free(ARRAY_SIZE(wm8741->supplies), wm8741->supplies); err: return ret; }
static int wm8731_probe(struct snd_soc_codec *codec) { struct wm8731_priv *wm8731 = snd_soc_codec_get_drvdata(codec); int ret = 0, i; codec->control_data = wm8731->regmap; ret = snd_soc_codec_set_cache_io(codec, 7, 9, SND_SOC_REGMAP); if (ret < 0) { dev_err(codec->dev, "Failed to set cache I/O: %d\n", ret); return ret; } for (i = 0; i < ARRAY_SIZE(wm8731->supplies); i++) wm8731->supplies[i].supply = wm8731_supply_names[i]; ret = regulator_bulk_get(codec->dev, ARRAY_SIZE(wm8731->supplies), wm8731->supplies); if (ret != 0) { dev_err(codec->dev, "Failed to request supplies: %d\n", ret); return ret; } ret = regulator_bulk_enable(ARRAY_SIZE(wm8731->supplies), wm8731->supplies); if (ret != 0) { dev_err(codec->dev, "Failed to enable supplies: %d\n", ret); goto err_regulator_get; } ret = wm8731_reset(codec); if (ret < 0) { dev_err(codec->dev, "Failed to issue reset: %d\n", ret); goto err_regulator_enable; } wm8731_set_bias_level(codec, SND_SOC_BIAS_STANDBY); /* Latch the update bits */ snd_soc_update_bits(codec, WM8731_LOUT1V, 0x100, 0); snd_soc_update_bits(codec, WM8731_ROUT1V, 0x100, 0); snd_soc_update_bits(codec, WM8731_LINVOL, 0x100, 0); snd_soc_update_bits(codec, WM8731_RINVOL, 0x100, 0); /* Disable bypass path by default */ snd_soc_update_bits(codec, WM8731_APANA, 0x8, 0); /* Regulators will have been enabled by bias management */ regulator_bulk_disable(ARRAY_SIZE(wm8731->supplies), wm8731->supplies); return 0; err_regulator_enable: regulator_bulk_disable(ARRAY_SIZE(wm8731->supplies), wm8731->supplies); err_regulator_get: regulator_bulk_free(ARRAY_SIZE(wm8731->supplies), wm8731->supplies); return ret; }
static int driver_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct device_node *np = dev->of_node; struct resource res; printk("======dev %p %s %d\n",dev,__FUNCTION__,__LINE__); int ret = 0; IMG_ASSERT(pdev->resource[0].flags == IORESOURCE_MEM); IMG_ASSERT(pdev->resource[1].flags == IORESOURCE_IRQ); printk("VDEC %s %d \n", __FUNCTION__, __LINE__); //power_on(1); if (NULL == np) { printk("the device node is null\n"); return -1; } printk("VDEC %s %d \n", __FUNCTION__, __LINE__); printk("======dev %p %s %d\n",dev,__FUNCTION__,__LINE__); module_irq = irq_of_parse_and_map(np,0); printk("%s, %d,module_irq = %d\n",__func__,__LINE__,module_irq); ret = of_address_to_resource(np,0,&res); if (ret == 0) { vdec_reg_paddr = res.start; vdec_reg_size = resource_size(&res); printk("%s, %d,vdec_reg_vaddr = %#llx,vdec_reg_size = %#x\n", __func__, __LINE__, vdec_reg_paddr, vdec_reg_size); } vdec_reg_vaddr = of_iomap(np, 0); if (NULL == vdec_reg_vaddr) { printk("get reg base addr failed\n"); } /*start j00140427 add clock and regulator*/ gvdec_regulator.supply = "ldo_vdec"; ret = regulator_bulk_get(dev, 1, &gvdec_regulator); if (ret) { printk("couldn't get regulators %d\n\r", ret); return -1; } gvdec_clk = of_clk_get(np,0); if (IS_ERR(gvdec_clk)) { printk("get vdec clock failed\n"); ret = PTR_ERR(gvdec_clk); regulator_put(gvdec_regulator.consumer); memset(&gvdec_regulator,0,sizeof(gvdec_regulator)); return -1; } /*end j00140427 add clock and regulator*/ gbDevDetected = IMG_TRUE; return 0; }
static int wm8737_probe(struct snd_soc_codec *codec) { struct wm8737_priv *wm8737 = snd_soc_codec_get_drvdata(codec); int ret, i; ret = snd_soc_codec_set_cache_io(codec, 7, 9, wm8737->control_type); if (ret != 0) { dev_err(codec->dev, "Failed to set cache I/O: %d\n", ret); return ret; } for (i = 0; i < ARRAY_SIZE(wm8737->supplies); i++) wm8737->supplies[i].supply = wm8737_supply_names[i]; ret = regulator_bulk_get(codec->dev, ARRAY_SIZE(wm8737->supplies), wm8737->supplies); if (ret != 0) { dev_err(codec->dev, "Failed to request supplies: %d\n", ret); return ret; } ret = regulator_bulk_enable(ARRAY_SIZE(wm8737->supplies), wm8737->supplies); if (ret != 0) { dev_err(codec->dev, "Failed to enable supplies: %d\n", ret); goto err_get; } ret = wm8737_reset(codec); if (ret < 0) { dev_err(codec->dev, "Failed to issue reset\n"); goto err_enable; } snd_soc_update_bits(codec, WM8737_LEFT_PGA_VOLUME, WM8737_LVU, WM8737_LVU); snd_soc_update_bits(codec, WM8737_RIGHT_PGA_VOLUME, WM8737_RVU, WM8737_RVU); wm8737_set_bias_level(codec, SND_SOC_BIAS_STANDBY); /* Bias level configuration will have done an extra enable */ regulator_bulk_disable(ARRAY_SIZE(wm8737->supplies), wm8737->supplies); snd_soc_add_controls(codec, wm8737_snd_controls, ARRAY_SIZE(wm8737_snd_controls)); wm8737_add_widgets(codec); return 0; err_enable: regulator_bulk_disable(ARRAY_SIZE(wm8737->supplies), wm8737->supplies); err_get: regulator_bulk_free(ARRAY_SIZE(wm8737->supplies), wm8737->supplies); return ret; }
static int regulator_userspace_consumer_probe(struct platform_device *pdev) { struct regulator_userspace_consumer_data *pdata; struct userspace_consumer_data *drvdata; int ret; pdata = pdev->dev.platform_data; if (!pdata) return -EINVAL; drvdata = kzalloc(sizeof(struct userspace_consumer_data), GFP_KERNEL); if (drvdata == NULL) return -ENOMEM; drvdata->name = pdata->name; drvdata->num_supplies = pdata->num_supplies; drvdata->supplies = pdata->supplies; mutex_init(&drvdata->lock); ret = regulator_bulk_get(&pdev->dev, drvdata->num_supplies, drvdata->supplies); if (ret) { dev_err(&pdev->dev, "Failed to get supplies: %d\n", ret); goto err_alloc_supplies; } ret = sysfs_create_group(&pdev->dev.kobj, &attr_group); if (ret != 0) goto err_create_attrs; if (pdata->init_on) { ret = regulator_bulk_enable(drvdata->num_supplies, drvdata->supplies); if (ret) { dev_err(&pdev->dev, "Failed to set initial state: %d\n", ret); goto err_enable; } } drvdata->enabled = pdata->init_on; platform_set_drvdata(pdev, drvdata); return 0; err_enable: sysfs_remove_group(&pdev->dev.kobj, &attr_group); err_create_attrs: regulator_bulk_free(drvdata->num_supplies, drvdata->supplies); err_alloc_supplies: kfree(drvdata); return ret; }
int m6mo_mipi_cam_power(int enable) { struct regulator_bulk_data supplies[5]; int num_consumers = ARRAY_SIZE(supplies); unsigned int gpio, front_gpio; int ret; pr_info("%s():%d\n", __FUNCTION__, enable); if (machine_is_m030()) { supplies[0].supply = "cam_isp_1.8v"; supplies[1].supply = "cam_isp_core"; supplies[2].supply = "cam_sensor_2.7v"; supplies[3].supply = "cam_sensor_1.2v"; supplies[4].supply = "cam_af_2.7v"; gpio = M030_GPIO_CAMERA0_RST; front_gpio = M030_GPIO_CAMERA1_PDN; } else { supplies[0].supply = "cam_1.8v"; supplies[1].supply = "cam0_isp_1.2v"; supplies[2].supply = "cam0_sensor_1.2v"; supplies[3].supply = "cam0_sensor_2.7v"; supplies[4].supply = "cam0_af_2.7v"; gpio = BACK_CAM_RST; front_gpio = FRONT_CAM_DOWN; } ret = regulator_bulk_get(NULL, num_consumers, supplies); if (ret) { pr_err("%s():regulator_bulk_get failed\n", __func__); return ret; } if (enable) { gpio_set_value(front_gpio, 1); ret = regulator_bulk_enable(num_consumers, supplies); gpio_set_value(gpio, 1); } else { gpio_set_value(gpio, 0); ret = regulator_bulk_disable(num_consumers, supplies); gpio_set_value(front_gpio, 0); } if (ret) { pr_err("%s():regulator_bulk_%sable failed\n", __func__, enable?"en":"dis"); goto exit_regulator; } usleep_range(5000, 5000); exit_regulator: regulator_bulk_free(num_consumers, supplies); return ret; }
static int atmel_ts_platform_init(struct i2c_client *client) { int rc; struct device *dev = &client->dev; rc = regulator_bulk_get(dev, ARRAY_SIZE(regs_atmel), regs_atmel); if (rc) { dev_err(dev, "%s: could not get regulators: %d\n", __func__, rc); goto out; } rc = regulator_bulk_set_voltage(ARRAY_SIZE(regs_atmel), regs_atmel); if (rc) { dev_err(dev, "%s: could not set voltages: %d\n", __func__, rc); goto reg_free; } rc = gpio_tlmm_config(GPIO_CFG(ATMEL_TS_GPIO_IRQ, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_UP, GPIO_CFG_8MA), GPIO_CFG_ENABLE); if (rc) { dev_err(dev, "%s: gpio_tlmm_config for %d failed\n", __func__, ATMEL_TS_GPIO_IRQ); goto reg_free; } /* configure touchscreen interrupt gpio */ rc = gpio_request(ATMEL_TS_GPIO_IRQ, "atmel_maxtouch_gpio"); if (rc) { dev_err(dev, "%s: unable to request gpio %d\n", __func__, ATMEL_TS_GPIO_IRQ); goto ts_gpio_tlmm_unconfig; } rc = gpio_direction_input(ATMEL_TS_GPIO_IRQ); if (rc < 0) { dev_err(dev, "%s: unable to set the direction of gpio %d\n", __func__, ATMEL_TS_GPIO_IRQ); goto free_ts_gpio; } return 0; free_ts_gpio: gpio_free(ATMEL_TS_GPIO_IRQ); ts_gpio_tlmm_unconfig: gpio_tlmm_config(GPIO_CFG(ATMEL_TS_GPIO_IRQ, 0, GPIO_CFG_INPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_DISABLE); reg_free: regulator_bulk_free(ARRAY_SIZE(regs_atmel), regs_atmel); out: return rc; }
/** * cs4270_probe - ASoC probe function * @pdev: platform device * * This function is called when ASoC has all the pieces it needs to * instantiate a sound driver. */ static int cs4270_probe(struct platform_device *pdev) { struct snd_soc_device *socdev = platform_get_drvdata(pdev); struct snd_soc_codec *codec = cs4270_codec; struct cs4270_private *cs4270 = codec->private_data; int i, ret; /* Connect the codec to the socdev. snd_soc_new_pcms() needs this. */ socdev->card->codec = codec; /* Register PCMs */ ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1); if (ret < 0) { dev_err(codec->dev, "failed to create pcms\n"); return ret; } /* Add the non-DAPM controls */ ret = snd_soc_add_controls(codec, cs4270_snd_controls, ARRAY_SIZE(cs4270_snd_controls)); if (ret < 0) { dev_err(codec->dev, "failed to add controls\n"); goto error_free_pcms; } /* get the power supply regulators */ for (i = 0; i < ARRAY_SIZE(supply_names); i++) cs4270->supplies[i].supply = supply_names[i]; ret = regulator_bulk_get(codec->dev, ARRAY_SIZE(cs4270->supplies), cs4270->supplies); if (ret < 0) goto error_free_pcms; ret = regulator_bulk_enable(ARRAY_SIZE(cs4270->supplies), cs4270->supplies); if (ret < 0) goto error_free_regulators; return 0; error_free_regulators: regulator_bulk_free(ARRAY_SIZE(cs4270->supplies), cs4270->supplies); error_free_pcms: snd_soc_free_pcms(socdev); return ret; }
static void msm_camera_vreg_enable(struct platform_device *pdev) { /*<BU5D09497 lijuan 00152865 20100514 begin*/ #ifndef CONFIG_HUAWEI_CAMERA int count, rc; struct device *dev = &pdev->dev; /* Use gp6 and gp16 if and only if dev name matches. */ if (!strncmp(pdev->name, "msm_camera_sn12m0pz", 20)) count = ARRAY_SIZE(regs); else count = ARRAY_SIZE(regs) - 2; rc = regulator_bulk_get(dev, count, regs); if (rc) { dev_err(dev, "%s: could not get regulators: %d\n", __func__, rc); return; } rc = regulator_bulk_set_voltage(count, regs); if (rc) { dev_err(dev, "%s: could not set voltages: %d\n", __func__, rc); goto reg_free; } rc = regulator_bulk_enable(count, regs); if (rc) { dev_err(dev, "%s: could not enable regulators: %d\n", __func__, rc); goto reg_free; } reg_count = count; return; reg_free: regulator_bulk_free(count, regs); return; #endif /*BU5D09497 lijuan 00152865 20100514 end>*/ }
static int wm8741_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id) { struct wm8741_priv *wm8741; int ret, i; wm8741 = kzalloc(sizeof(struct wm8741_priv), GFP_KERNEL); if (wm8741 == NULL) return -ENOMEM; for (i = 0; i < ARRAY_SIZE(wm8741->supplies); i++) wm8741->supplies[i].supply = wm8741_supply_names[i]; ret = regulator_bulk_get(&i2c->dev, ARRAY_SIZE(wm8741->supplies), wm8741->supplies); if (ret != 0) { dev_err(&i2c->dev, "Failed to request supplies: %d\n", ret); goto err; } ret = regulator_bulk_enable(ARRAY_SIZE(wm8741->supplies), wm8741->supplies); if (ret != 0) { dev_err(&i2c->dev, "Failed to enable supplies: %d\n", ret); goto err_get; } i2c_set_clientdata(i2c, wm8741); wm8741->control_type = SND_SOC_I2C; ret = snd_soc_register_codec(&i2c->dev, &soc_codec_dev_wm8741, &wm8741_dai, 1); if (ret < 0) goto err_enable; return ret; err_enable: regulator_bulk_disable(ARRAY_SIZE(wm8741->supplies), wm8741->supplies); err_get: regulator_bulk_free(ARRAY_SIZE(wm8741->supplies), wm8741->supplies); err: kfree(wm8741); return ret; }
static int mipi_power_control(struct mipi_dsim_device *dsim, unsigned int enable) { int ret; ret = regulator_bulk_get(NULL, ARRAY_SIZE(mipi_supplies), mipi_supplies); if (ret) { pr_err("%s: failed to get regulators: %d\n", __func__, ret); return ret; } if (enable) regulator_bulk_enable(ARRAY_SIZE(mipi_supplies), mipi_supplies); else regulator_bulk_disable(ARRAY_SIZE(mipi_supplies), mipi_supplies); regulator_bulk_free(ARRAY_SIZE(mipi_supplies), mipi_supplies); return 0; }
static void msm_camera_vreg_enable(struct platform_device *pdev) { int count, rc; struct device *dev = &pdev->dev; /* Use gp6 and gp16 if and only if dev name matches. */ if (!strncmp(pdev->name, "msm_camera_sn12m0pz", 20)) count = ARRAY_SIZE(regs); else count = ARRAY_SIZE(regs) - 2; rc = regulator_bulk_get(dev, count, regs); if (rc) { dev_err(dev, "%s: could not get regulators: %d\n", __func__, rc); return; } rc = regulator_bulk_set_voltage(count, regs); if (rc) { dev_err(dev, "%s: could not set voltages: %d\n", __func__, rc); goto reg_free; } rc = regulator_bulk_enable(count, regs); if (rc) { dev_err(dev, "%s: could not enable regulators: %d\n", __func__, rc); goto reg_free; } reg_count = count; return; reg_free: regulator_bulk_free(count, regs); return; }
static int ov7690_cam_power(int enable) { struct regulator_bulk_data supplies[2]; int num_consumers = ARRAY_SIZE(supplies); unsigned int gpio; int ret; pr_info("%s():%d\n", __FUNCTION__, enable); if (machine_is_m030()) { supplies[0].supply = "cam_isp_1.8v"; supplies[1].supply = "cam_front_2.8v"; gpio = M030_GPIO_CAMERA1_PDN; } else { supplies[0].supply = "cam_1.8v"; supplies[1].supply = "cam1_2.8v"; gpio = FRONT_CAM_DOWN; } ret = regulator_bulk_get(NULL, num_consumers, supplies); if (ret) { pr_err("%s():regulator_bulk_get failed\n", __func__); return ret; } if (enable) { ret = regulator_bulk_enable(num_consumers, supplies); } else { ret = regulator_bulk_disable(num_consumers, supplies); } if (ret) { pr_err("%s():regulator_bulk_%sable failed\n", __func__, enable?"en":"dis"); goto exit_regulator; } usleep_range(5000, 5000); exit_regulator: regulator_bulk_free(num_consumers, supplies); return ret; }
void __init msm7627a_camera_init(void) { int rc; #ifndef CONFIG_MSM_CAMERA_V4L2 if (machine_is_msm7627a_qrd1()) { qrd1_camera_gpio_cfg(); platform_add_devices(camera_devices_qrd, ARRAY_SIZE(camera_devices_qrd)); } else platform_add_devices(camera_devices_msm, ARRAY_SIZE(camera_devices_msm)); #endif if (!machine_is_msm7627a_qrd1()) register_i2c_devices(); rc = regulator_bulk_get(NULL, ARRAY_SIZE(regs_camera), regs_camera); if (rc) { pr_err("%s: could not get regulators: %d\n", __func__, rc); return; } rc = regulator_bulk_set_voltage(ARRAY_SIZE(regs_camera), regs_camera); if (rc) { pr_err("%s: could not set voltages: %d\n", __func__, rc); return; } #if defined(CONFIG_MSM_CAMERA_V4L2) msm7x27a_init_cam(); #endif #ifndef CONFIG_MSM_CAMERA_V4L2 if (machine_is_msm7627a_qrd1()) i2c_register_board_info(MSM_GSBI0_QUP_I2C_BUS_ID, i2c_camera_devices_qrd, ARRAY_SIZE(i2c_camera_devices_qrd)); else #endif i2c_register_board_info(MSM_GSBI0_QUP_I2C_BUS_ID, i2c_camera_devices, ARRAY_SIZE(i2c_camera_devices)); }
static int lcd_power_on(struct lcd_device *ld, int enable) { int ret; ret = regulator_bulk_get(NULL, ARRAY_SIZE(panel_supplies), panel_supplies); if (ret) { pr_err("%s: failed to get regulators: %d\n", __func__, ret); return ret; } if (enable) regulator_bulk_enable(ARRAY_SIZE(panel_supplies), panel_supplies); else { regulator_bulk_disable(ARRAY_SIZE(panel_supplies), panel_supplies); #if defined(GPIO_MLCD_RST) gpio_request_one(GPIO_MLCD_RST, GPIOF_OUT_INIT_LOW, "GPD1"); gpio_free(GPIO_MLCD_RST); #endif } regulator_bulk_free(ARRAY_SIZE(panel_supplies), panel_supplies); return 0; }
static int wm8523_probe(struct snd_soc_codec *codec) { struct wm8523_priv *wm8523 = snd_soc_codec_get_drvdata(codec); int ret, i; wm8523->rate_constraint.list = &wm8523->rate_constraint_list[0]; wm8523->rate_constraint.count = ARRAY_SIZE(wm8523->rate_constraint_list); ret = snd_soc_codec_set_cache_io(codec, 8, 16, wm8523->control_type); if (ret != 0) { dev_err(codec->dev, "Failed to set cache I/O: %d\n", ret); return ret; } for (i = 0; i < ARRAY_SIZE(wm8523->supplies); i++) wm8523->supplies[i].supply = wm8523_supply_names[i]; ret = regulator_bulk_get(codec->dev, ARRAY_SIZE(wm8523->supplies), wm8523->supplies); if (ret != 0) { dev_err(codec->dev, "Failed to request supplies: %d\n", ret); return ret; } ret = regulator_bulk_enable(ARRAY_SIZE(wm8523->supplies), wm8523->supplies); if (ret != 0) { dev_err(codec->dev, "Failed to enable supplies: %d\n", ret); goto err_get; } ret = snd_soc_read(codec, WM8523_DEVICE_ID); if (ret < 0) { dev_err(codec->dev, "Failed to read ID register\n"); goto err_enable; } if (ret != wm8523_reg[WM8523_DEVICE_ID]) { dev_err(codec->dev, "Device is not a WM8523, ID is %x\n", ret); ret = -EINVAL; goto err_enable; } ret = snd_soc_read(codec, WM8523_REVISION); if (ret < 0) { dev_err(codec->dev, "Failed to read revision register\n"); goto err_enable; } dev_info(codec->dev, "revision %c\n", (ret & WM8523_CHIP_REV_MASK) + 'A'); ret = wm8523_reset(codec); if (ret < 0) { dev_err(codec->dev, "Failed to issue reset\n"); goto err_enable; } /* Change some default settings - latch VU and enable ZC */ snd_soc_update_bits(codec, WM8523_DAC_GAINR, WM8523_DACR_VU, WM8523_DACR_VU); snd_soc_update_bits(codec, WM8523_DAC_CTRL3, WM8523_ZC, WM8523_ZC); wm8523_set_bias_level(codec, SND_SOC_BIAS_STANDBY); /* Bias level configuration will have done an extra enable */ regulator_bulk_disable(ARRAY_SIZE(wm8523->supplies), wm8523->supplies); return 0; err_enable: regulator_bulk_disable(ARRAY_SIZE(wm8523->supplies), wm8523->supplies); err_get: regulator_bulk_free(ARRAY_SIZE(wm8523->supplies), wm8523->supplies); return ret; }
/* * Instantiate the generic non-control parts of the device. */ static int wm8994_device_init(struct wm8994 *wm8994, int irq) { struct wm8994_pdata *pdata = wm8994->dev->platform_data; const char *devname; int ret, i; mutex_init(&wm8994->io_lock); dev_set_drvdata(wm8994->dev, wm8994); // ret = gpio_request(GPIO_WM8994_LDO_EN, "wm8994_ldo"); if (ret < 0) { printk(KERN_ERR "Can't request gpio%d for wm8994_ldo: %d\n", GPIO_WM8994_LDO_EN, ret); goto err; } tegra_gpio_enable(GPIO_WM8994_LDO_EN); ret = gpio_direction_output(GPIO_WM8994_LDO_EN, 1); if (ret < 0) { printk(KERN_ERR "Can't set gpio%d direction to output: %d\n", GPIO_WM8994_LDO_EN, ret); goto err; } gpio_set_value(GPIO_WM8994_LDO_EN, 1); msleep(10); // // /* Add the on-chip regulators first for bootstrapping */ ret = mfd_add_devices(wm8994->dev, -1, wm8994_regulator_devs, ARRAY_SIZE(wm8994_regulator_devs), NULL, 0); if (ret != 0) { dev_err(wm8994->dev, "Failed to add children: %d\n", ret); goto err; } switch (wm8994->type) { case WM8994: wm8994->num_supplies = ARRAY_SIZE(wm8994_main_supplies); break; case WM8958: wm8994->num_supplies = ARRAY_SIZE(wm8958_main_supplies); break; default: BUG(); return -EINVAL; } wm8994->supplies = kzalloc(sizeof(struct regulator_bulk_data) * wm8994->num_supplies, GFP_KERNEL); if (!wm8994->supplies) { ret = -ENOMEM; goto err; } switch (wm8994->type) { case WM8994: for (i = 0; i < ARRAY_SIZE(wm8994_main_supplies); i++) wm8994->supplies[i].supply = wm8994_main_supplies[i]; break; case WM8958: for (i = 0; i < ARRAY_SIZE(wm8958_main_supplies); i++) wm8994->supplies[i].supply = wm8958_main_supplies[i]; break; default: BUG(); return -EINVAL; } ret = regulator_bulk_get(wm8994->dev, wm8994->num_supplies, wm8994->supplies); if (ret != 0) { dev_err(wm8994->dev, "Failed to get supplies: %d\n", ret); goto err_supplies; } ret = regulator_bulk_enable(wm8994->num_supplies, wm8994->supplies); if (ret != 0) { dev_err(wm8994->dev, "Failed to enable supplies: %d\n", ret); goto err_get; } ret = wm8994_reg_read(wm8994, WM8994_SOFTWARE_RESET); if (ret < 0) { dev_err(wm8994->dev, "Failed to read ID register\n"); goto err_enable; } switch (ret) { case 0x8994: devname = "WM8994"; if (wm8994->type != WM8994) dev_warn(wm8994->dev, "Device registered as type %d\n", wm8994->type); wm8994->type = WM8994; break; case 0x8958: devname = "WM8958"; if (wm8994->type != WM8958) dev_warn(wm8994->dev, "Device registered as type %d\n", wm8994->type); wm8994->type = WM8958; break; default: dev_err(wm8994->dev, "Device is not a WM8994, ID is %x\n", ret); ret = -EINVAL; goto err_enable; } ret = wm8994_reg_read(wm8994, WM8994_CHIP_REVISION); if (ret < 0) { dev_err(wm8994->dev, "Failed to read revision register: %d\n", ret); goto err_enable; } switch (ret) { case 0: case 1: if (wm8994->type == WM8994) dev_warn(wm8994->dev, "revision %c not fully supported\n", 'A' + ret); break; default: break; } dev_info(wm8994->dev, "%s revision %c\n", devname, 'A' + ret); if (pdata) { wm8994->irq_base = pdata->irq_base; wm8994->gpio_base = pdata->gpio_base; /* GPIO configuration is only applied if it's non-zero */ for (i = 0; i < ARRAY_SIZE(pdata->gpio_defaults); i++) { if (pdata->gpio_defaults[i]) { wm8994_set_bits(wm8994, WM8994_GPIO_1 + i, 0xffff, pdata->gpio_defaults[i]); } } } /* In some system designs where the regulators are not in use, * we can achieve a small reduction in leakage currents by * floating LDO outputs. This bit makes no difference if the * LDOs are enabled, it only affects cases where the LDOs were * in operation and are then disabled. */ for (i = 0; i < WM8994_NUM_LDO_REGS; i++) { if (wm8994_ldo_in_use(pdata, i)) wm8994_set_bits(wm8994, WM8994_LDO_1 + i, WM8994_LDO1_DISCH, WM8994_LDO1_DISCH); else wm8994_set_bits(wm8994, WM8994_LDO_1 + i, WM8994_LDO1_DISCH, 0); } wm8994_irq_init(wm8994); ret = mfd_add_devices(wm8994->dev, -1, wm8994_devs, ARRAY_SIZE(wm8994_devs), NULL, 0); if (ret != 0) { dev_err(wm8994->dev, "Failed to add children: %d\n", ret); goto err_irq; } #if !defined(CONFIG_ARCH_TEGRA) pm_runtime_enable(wm8994->dev); pm_runtime_resume(wm8994->dev); #endif return 0; err_irq: wm8994_irq_exit(wm8994); err_enable: regulator_bulk_disable(wm8994->num_supplies, wm8994->supplies); err_get: regulator_bulk_free(wm8994->num_supplies, wm8994->supplies); err_supplies: kfree(wm8994->supplies); err: mfd_remove_devices(wm8994->dev); kfree(wm8994); return ret; }
static int __devinit lis3lv02d_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id) { int ret = 0; struct lis3lv02d_platform_data *pdata = client->dev.platform_data; #ifdef CONFIG_OF if (of_match_device(lis3lv02d_i2c_dt_ids, &client->dev)) { lis3_dev.of_node = client->dev.of_node; ret = lis3lv02d_init_dt(&lis3_dev); if (ret) return ret; pdata = lis3_dev.pdata; } #endif if (pdata) { if ((pdata->driver_features & LIS3_USE_BLOCK_READ) && (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_I2C_BLOCK))) lis3_dev.blkread = lis3_i2c_blockread; if (pdata->axis_x) lis3lv02d_axis_map.x = pdata->axis_x; if (pdata->axis_y) lis3lv02d_axis_map.y = pdata->axis_y; if (pdata->axis_z) lis3lv02d_axis_map.z = pdata->axis_z; if (pdata->setup_resources) ret = pdata->setup_resources(); if (ret) goto fail; } lis3_dev.regulators[0].supply = reg_vdd; lis3_dev.regulators[1].supply = reg_vdd_io; ret = regulator_bulk_get(&client->dev, ARRAY_SIZE(lis3_dev.regulators), lis3_dev.regulators); if (ret < 0) goto fail; lis3_dev.pdata = pdata; lis3_dev.bus_priv = client; lis3_dev.init = lis3_i2c_init; lis3_dev.read = lis3_i2c_read; lis3_dev.write = lis3_i2c_write; lis3_dev.irq = client->irq; lis3_dev.ac = lis3lv02d_axis_map; lis3_dev.pm_dev = &client->dev; i2c_set_clientdata(client, &lis3_dev); /* Provide power over the init call */ lis3_reg_ctrl(&lis3_dev, LIS3_REG_ON); ret = lis3lv02d_init_device(&lis3_dev); lis3_reg_ctrl(&lis3_dev, LIS3_REG_OFF); if (ret) goto fail2; return 0; fail2: regulator_bulk_free(ARRAY_SIZE(lis3_dev.regulators), lis3_dev.regulators); fail: if (pdata && pdata->release_resources) pdata->release_resources(); return ret; }
#include <plat/pd.h> #include <plat/devs.h> #include <plat/tvout.h> #ifdef CONFIG_MHL_DRIVER static int m032_mhl_power_on(struct mhl_platform_data *pdata, int enable) { struct regulator_bulk_data supplies[] ={ {.supply = "vdd_ldo26",}, {.supply = "vdd_ldo20",}, {.supply = "MHL_1.2V",}, }; int num_consumers = ARRAY_SIZE(supplies); int ret = 0; ret = regulator_bulk_get(NULL, num_consumers, supplies); if (ret) { pr_err("regulator_bulk_get failed\n"); return ret; } ret = enable ? regulator_bulk_enable(num_consumers, supplies): regulator_bulk_disable(num_consumers, supplies); if (ret) { MHLPRINTK("regulator_%sable failed\n", enable ? "en" : "dis"); return ret; } regulator_bulk_free(num_consumers, supplies); return 0;
static void lcdc_toshiba_gpio_init(void) { int rc = 0; if (!lcdc_gpio_initialized) { if (gpio_request(GPIO_SPI_CLK, "spi_clk")) { pr_err("failed to request gpio spi_clk\n"); return; } if (gpio_request(GPIO_SPI_CS0_N, "spi_cs")) { pr_err("failed to request gpio spi_cs0_N\n"); goto fail_gpio6; } if (gpio_request(GPIO_SPI_MOSI, "spi_mosi")) { pr_err("failed to request gpio spi_mosi\n"); goto fail_gpio5; } if (gpio_request(GPIO_SPI_MISO, "spi_miso")) { pr_err("failed to request gpio spi_miso\n"); goto fail_gpio4; } if (gpio_request(GPIO_DISPLAY_PWR_EN, "gpio_disp_pwr")) { pr_err("failed to request gpio_disp_pwr\n"); goto fail_gpio3; } if (gpio_request(GPIO_BACKLIGHT_EN, "gpio_bkl_en")) { pr_err("failed to request gpio_bkl_en\n"); goto fail_gpio2; } pmapp_disp_backlight_init(); rc = regulator_bulk_get(NULL, ARRAY_SIZE(regs_lcdc), regs_lcdc); if (rc) { pr_err("%s: could not get regulators: %d\n", __func__, rc); goto fail_gpio1; } rc = regulator_bulk_set_voltage(ARRAY_SIZE(regs_lcdc), regs_lcdc); if (rc) { pr_err("%s: could not set voltages: %d\n", __func__, rc); goto fail_vreg; } lcdc_gpio_initialized = 1; } return; fail_vreg: regulator_bulk_free(ARRAY_SIZE(regs_lcdc), regs_lcdc); fail_gpio1: gpio_free(GPIO_BACKLIGHT_EN); fail_gpio2: gpio_free(GPIO_DISPLAY_PWR_EN); fail_gpio3: gpio_free(GPIO_SPI_MISO); fail_gpio4: gpio_free(GPIO_SPI_MOSI); fail_gpio5: gpio_free(GPIO_SPI_CS0_N); fail_gpio6: gpio_free(GPIO_SPI_CLK); lcdc_gpio_initialized = 0; }
static int mipi_dsi_panel_power(int on) { int rc = 0; uint32_t lcdc_reset_cfg; /* I2C-controlled GPIO Expander -init of the GPIOs very late */ if (unlikely(!dsi_gpio_initialized)) { pmapp_disp_backlight_init(); rc = gpio_request(GPIO_DISPLAY_PWR_EN, "gpio_disp_pwr"); if (rc < 0) { pr_err("failed to request gpio_disp_pwr\n"); return rc; } if (machine_is_msm7x27a_surf() || machine_is_msm7625a_surf()) { rc = gpio_direction_output(GPIO_DISPLAY_PWR_EN, 1); if (rc < 0) { pr_err("failed to enable display pwr\n"); goto fail_gpio1; } rc = gpio_request(GPIO_BACKLIGHT_EN, "gpio_bkl_en"); if (rc < 0) { pr_err("failed to request gpio_bkl_en\n"); goto fail_gpio1; } rc = gpio_direction_output(GPIO_BACKLIGHT_EN, 1); if (rc < 0) { pr_err("failed to enable backlight\n"); goto fail_gpio2; } } rc = regulator_bulk_get(NULL, ARRAY_SIZE(regs_dsi), regs_dsi); if (rc) { pr_err("%s: could not get regulators: %d\n", __func__, rc); goto fail_gpio2; } rc = regulator_bulk_set_voltage(ARRAY_SIZE(regs_dsi), regs_dsi); if (rc) { pr_err("%s: could not set voltages: %d\n", __func__, rc); goto fail_vreg; } if (pmapp_disp_backlight_set_brightness(100)) pr_err("backlight set brightness failed\n"); dsi_gpio_initialized = 1; } if (machine_is_msm7x27a_surf() || machine_is_msm7625a_surf()) { gpio_set_value_cansleep(GPIO_DISPLAY_PWR_EN, on); gpio_set_value_cansleep(GPIO_BACKLIGHT_EN, on); } else if (machine_is_msm7x27a_ffa() || machine_is_msm7625a_ffa()) { if (on) { /* This line drives an active low pin on FFA */ rc = gpio_direction_output(GPIO_DISPLAY_PWR_EN, !on); if (rc < 0) pr_err("failed to set direction for " "display pwr\n"); } else { gpio_set_value_cansleep(GPIO_DISPLAY_PWR_EN, !on); rc = gpio_direction_input(GPIO_DISPLAY_PWR_EN); if (rc < 0) pr_err("failed to set direction for " "display pwr\n"); } } if (on) { gpio_set_value_cansleep(GPIO_LCDC_BRDG_PD, 0); if (machine_is_msm7x27a_surf() || machine_is_msm7625a_surf()) { lcdc_reset_cfg = readl_relaxed(lcdc_reset_ptr); rmb(); lcdc_reset_cfg &= ~1; writel_relaxed(lcdc_reset_cfg, lcdc_reset_ptr); msleep(20); wmb(); lcdc_reset_cfg |= 1; writel_relaxed(lcdc_reset_cfg, lcdc_reset_ptr); } else { gpio_set_value_cansleep(GPIO_LCDC_BRDG_RESET_N, 0); msleep(20); gpio_set_value_cansleep(GPIO_LCDC_BRDG_RESET_N, 1); } } else { gpio_set_value_cansleep(GPIO_LCDC_BRDG_PD, 1); } rc = on ? regulator_bulk_enable(ARRAY_SIZE(regs_dsi), regs_dsi) : regulator_bulk_disable(ARRAY_SIZE(regs_dsi), regs_dsi); if (rc) pr_err("%s: could not %sable regulators: %d\n", __func__, on ? "en" : "dis", rc); return rc; fail_vreg: regulator_bulk_free(ARRAY_SIZE(regs_dsi), regs_dsi); fail_gpio2: gpio_free(GPIO_BACKLIGHT_EN); fail_gpio1: gpio_free(GPIO_DISPLAY_PWR_EN); dsi_gpio_initialized = 0; return rc; }
void __init msm7627a_camera_init(void) { int rc; /* <DTS2012041003722 sibingsong 20120410 begin */ /*< DTS2012021000399 yuguangcai 20120211 begin */ #ifdef CONFIG_HUAWEI_CAMERA /*before camera probe, config the camera pwd gpio*/ camera_sensor_pwd_config(); #endif /* DTS2012021000399 yuguangcai 20120211 end > */ /* DTS2012041003722 sibingsong 20120410 end> */ #ifndef CONFIG_MSM_CAMERA_V4L2 if (machine_is_msm7627a_qrd1()) { qrd1_camera_gpio_cfg(); platform_add_devices(camera_devices_qrd, ARRAY_SIZE(camera_devices_qrd)); } else platform_add_devices(camera_devices_msm, ARRAY_SIZE(camera_devices_msm)); #endif if (!machine_is_msm7627a_qrd1()) register_i2c_devices(); /* < DTS2012050205820 zhouqiwei 20120502 begin */ if (WIFI_QUALCOMM == get_hw_wifi_device_type()) { if (HW_DS != get_hw_ds_type()) { rc = regulator_bulk_get(NULL, ARRAY_SIZE(regs_camera_WIFI_QUALCOMM), regs_camera_WIFI_QUALCOMM); if (rc) { pr_err("%s: could not get regs_camera_WIFI_QUALCOMM: %d\n", __func__, rc); return; } rc = regulator_bulk_set_voltage(ARRAY_SIZE(regs_camera_WIFI_QUALCOMM), regs_camera_WIFI_QUALCOMM); if (rc) { pr_err("%s: could not set regs_camera_WIFI_QUALCOMM: %d\n", __func__, rc); return; } } else { rc = regulator_bulk_get(NULL, ARRAY_SIZE(regs_camera_HW_DS), regs_camera_HW_DS); if (rc) { pr_err("%s: could not get regs_camera_HW_DSs: %d\n", __func__, rc); return; } rc = regulator_bulk_set_voltage(ARRAY_SIZE(regs_camera_HW_DS), regs_camera_HW_DS); if (rc) { pr_err("%s: could not set regs_camera_HW_DS: %d\n", __func__, rc); return; } } } else { rc = regulator_bulk_get(NULL, ARRAY_SIZE(regs_camera), regs_camera); if (rc) { pr_err("%s: could not get regulators: %d\n", __func__, rc); return; } rc = regulator_bulk_set_voltage(ARRAY_SIZE(regs_camera), regs_camera); if (rc) { pr_err("%s: could not set voltages: %d\n", __func__, rc); return; } } /* DTS2012050205820 zhouqiwei 20120502 end > */ #if defined(CONFIG_MSM_CAMERA_V4L2) msm7x27a_init_cam(); #endif #ifndef CONFIG_MSM_CAMERA_V4L2 if (machine_is_msm7627a_qrd1()) i2c_register_board_info(MSM_GSBI0_QUP_I2C_BUS_ID, i2c_camera_devices_qrd, ARRAY_SIZE(i2c_camera_devices_qrd)); else #endif i2c_register_board_info(MSM_GSBI0_QUP_I2C_BUS_ID, i2c_camera_devices, ARRAY_SIZE(i2c_camera_devices)); }
void __init msm7627a_camera_init(void) { #ifndef CONFIG_MSM_CAMERA_V4L2 int rc; #endif pr_debug("msm7627a_camera_init Entered\n"); if (machine_is_msm7627a_qrd3() || machine_is_msm8625_qrd7()) { ov7692_cam_req_gpio[0].gpio = GPIO_SKU7_CAM_VGA_SHDN; ov7692_cam_gpio_set_tbl[0].gpio = GPIO_SKU7_CAM_VGA_SHDN; ov7692_cam_gpio_set_tbl[1].gpio = GPIO_SKU7_CAM_VGA_SHDN; msm_camera_sensor_ov5647_data.sensor_pwd = GPIO_SKU7_CAM_5MP_SHDN_N; msm_camera_sensor_ov5647_data.sensor_reset = GPIO_SKU7_CAM_5MP_CAMIF_RESET; } /* LCD and camera power (VREG & LDO) init */ if (machine_is_msm7627a_evb() || machine_is_msm8625_evb() || machine_is_msm8625_evt() || machine_is_msm7627a_qrd3() || machine_is_msm8625_qrd7()) { #ifndef CONFIG_MSM_CAMERA_V4L2 lcd_camera_power_init(); #endif evb_camera_gpio_cfg(); } #ifndef CONFIG_MSM_CAMERA_V4L2 if (machine_is_msm7627a_qrd1()) { qrd1_camera_gpio_cfg(); platform_add_devices(camera_devices_qrd, ARRAY_SIZE(camera_devices_qrd)); } else if (machine_is_msm7627a_evb() || machine_is_msm8625_evb() || machine_is_msm8625_evt() || machine_is_msm7627a_qrd3() || machine_is_msm8625_qrd7()) { platform_add_devices(camera_devices_evb, ARRAY_SIZE(camera_devices_evb)); } else if (machine_is_msm7627a_qrd3()) return; else platform_add_devices(camera_devices_msm, ARRAY_SIZE(camera_devices_msm)); #endif if (!machine_is_msm7627a_qrd1() || !machine_is_msm7627a_evb() || !machine_is_msm8625_evb() || !machine_is_msm8625_evt() || !machine_is_msm7627a_qrd3() || !machine_is_msm8625_qrd7()) register_i2c_devices(); #ifndef CONFIG_MSM_CAMERA_V4L2 rc = regulator_bulk_get(NULL, ARRAY_SIZE(regs_camera), regs_camera); if (rc) { pr_err("%s: could not get regulators: %d\n", __func__, rc); return; } rc = regulator_bulk_set_voltage(ARRAY_SIZE(regs_camera), regs_camera); if (rc) { pr_err("%s: could not set voltages: %d\n", __func__, rc); return; } #endif #if defined(CONFIG_MSM_CAMERA_V4L2) msm7x27a_init_cam(); #endif #ifndef CONFIG_MSM_CAMERA_V4L2 if (machine_is_msm7627a_qrd1()) { i2c_register_board_info(MSM_GSBI0_QUP_I2C_BUS_ID, i2c_camera_devices_qrd, ARRAY_SIZE(i2c_camera_devices_qrd)); } else if (machine_is_msm7627a_evb() || machine_is_msm8625_evb() || machine_is_msm8625_evt() || machine_is_msm7627a_qrd3() || machine_is_msm8625_qrd7()) { pr_debug("machine_is_msm7627a_evb i2c_register_board_info\n"); i2c_register_board_info(MSM_GSBI0_QUP_I2C_BUS_ID, i2c_camera_devices_evb, ARRAY_SIZE(i2c_camera_devices_evb)); } else #endif pr_debug("i2c_register_board_info\n"); i2c_register_board_info(MSM_GSBI0_QUP_I2C_BUS_ID, i2c_camera_devices, ARRAY_SIZE(i2c_camera_devices)); }
void sku3_lcdc_lcd_camera_power_init(void) { int rc = 0; u32 socinfo = socinfo_get_platform_type(); /* LDO_EXT2V8 */ if (gpio_request(SKU3_LCDC_LCD_CAMERA_LDO_2V8, "lcd_camera_ldo_2v8")) { pr_err("failed to request gpio lcd_camera_ldo_2v8\n"); return; } rc = gpio_tlmm_config(GPIO_CFG(SKU3_LCDC_LCD_CAMERA_LDO_2V8, 0, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), GPIO_CFG_ENABLE); if (rc < 0) { pr_err("%s:unable to enable lcd_camera_ldo_2v8!\n", __func__); goto fail_gpio2; } /* LDO_EVT1V8 */ if (socinfo == 0x0B) { if (gpio_request(SKU3_LCDC_LCD_CAMERA_LDO_1V8, "lcd_camera_ldo_1v8")) { pr_err("failed to request gpio lcd_camera_ldo_1v8\n"); goto fail_gpio1; } rc = gpio_tlmm_config(GPIO_CFG(SKU3_LCDC_LCD_CAMERA_LDO_1V8, 0, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), GPIO_CFG_ENABLE); if (rc < 0) { pr_err("%s: unable to enable lcdc_camera_ldo_1v8!\n", __func__); goto fail_gpio1; } } else if (socinfo == 0x0F || machine_is_msm8625_qrd7()) { if (gpio_request(SKU3_1_LCDC_LCD_CAMERA_LDO_1V8, "lcd_camera_ldo_1v8")) { pr_err("failed to request gpio lcd_camera_ldo_1v8\n"); goto fail_gpio1; } rc = gpio_tlmm_config(GPIO_CFG(SKU3_1_LCDC_LCD_CAMERA_LDO_1V8, 0, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), GPIO_CFG_ENABLE); if (rc < 0) { pr_err("%s: unable to enable lcdc_camera_ldo_1v8!\n", __func__); goto fail_gpio1; } } rc = regulator_bulk_get(NULL, ARRAY_SIZE(regs_truly_lcdc), regs_truly_lcdc); if (rc) pr_err("%s: could not get regulators: %d\n", __func__, rc); rc = regulator_bulk_set_voltage(ARRAY_SIZE(regs_truly_lcdc), regs_truly_lcdc); if (rc) pr_err("%s: could not set voltages: %d\n", __func__, rc); return; fail_gpio1: if (socinfo == 0x0B) gpio_free(SKU3_LCDC_LCD_CAMERA_LDO_1V8); else if (socinfo == 0x0F || machine_is_msm8625_qrd7()) gpio_free(SKU3_1_LCDC_LCD_CAMERA_LDO_1V8); fail_gpio2: gpio_free(SKU3_LCDC_LCD_CAMERA_LDO_2V8); return; }
/** * cs4270_probe - ASoC probe function * @pdev: platform device * * This function is called when ASoC has all the pieces it needs to * instantiate a sound driver. */ static int cs4270_probe(struct snd_soc_codec *codec) { struct cs4270_private *cs4270 = snd_soc_codec_get_drvdata(codec); int i, ret; /* Tell ASoC what kind of I/O to use to read the registers. ASoC will * then do the I2C transactions itself. */ ret = snd_soc_codec_set_cache_io(codec, 8, 8, cs4270->control_type); if (ret < 0) { dev_err(codec->dev, "failed to set cache I/O (ret=%i)\n", ret); return ret; } /* Disable auto-mute. This feature appears to be buggy. In some * situations, auto-mute will not deactivate when it should, so we want * this feature disabled by default. An application (e.g. alsactl) can * re-enabled it by using the controls. */ ret = snd_soc_update_bits(codec, CS4270_MUTE, CS4270_MUTE_AUTO, 0); if (ret < 0) { dev_err(codec->dev, "i2c write failed\n"); return ret; } /* Disable automatic volume control. The hardware enables, and it * causes volume change commands to be delayed, sometimes until after * playback has started. An application (e.g. alsactl) can * re-enabled it by using the controls. */ ret = snd_soc_update_bits(codec, CS4270_TRANS, CS4270_TRANS_SOFT | CS4270_TRANS_ZERO, 0); if (ret < 0) { dev_err(codec->dev, "i2c write failed\n"); return ret; } /* Add the non-DAPM controls */ ret = snd_soc_add_codec_controls(codec, cs4270_snd_controls, ARRAY_SIZE(cs4270_snd_controls)); if (ret < 0) { dev_err(codec->dev, "failed to add controls\n"); return ret; } /* get the power supply regulators */ for (i = 0; i < ARRAY_SIZE(supply_names); i++) cs4270->supplies[i].supply = supply_names[i]; ret = regulator_bulk_get(codec->dev, ARRAY_SIZE(cs4270->supplies), cs4270->supplies); if (ret < 0) return ret; ret = regulator_bulk_enable(ARRAY_SIZE(cs4270->supplies), cs4270->supplies); if (ret < 0) goto error_free_regulators; return 0; error_free_regulators: regulator_bulk_free(ARRAY_SIZE(cs4270->supplies), cs4270->supplies); return ret; }
static int __devinit apds990x_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct apds990x_chip *chip; int err; chip = kzalloc(sizeof *chip, GFP_KERNEL); if (!chip) return -ENOMEM; i2c_set_clientdata(client, chip); chip->client = client; init_waitqueue_head(&chip->wait); mutex_init(&chip->mutex); chip->pdata = client->dev.platform_data; if (chip->pdata == NULL) { dev_err(&client->dev, "platform data is mandatory\n"); err = -EINVAL; goto fail1; } if (chip->pdata->cf.ga == 0) { /* set uncovered sensor default parameters */ chip->cf.ga = 1966; /* 0.48 * APDS_PARAM_SCALE */ chip->cf.cf1 = 4096; /* 1.00 * APDS_PARAM_SCALE */ chip->cf.irf1 = 9134; /* 2.23 * APDS_PARAM_SCALE */ chip->cf.cf2 = 2867; /* 0.70 * APDS_PARAM_SCALE */ chip->cf.irf2 = 5816; /* 1.42 * APDS_PARAM_SCALE */ chip->cf.df = 52; } else { chip->cf = chip->pdata->cf; } /* precalculate inverse chip factors for threshold control */ chip->rcf.afactor = (chip->cf.irf1 - chip->cf.irf2) * APDS_PARAM_SCALE / (chip->cf.cf1 - chip->cf.cf2); chip->rcf.cf1 = APDS_PARAM_SCALE * APDS_PARAM_SCALE / chip->cf.cf1; chip->rcf.irf1 = chip->cf.irf1 * APDS_PARAM_SCALE / chip->cf.cf1; chip->rcf.cf2 = APDS_PARAM_SCALE * APDS_PARAM_SCALE / chip->cf.cf2; chip->rcf.irf2 = chip->cf.irf2 * APDS_PARAM_SCALE / chip->cf.cf2; /* Set something to start with */ chip->lux_thres_hi = APDS_LUX_DEF_THRES_HI; chip->lux_thres_lo = APDS_LUX_DEF_THRES_LO; chip->lux_calib = APDS_LUX_NEUTRAL_CALIB_VALUE; chip->prox_thres = APDS_PROX_DEF_THRES; chip->pdrive = chip->pdata->pdrive; chip->pdiode = APDS_PDIODE_IR; chip->pgain = APDS_PGAIN_1X; chip->prox_calib = APDS_PROX_NEUTRAL_CALIB_VALUE; chip->prox_persistence = APDS_DEFAULT_PROX_PERS; chip->prox_continuous_mode = false; chip->regs[0].supply = reg_vcc; chip->regs[1].supply = reg_vled; err = regulator_bulk_get(&client->dev, ARRAY_SIZE(chip->regs), chip->regs); if (err < 0) { dev_err(&client->dev, "Cannot get regulators\n"); goto fail1; } err = regulator_bulk_enable(ARRAY_SIZE(chip->regs), chip->regs); if (err < 0) { dev_err(&client->dev, "Cannot enable regulators\n"); goto fail2; } usleep_range(APDS_STARTUP_DELAY, 2 * APDS_STARTUP_DELAY); err = apds990x_detect(chip); if (err < 0) { dev_err(&client->dev, "APDS990X not found\n"); goto fail3; } pm_runtime_set_active(&client->dev); apds990x_configure(chip); apds990x_set_arate(chip, APDS_LUX_DEFAULT_RATE); apds990x_mode_on(chip); pm_runtime_enable(&client->dev); if (chip->pdata->setup_resources) { err = chip->pdata->setup_resources(); if (err) { err = -EINVAL; goto fail3; } } err = sysfs_create_group(&chip->client->dev.kobj, apds990x_attribute_group); if (err < 0) { dev_err(&chip->client->dev, "Sysfs registration failed\n"); goto fail4; } err = request_threaded_irq(client->irq, NULL, apds990x_irq, IRQF_TRIGGER_FALLING | IRQF_TRIGGER_LOW | IRQF_ONESHOT, "apds990x", chip); if (err) { dev_err(&client->dev, "could not get IRQ %d\n", client->irq); goto fail5; } return err; fail5: sysfs_remove_group(&chip->client->dev.kobj, &apds990x_attribute_group[0]); fail4: if (chip->pdata && chip->pdata->release_resources) chip->pdata->release_resources(); fail3: regulator_bulk_disable(ARRAY_SIZE(chip->regs), chip->regs); fail2: regulator_bulk_free(ARRAY_SIZE(chip->regs), chip->regs); fail1: kfree(chip); return err; }
static int wm8994_device_init(struct wm8994 *wm8994, unsigned long id, int irq) { struct wm8994_pdata *pdata = wm8994->dev->platform_data; int ret, i; mutex_init(&wm8994->io_lock); dev_set_drvdata(wm8994->dev, wm8994); /* Add the on-chip regulators first for bootstrapping */ ret = mfd_add_devices(wm8994->dev, -1, wm8994_regulator_devs, ARRAY_SIZE(wm8994_regulator_devs), NULL, 0); if (ret != 0) { dev_err(wm8994->dev, "Failed to add children: %d\n", ret); goto err; } wm8994->supplies = kzalloc(sizeof(struct regulator_bulk_data) * ARRAY_SIZE(wm8994_main_supplies), GFP_KERNEL); if (!wm8994->supplies) goto err; for (i = 0; i < ARRAY_SIZE(wm8994_main_supplies); i++) wm8994->supplies[i].supply = wm8994_main_supplies[i]; ret = regulator_bulk_get(wm8994->dev, ARRAY_SIZE(wm8994_main_supplies), wm8994->supplies); if (ret != 0) { dev_err(wm8994->dev, "Failed to get supplies: %d\n", ret); goto err_supplies; } ret = regulator_bulk_enable(ARRAY_SIZE(wm8994_main_supplies), wm8994->supplies); if (ret != 0) { dev_err(wm8994->dev, "Failed to enable supplies: %d\n", ret); goto err_get; } ret = wm8994_reg_read(wm8994, WM8994_SOFTWARE_RESET); if (ret < 0) { dev_err(wm8994->dev, "Failed to read ID register\n"); goto err_enable; } if (ret != 0x8994) { dev_err(wm8994->dev, "Device is not a WM8994, ID is %x\n", ret); ret = -EINVAL; goto err_enable; } ret = wm8994_reg_read(wm8994, WM8994_CHIP_REVISION); if (ret < 0) { dev_err(wm8994->dev, "Failed to read revision register: %d\n", ret); goto err_enable; } switch (ret) { case 0: case 1: dev_warn(wm8994->dev, "revision %c not fully supported\n", 'A' + ret); break; default: dev_info(wm8994->dev, "revision %c\n", 'A' + ret); break; } if (pdata) { wm8994->irq_base = pdata->irq_base; wm8994->gpio_base = pdata->gpio_base; /* GPIO configuration is only applied if it's non-zero */ for (i = 0; i < ARRAY_SIZE(pdata->gpio_defaults); i++) { if (pdata->gpio_defaults[i]) { wm8994_set_bits(wm8994, WM8994_GPIO_1 + i, 0xffff, pdata->gpio_defaults[i]); } } } /* In some system designs where the regulators are not in use, * we can achieve a small reduction in leakage currents by * floating LDO outputs. This bit makes no difference if the * LDOs are enabled, it only affects cases where the LDOs were * in operation and are then disabled. */ for (i = 0; i < WM8994_NUM_LDO_REGS; i++) { if (wm8994_ldo_in_use(pdata, i)) wm8994_set_bits(wm8994, WM8994_LDO_1 + i, WM8994_LDO1_DISCH, WM8994_LDO1_DISCH); else wm8994_set_bits(wm8994, WM8994_LDO_1 + i, WM8994_LDO1_DISCH, 0); } wm8994_irq_init(wm8994); ret = mfd_add_devices(wm8994->dev, -1, wm8994_devs, ARRAY_SIZE(wm8994_devs), NULL, 0); if (ret != 0) { dev_err(wm8994->dev, "Failed to add children: %d\n", ret); goto err_irq; } return 0; err_irq: wm8994_irq_exit(wm8994); err_enable: regulator_bulk_disable(ARRAY_SIZE(wm8994_main_supplies), wm8994->supplies); err_get: regulator_bulk_free(ARRAY_SIZE(wm8994_main_supplies), wm8994->supplies); err_supplies: kfree(wm8994->supplies); err: mfd_remove_devices(wm8994->dev); kfree(wm8994); return ret; }