static int twl4030_usb_ldo_init(struct twl4030_usb *twl) { /* Enable writing to power configuration registers */ twl_i2c_write_u8(TWL_MODULE_PM_MASTER, TWL4030_PM_MASTER_KEY_CFG1, TWL4030_PM_MASTER_PROTECT_KEY); twl_i2c_write_u8(TWL_MODULE_PM_MASTER, TWL4030_PM_MASTER_KEY_CFG2, TWL4030_PM_MASTER_PROTECT_KEY); /* Keep VUSB3V1 LDO in sleep state until VBUS/ID change detected*/ /*twl_i2c_write_u8(TWL_MODULE_PM_RECEIVER, 0, VUSB_DEDICATED2);*/ /* input to VUSB3V1 LDO is from VBAT, not VBUS */ twl_i2c_write_u8(TWL_MODULE_PM_RECEIVER, 0x14, VUSB_DEDICATED1); /* Initialize 3.1V regulator */ twl_i2c_write_u8(TWL_MODULE_PM_RECEIVER, 0, VUSB3V1_DEV_GRP); twl->usb3v1 = devm_regulator_get(twl->dev, "usb3v1"); if (IS_ERR(twl->usb3v1)) return -ENODEV; twl_i2c_write_u8(TWL_MODULE_PM_RECEIVER, 0, VUSB3V1_TYPE); /* Initialize 1.5V regulator */ twl_i2c_write_u8(TWL_MODULE_PM_RECEIVER, 0, VUSB1V5_DEV_GRP); twl->usb1v5 = devm_regulator_get(twl->dev, "usb1v5"); if (IS_ERR(twl->usb1v5)) return -ENODEV; twl_i2c_write_u8(TWL_MODULE_PM_RECEIVER, 0, VUSB1V5_TYPE); /* Initialize 1.8V regulator */ twl_i2c_write_u8(TWL_MODULE_PM_RECEIVER, 0, VUSB1V8_DEV_GRP); twl->usb1v8 = devm_regulator_get(twl->dev, "usb1v8"); if (IS_ERR(twl->usb1v8)) return -ENODEV; twl_i2c_write_u8(TWL_MODULE_PM_RECEIVER, 0, VUSB1V8_TYPE); /* disable access to power configuration registers */ twl_i2c_write_u8(TWL_MODULE_PM_MASTER, 0, TWL4030_PM_MASTER_PROTECT_KEY); return 0; }
static int regulator_virtual_probe(struct platform_device *pdev) { char *reg_id = dev_get_platdata(&pdev->dev); struct virtual_consumer_data *drvdata; int ret; drvdata = devm_kzalloc(&pdev->dev, sizeof(struct virtual_consumer_data), GFP_KERNEL); if (drvdata == NULL) return -ENOMEM; mutex_init(&drvdata->lock); drvdata->regulator = devm_regulator_get(&pdev->dev, reg_id); if (IS_ERR(drvdata->regulator)) { ret = PTR_ERR(drvdata->regulator); dev_err(&pdev->dev, "Failed to obtain supply '%s': %d\n", reg_id, ret); return ret; } ret = sysfs_create_group(&pdev->dev.kobj, ®ulator_virtual_attr_group); if (ret != 0) { dev_err(&pdev->dev, "Failed to create attribute group: %d\n", ret); return ret; } drvdata->mode = regulator_get_mode(drvdata->regulator); platform_set_drvdata(pdev, drvdata); return 0; }
static int hdmi_init_regulator(void) { int r; struct regulator *reg; if (hdmi.vdda_reg != NULL) return 0; reg = devm_regulator_get(&hdmi.pdev->dev, "vdda"); if (IS_ERR(reg)) { DSSERR("can't get VDDA regulator\n"); return PTR_ERR(reg); } r = regulator_set_voltage(reg, 1800000, 1800000); if (r) { devm_regulator_put(reg); DSSWARN("can't set the regulator voltage\n"); return r; } hdmi.vdda_reg = reg; return 0; }
static int msm_ehci_init_vbus(struct msm_hcd *mhcd, int init) { int rc = 0; struct usb_hcd *hcd = mhcd_to_hcd(mhcd); const struct msm_usb_host_platform_data *pdata; pdata = mhcd->dev->platform_data; if (!init) { if (pdata && pdata->dock_connect_irq) free_irq(pdata->dock_connect_irq, mhcd); return rc; } mhcd->vbus = devm_regulator_get(mhcd->dev, "vbus"); if (IS_ERR(mhcd->vbus)) { pr_err("Unable to get vbus\n"); return -ENODEV; } if (pdata) { hcd->power_budget = pdata->power_budget; if (pdata->dock_connect_irq) { rc = request_threaded_irq(pdata->dock_connect_irq, NULL, msm_ehci_dock_connect_irq, IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING | IRQF_ONESHOT, "msm_ehci_host", mhcd); if (!rc) enable_irq_wake(pdata->dock_connect_irq); } } return rc; }
static int ak4104_spi_probe(struct spi_device *spi) { struct device_node *np = spi->dev.of_node; struct ak4104_private *ak4104; unsigned int val; int ret; spi->bits_per_word = 8; spi->mode = SPI_MODE_0; ret = spi_setup(spi); if (ret < 0) return ret; ak4104 = devm_kzalloc(&spi->dev, sizeof(struct ak4104_private), GFP_KERNEL); if (ak4104 == NULL) return -ENOMEM; ak4104->regulator = devm_regulator_get(&spi->dev, "vdd"); if (IS_ERR(ak4104->regulator)) { ret = PTR_ERR(ak4104->regulator); dev_err(&spi->dev, "Unable to get Vdd regulator: %d\n", ret); return ret; } ak4104->regmap = devm_regmap_init_spi(spi, &ak4104_regmap); if (IS_ERR(ak4104->regmap)) { ret = PTR_ERR(ak4104->regmap); return ret; } if (np) { enum of_gpio_flags flags; int gpio = of_get_named_gpio_flags(np, "reset-gpio", 0, &flags); if (gpio_is_valid(gpio)) { ret = devm_gpio_request_one(&spi->dev, gpio, flags & OF_GPIO_ACTIVE_LOW ? GPIOF_OUT_INIT_LOW : GPIOF_OUT_INIT_HIGH, "ak4104 reset"); if (ret < 0) return ret; } } /* read the 'reserved' register - according to the datasheet, it * should contain 0x5b. Not a good way to verify the presence of * the device, but there is no hardware ID register. */ ret = regmap_read(ak4104->regmap, AK4104_REG_RESERVED, &val); if (ret != 0) return ret; if (val != AK4104_RESERVED_VAL) return -ENODEV; spi_set_drvdata(spi, ak4104); ret = snd_soc_register_codec(&spi->dev, &soc_codec_device_ak4104, &ak4104_dai, 1); return ret; }
/** * devm_regulator_bulk_get - managed get multiple regulator consumers * * @dev: Device to supply * @num_consumers: Number of consumers to register * @consumers: Configuration of consumers; clients are stored here. * * @return 0 on success, an errno on failure. * * This helper function allows drivers to get several regulator * consumers in one operation with management, the regulators will * automatically be freed when the device is unbound. If any of the * regulators cannot be acquired then any regulators that were * allocated will be freed before returning to the caller. */ int devm_regulator_bulk_get(struct device *dev, int num_consumers, struct regulator_bulk_data *consumers) { int i; int ret; for (i = 0; i < num_consumers; i++) consumers[i].consumer = NULL; for (i = 0; i < num_consumers; i++) { consumers[i].consumer = devm_regulator_get(dev, consumers[i].supply); if (IS_ERR(consumers[i].consumer)) { ret = PTR_ERR(consumers[i].consumer); dev_err(dev, "Failed to get supply '%s': %d\n", consumers[i].supply, ret); consumers[i].consumer = NULL; goto err; } } return 0; err: for (i = 0; i < num_consumers && consumers[i].consumer; i++) devm_regulator_put(consumers[i].consumer); return ret; }
static struct max97236_pdata *max97236_of_pdata(struct i2c_client *i2c) { struct max97236_pdata *pdata; struct device_node *dn = i2c->dev.of_node; pdata = devm_kzalloc(&i2c->dev, sizeof(struct max97236_pdata), GFP_KERNEL); if (!pdata) return NULL; pdata->irq_gpio = of_get_named_gpio(dn, "maxim,irq-gpio", 0); if (pdata->irq_gpio) { dev_info(&i2c->dev, "max97236: GPIO %d\n", pdata->irq_gpio); } else { dev_err(&i2c->dev, "max97236: No GPIO value found in dn\n"); } pdata->vreg = devm_regulator_get(&i2c->dev, "vdd_hp_mux"); if (IS_ERR(pdata->vreg)) { dev_err(&i2c->dev, "max97236: failed to get vdd hp supply"); pdata->vreg = NULL; } return pdata; }
static int qpnp_typec_parse_dt(struct qpnp_typec_chip *chip) { int rc; struct device_node *node = chip->dev->of_node; /* SS-Mux configuration gpio */ if (of_find_property(node, "qcom,ssmux-gpio", NULL)) { chip->ssmux_gpio = of_get_named_gpio(node, "qcom,ssmux-gpio", 0); if (!gpio_is_valid(chip->ssmux_gpio)) { if (chip->ssmux_gpio != -EPROBE_DEFER) pr_err("failed to get ss-mux config gpio=%d\n", chip->ssmux_gpio); return chip->ssmux_gpio; } rc = devm_gpio_request(chip->dev, chip->ssmux_gpio, "typec_mux_config_gpio"); if (rc) { pr_err("failed to request ss-mux gpio rc=%d\n", rc); return rc; } } /* SS-Mux regulator */ if (of_find_property(node, "ss-mux-supply", NULL)) { chip->ss_mux_vreg = devm_regulator_get(chip->dev, "ss-mux"); if (IS_ERR(chip->ss_mux_vreg)) return PTR_ERR(chip->ss_mux_vreg); } return 0; }
/* * Init regulator needed for edp, 8974_l12 */ static int mdss_edp_regulator_init(struct mdss_edp_drv_pdata *edp_drv) { int ret; edp_drv->vdda_vreg = devm_regulator_get(&(edp_drv->pdev->dev), "vdda"); if (IS_ERR(edp_drv->vdda_vreg)) { pr_err("%s: Could not get 8941_l12, ret = %ld\n", __func__, PTR_ERR(edp_drv->vdda_vreg)); return -ENODEV; } ret = regulator_set_voltage(edp_drv->vdda_vreg, VDDA_MIN_UV, VDDA_MAX_UV); if (ret) { pr_err("%s: vdda_vreg set_voltage failed, ret=%d\n", __func__, ret); return -EINVAL; } ret = mdss_edp_regulator_on(edp_drv); if (ret) return ret; return 0; }
static int __init hdmi_init_display(struct omap_dss_device *dssdev) { int r; struct gpio gpios[] = { { hdmi.ct_cp_hpd_gpio, GPIOF_OUT_INIT_LOW, "hdmi_ct_cp_hpd" }, { hdmi.ls_oe_gpio, GPIOF_OUT_INIT_LOW, "hdmi_ls_oe" }, { hdmi.hpd_gpio, GPIOF_DIR_IN, "hdmi_hpd" }, }; DSSDBG("init_display\n"); dss_init_hdmi_ip_ops(&hdmi.ip_data); if (hdmi.vdda_hdmi_dac_reg == NULL) { struct regulator *reg; reg = devm_regulator_get(&hdmi.pdev->dev, "vdda_hdmi_dac"); if (IS_ERR(reg)) { DSSERR("can't get VDDA_HDMI_DAC regulator\n"); return PTR_ERR(reg); } hdmi.vdda_hdmi_dac_reg = reg; } r = gpio_request_array(gpios, ARRAY_SIZE(gpios)); if (r) return r; return 0; }
static int mitigate_inrush_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct device_node *np = dev->of_node; int i, retval; struct subsystem *subsys; struct inrush_driver_data *drv_data; retval = of_property_count_strings(np, "qcom,dependent-subsystems"); if (IS_ERR_VALUE(retval)) { dev_err(dev, "Failed to get dependent subsystems\n"); return -EINVAL; } drv_data = kzalloc((retval * sizeof(struct subsystem) + sizeof(struct inrush_driver_data)), GFP_KERNEL); if (!drv_data) return -ENOMEM; drv_data->subsystems = (void *)drv_data + sizeof(struct inrush_driver_data); drv_data->subsys_count = retval; for (i = 0; i < drv_data->subsys_count; i++) { subsys = &drv_data->subsystems[i]; subsys->drv_data = drv_data; of_property_read_string_index(np, "qcom,dependent-subsystems", i, &subsys->name); subsys->nb.notifier_call = mitigate_inrush_notifier_cb; subsys->notif_handle = subsys_notif_register_notifier(subsys->name, &subsys->nb); if (IS_ERR(subsys->notif_handle)) { dev_err(dev, "Notifier registration failed for %s\n", subsys->name); retval = PTR_ERR(subsys->notif_handle); goto err_subsys_notif; } } drv_data->vreg = devm_regulator_get(dev, "vdd"); if (IS_ERR(drv_data->vreg)) { dev_err(dev, "Failed to get regulator\n"); return PTR_ERR(drv_data->vreg); } return 0; err_subsys_notif: for (i = 0; i < drv_data->subsys_count; i++) { subsys = &drv_data->subsystems[i]; subsys_notif_unregister_notifier(subsys->notif_handle, &subsys->nb); } kfree(drv_data); return retval; }
static int __ufs_qcom_phy_init_vreg(struct device *dev, struct ufs_qcom_phy_vreg *vreg, const char *name, bool optional) { int err = 0; char prop_name[MAX_PROP_NAME]; vreg->name = devm_kstrdup(dev, name, GFP_KERNEL); if (!vreg->name) { err = -ENOMEM; goto out; } vreg->reg = devm_regulator_get(dev, name); if (IS_ERR(vreg->reg)) { err = PTR_ERR(vreg->reg); vreg->reg = NULL; if (!optional) dev_err(dev, "failed to get %s, %d\n", name, err); goto out; } if (dev->of_node) { snprintf(prop_name, MAX_PROP_NAME, "%s-max-microamp", name); err = of_property_read_u32(dev->of_node, prop_name, &vreg->max_uA); if (err && err != -EINVAL) { dev_err(dev, "%s: failed to read %s\n", __func__, prop_name); goto out; } else if (err == -EINVAL || !vreg->max_uA) { if (regulator_count_voltages(vreg->reg) > 0) { dev_err(dev, "%s: %s is mandatory\n", __func__, prop_name); goto out; } err = 0; } snprintf(prop_name, MAX_PROP_NAME, "%s-always-on", name); vreg->is_always_on = of_property_read_bool(dev->of_node, prop_name); } if (!strcmp(name, "vdda-pll")) { vreg->max_uV = VDDA_PLL_MAX_UV; vreg->min_uV = VDDA_PLL_MIN_UV; } else if (!strcmp(name, "vdda-phy")) { vreg->max_uV = VDDA_PHY_MAX_UV; vreg->min_uV = VDDA_PHY_MIN_UV; } else if (!strcmp(name, "vddp-ref-clk")) { vreg->max_uV = VDDP_REF_CLK_MAX_UV; vreg->min_uV = VDDP_REF_CLK_MIN_UV; } out: if (err) kfree(vreg->name); return err; }
int ili9341_init(struct platform_device *pdev, struct device_node *np) { int rc = 0; rst_gpio = of_get_named_gpio(np, "qcom,rst-gpio", 0); cs_gpio = of_get_named_gpio(np, "qcom,cs-gpio", 0); ad8_gpio = of_get_named_gpio(np, "qcom,ad8-gpio", 0); te_gpio = of_get_named_gpio(np, "qcom,te-gpio", 0); if (!gpio_is_valid(rst_gpio)) { pr_err("%s: reset gpio not specified\n" , __func__); return -EINVAL; } if (!gpio_is_valid(cs_gpio)) { pr_err("%s: cs gpio not specified\n", __func__); return -EINVAL; } if (!gpio_is_valid(ad8_gpio)) { pr_err("%s: ad8 gpio not specified\n", __func__); return -EINVAL; } if (!gpio_is_valid(te_gpio)) { pr_err("%s: te gpio not specified\n", __func__); return -EINVAL; } vdd_vreg = devm_regulator_get(&pdev->dev, "vdd"); if (IS_ERR(vdd_vreg)) { pr_err("%s could not get vdd,", __func__); return -ENODEV; } avdd_vreg = devm_regulator_get(&pdev->dev, "avdd"); if (IS_ERR(avdd_vreg)) { pr_err("%s could not get avdd,", __func__); return -ENODEV; } rc = regulator_set_voltage(vdd_vreg, 1800000, 1800000); if (rc) { pr_err("vdd_vreg->set_voltage failed, rc=%d\n", rc); return -EINVAL; } rc = regulator_set_voltage(avdd_vreg, 2700000, 2700000); if (rc) { pr_err("vdd_vreg->set_voltage failed, rc=%d\n", rc); return -EINVAL; } return 0; }
static int __devinit pil_mss_driver_probe(struct platform_device *pdev) { struct q6v5_data *drv; struct pil_desc *desc; struct resource *res; int ret; desc = pil_q6v5_init(pdev); if (IS_ERR(desc)) return PTR_ERR(desc); drv = platform_get_drvdata(pdev); if (drv == NULL) return -ENODEV; desc->ops = &pil_mss_ops; desc->owner = THIS_MODULE; desc->proxy_timeout = PROXY_TIMEOUT_MS; of_property_read_u32(pdev->dev.of_node, "qcom,pil-self-auth", &drv->self_auth); if (drv->self_auth) { res = platform_get_resource(pdev, IORESOURCE_MEM, 2); drv->rmb_base = devm_ioremap(&pdev->dev, res->start, resource_size(res)); if (!drv->rmb_base) return -ENOMEM; } res = platform_get_resource(pdev, IORESOURCE_MEM, 3); drv->restart_reg = devm_ioremap(&pdev->dev, res->start, resource_size(res)); if (!drv->restart_reg) return -ENOMEM; drv->vreg = devm_regulator_get(&pdev->dev, "vdd_mss"); if (IS_ERR(drv->vreg)) return PTR_ERR(drv->vreg); ret = regulator_set_voltage(drv->vreg, 1150000, 1150000); if (ret) dev_err(&pdev->dev, "Failed to set regulator's voltage.\n"); ret = regulator_set_optimum_mode(drv->vreg, 100000); if (ret < 0) { dev_err(&pdev->dev, "Failed to set regulator's mode.\n"); return ret; } drv->mem_clk = devm_clk_get(&pdev->dev, "mem_clk"); if (IS_ERR(drv->mem_clk)) return PTR_ERR(drv->mem_clk); drv->pil = msm_pil_register(desc); if (IS_ERR(drv->pil)) return PTR_ERR(drv->pil); return 0; }
static int gpio_vibrator_probe(struct platform_device *pdev) { struct gpio_vibrator *vibrator; int err; vibrator = devm_kzalloc(&pdev->dev, sizeof(*vibrator), GFP_KERNEL); if (!vibrator) return -ENOMEM; vibrator->input = devm_input_allocate_device(&pdev->dev); if (!vibrator->input) return -ENOMEM; vibrator->vcc = devm_regulator_get(&pdev->dev, "vcc"); err = PTR_ERR_OR_ZERO(vibrator->vcc); if (err) { if (err != -EPROBE_DEFER) dev_err(&pdev->dev, "Failed to request regulator: %d\n", err); return err; } vibrator->gpio = devm_gpiod_get(&pdev->dev, "enable", GPIOD_OUT_LOW); err = PTR_ERR_OR_ZERO(vibrator->gpio); if (err) { if (err != -EPROBE_DEFER) dev_err(&pdev->dev, "Failed to request main gpio: %d\n", err); return err; } INIT_WORK(&vibrator->play_work, gpio_vibrator_play_work); vibrator->input->name = "gpio-vibrator"; vibrator->input->id.bustype = BUS_HOST; vibrator->input->close = gpio_vibrator_close; input_set_drvdata(vibrator->input, vibrator); input_set_capability(vibrator->input, EV_FF, FF_RUMBLE); err = input_ff_create_memless(vibrator->input, NULL, gpio_vibrator_play_effect); if (err) { dev_err(&pdev->dev, "Couldn't create FF dev: %d\n", err); return err; } err = input_register_device(vibrator->input); if (err) { dev_err(&pdev->dev, "Couldn't register input dev: %d\n", err); return err; } platform_set_drvdata(pdev, vibrator); return 0; }
static int mdss_dsi_regulator_init(struct platform_device *pdev) { int ret; dsi_drv.vdd_vreg = devm_regulator_get(&pdev->dev, "vdd"); if (IS_ERR(dsi_drv.vdd_vreg)) { pr_err("could not get 8941_l22, rc = %ld\n", PTR_ERR(dsi_drv.vdd_vreg)); return -ENODEV; } ret = regulator_set_voltage(dsi_drv.vdd_vreg, 3000000, 3000000); if (ret) { pr_err("vdd_vreg->set_voltage failed, rc=%d\n", ret); return -EINVAL; } dsi_drv.vdd_io_vreg = devm_regulator_get(&pdev->dev, "vdd_io"); if (IS_ERR(dsi_drv.vdd_io_vreg)) { pr_err("could not get 8941_l12, rc = %ld\n", PTR_ERR(dsi_drv.vdd_io_vreg)); return -ENODEV; } ret = regulator_set_voltage(dsi_drv.vdd_io_vreg, 1800000, 1800000); if (ret) { pr_err("vdd_io_vreg->set_voltage failed, rc=%d\n", ret); return -EINVAL; } dsi_drv.dsi_vreg = devm_regulator_get(&pdev->dev, "vreg"); if (IS_ERR(dsi_drv.dsi_vreg)) { pr_err("could not get 8941_l2, rc = %ld\n", PTR_ERR(dsi_drv.dsi_vreg)); return -ENODEV; } ret = regulator_set_voltage(dsi_drv.dsi_vreg, 1200000, 1200000); if (ret) { pr_err("dsi_vreg->set_voltage failed, rc=%d\n", ret); return -EINVAL; } return 0; }
static int __devinit lcd_pwrctrl_probe(struct platform_device *pdev) { struct lcd_pwrctrl *lp; struct lcd_pwrctrl_data *pdata = pdev->dev.platform_data; struct device *dev = &pdev->dev; int err; #ifdef CONFIG_OF if (dev->of_node) { pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL); if (!pdata) { dev_err(dev, "memory allocation for pdata failed\n"); return -ENOMEM; } lcd_pwrctrl_parse_dt(dev, pdata); } #endif if (!pdata) { dev_err(dev, "platform data not available\n"); return -EINVAL; } lp = devm_kzalloc(dev, sizeof(struct lcd_pwrctrl), GFP_KERNEL); if (!lp) { dev_err(dev, "memory allocation failed for private data\n"); return -ENOMEM; } err = gpio_request(pdata->gpio, "LCD-nRESET"); if (err) { dev_err(dev, "gpio [%d] request failed\n", pdata->gpio); return err; } /* * If power to lcd and/or lcd interface is controlled using a regulator, * get the handle to the regulator for later use during power switching. */ lp->regulator = devm_regulator_get(dev, "vcc-lcd"); if (IS_ERR(lp->regulator)) dev_info(dev, "could not find regulator\n"); lp->dev = dev; lp->pdata = pdata; lp->lcd = lcd_device_register(dev_name(dev), dev, lp, &lcd_pwrctrl_ops); if (IS_ERR(lp->lcd)) { dev_err(dev, "cannot register lcd device\n"); gpio_free(pdata->gpio); return PTR_ERR(lp->lcd); } platform_set_drvdata(pdev, lp); lcd_pwrctrl_set_power(lp->lcd, FB_BLANK_NORMAL); return 0; }
static int mn885521_parse_dt(struct device *dev, struct mn885521_platform_data *pdata) { int rc = 0; INFO_PRINT("%s \n", __func__); pdata->fm_fullseg_pw_vreg = devm_regulator_get(dev, "fm_fullseg_pw"); if (IS_ERR(pdata->fm_fullseg_pw_vreg)) { pdata->fm_fullseg_pw_vreg = NULL; pr_err("%s: could not get fm_fullseg_pw reg!\n", __func__); return -EINVAL; }else INFO_PRINT("%s: get fm_fullseg_pw reg\n", __func__); rc = regulator_set_voltage(pdata->fm_fullseg_pw_vreg, 2850000, 2850000); if (rc < 0) { pr_err("%s: set voltage failed\n", __func__); return -EINVAL; }else INFO_PRINT("%s: set fm_fullseg_pw voltage\n", __func__); #if 0 prop = of_find_property(dt, "mn885521,npd_reg_npd_xtal", NULL); if (prop) { pdata->npd_reg_npd_xtal = of_get_named_gpio(dt, "mn885521,npd_reg_npd_xtal", 0); printk("%s: pdata->npd_reg_npd_xtal = %x\n", __func__, pdata->npd_reg_npd_xtal); }else printk("%s: fail to get npd_reg_npd_xtal\n", __func__); prop = of_find_property(dt, "mn885521,nrst", NULL); if (prop) { pdata->nrst = of_get_named_gpio(dt, "mn885521,nrst", 0); printk("%s: pdata->nrst = %x\n", __func__, pdata->nrst); } prop = of_find_property(dt, "mn885521,spisel", NULL); if (prop) { pdata->spisel = of_get_named_gpio(dt, "mn885521,spisel", 0); printk("%s: pdata->spisel = %x\n", __func__, pdata->spisel); } prop = of_find_property(dt, "mn885521,sadr1", NULL); if (prop) { pdata->sadr1 = of_get_named_gpio(dt, "mn885521,sadr1", 0); printk("%s: pdata->sadr1 = %x\n", __func__, pdata->sadr1); } prop = of_find_property(dt, "mn885521,sadr2", NULL); if (prop) { pdata->sadr2 = of_get_named_gpio(dt, "mn885521,sadr2", 0); printk("%s: pdata->sadr2 = %x\n", __func__, pdata->sadr2); } #endif return 0; }
static int msm_ehci_ldo_init(struct msm_hcd *mhcd, int init) { int rc = 0; if (!init) goto put_1p8; mhcd->hsusb_3p3 = devm_regulator_get(mhcd->dev, "HSUSB_3p3"); if (IS_ERR(mhcd->hsusb_3p3)) { dev_err(mhcd->dev, "unable to get hsusb 3p3\n"); return PTR_ERR(mhcd->hsusb_3p3); } rc = regulator_set_voltage(mhcd->hsusb_3p3, HSUSB_PHY_3P3_VOL_MIN, HSUSB_PHY_3P3_VOL_MAX); if (rc) { dev_err(mhcd->dev, "unable to set voltage level for" "hsusb 3p3\n"); return rc; } mhcd->hsusb_1p8 = devm_regulator_get(mhcd->dev, "HSUSB_1p8"); if (IS_ERR(mhcd->hsusb_1p8)) { dev_err(mhcd->dev, "unable to get hsusb 1p8\n"); rc = PTR_ERR(mhcd->hsusb_1p8); goto put_3p3_lpm; } rc = regulator_set_voltage(mhcd->hsusb_1p8, HSUSB_PHY_1P8_VOL_MIN, HSUSB_PHY_1P8_VOL_MAX); if (rc) { dev_err(mhcd->dev, "unable to set voltage level for" "hsusb 1p8\n"); goto put_1p8; } return 0; put_1p8: regulator_set_voltage(mhcd->hsusb_1p8, 0, HSUSB_PHY_1P8_VOL_MAX); put_3p3_lpm: regulator_set_voltage(mhcd->hsusb_3p3, 0, HSUSB_PHY_3P3_VOL_MAX); return rc; }
static int nouveau_platform_probe(struct platform_device *pdev) { struct nouveau_platform_gpu *gpu; struct nouveau_platform_device *device; struct drm_device *drm; int err; gpu = devm_kzalloc(&pdev->dev, sizeof(*gpu), GFP_KERNEL); if (!gpu) return -ENOMEM; gpu->vdd = devm_regulator_get(&pdev->dev, "vdd"); if (IS_ERR(gpu->vdd)) return PTR_ERR(gpu->vdd); gpu->rst = devm_reset_control_get(&pdev->dev, "gpu"); if (IS_ERR(gpu->rst)) return PTR_ERR(gpu->rst); gpu->clk = devm_clk_get(&pdev->dev, "gpu"); if (IS_ERR(gpu->clk)) return PTR_ERR(gpu->clk); gpu->clk_pwr = devm_clk_get(&pdev->dev, "pwr"); if (IS_ERR(gpu->clk_pwr)) return PTR_ERR(gpu->clk_pwr); err = nouveau_platform_power_up(gpu); if (err) return err; drm = nouveau_platform_device_create(pdev, &device); if (IS_ERR(drm)) { err = PTR_ERR(drm); goto power_down; } device->gpu = gpu; err = drm_dev_register(drm, 0); if (err < 0) goto err_unref; return 0; err_unref: drm_dev_unref(drm); return 0; power_down: nouveau_platform_power_down(gpu); return err; }
static int msm_hsic_hub_init_vdd(struct hsic_hub *hub, int init) { int ret; if (!of_get_property(hub->dev->of_node, "ext-hub-vddio-supply", NULL)) return 0; if (!init) { if (!IS_ERR(smsc_hub->hsic_hub_reg)) { regulator_disable(smsc_hub->hsic_hub_reg); regulator_set_optimum_mode(smsc_hub->hsic_hub_reg, 0); regulator_set_voltage(smsc_hub->hsic_hub_reg, 0, HSIC_HUB_VDD_VOL_MAX); } return 0; } smsc_hub->hsic_hub_reg = devm_regulator_get(hub->dev, "ext-hub-vddio"); if (IS_ERR(smsc_hub->hsic_hub_reg)) { dev_dbg(hub->dev, "unable to get ext hub vddcx\n"); } else { ret = regulator_set_voltage(smsc_hub->hsic_hub_reg, HSIC_HUB_VDD_VOL_MIN, HSIC_HUB_VDD_VOL_MAX); if (ret) { dev_err(hub->dev, "unable to set the voltage\n" "for hsic hub reg\n"); return ret; } ret = regulator_set_optimum_mode(smsc_hub->hsic_hub_reg, HSIC_HUB_VDD_LOAD); if (ret < 0) { dev_err(hub->dev, "Unable to set mode of VDDCX\n"); goto reg_optimum_mode_fail; } ret = regulator_enable(smsc_hub->hsic_hub_reg); if (ret) { dev_err(hub->dev, "unable to enable ext hub vddcx\n"); goto reg_enable_fail; } } return 0; reg_enable_fail: regulator_set_optimum_mode(smsc_hub->hsic_hub_reg, 0); reg_optimum_mode_fail: regulator_set_voltage(smsc_hub->hsic_hub_reg, 0, HSIC_HUB_VDD_VOL_MAX); return ret; }
static int sun4i_mdio_probe(struct platform_device *pdev) { struct device_node *np = pdev->dev.of_node; struct mii_bus *bus; struct sun4i_mdio_data *data; struct resource *res; int ret; bus = mdiobus_alloc_size(sizeof(*data)); if (!bus) return -ENOMEM; bus->name = "sun4i_mii_bus"; bus->read = &sun4i_mdio_read; bus->write = &sun4i_mdio_write; snprintf(bus->id, MII_BUS_ID_SIZE, "%s-mii", dev_name(&pdev->dev)); bus->parent = &pdev->dev; data = bus->priv; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); data->membase = devm_ioremap_resource(&pdev->dev, res); if (IS_ERR(data->membase)) { ret = PTR_ERR(data->membase); goto err_out_free_mdiobus; } data->regulator = devm_regulator_get(&pdev->dev, "phy"); if (IS_ERR(data->regulator)) { if (PTR_ERR(data->regulator) == -EPROBE_DEFER) return -EPROBE_DEFER; dev_info(&pdev->dev, "no regulator found\n"); data->regulator = NULL; } else { ret = regulator_enable(data->regulator); if (ret) goto err_out_free_mdiobus; } ret = of_mdiobus_register(bus, np); if (ret < 0) goto err_out_disable_regulator; platform_set_drvdata(pdev, bus); return 0; err_out_disable_regulator: if (data->regulator) regulator_disable(data->regulator); err_out_free_mdiobus: mdiobus_free(bus); return ret; }
static mali_bool kbase_platform_init(struct kbase_device *kbdev) { struct device *dev = kbdev->dev; dev->platform_data = kbdev; #ifdef CONFIG_REPORT_VSYNC kbase_dev = kbdev; #endif kbdev->clk = devm_clk_get(dev, NULL); if (IS_ERR(kbdev->clk)) { printk("[mali-midgard] Failed to get clk\n"); return MALI_FALSE; } kbdev->regulator = devm_regulator_get(dev, KBASE_HI3635_PLATFORM_GPU_REGULATOR_NAME); if (IS_ERR(kbdev->regulator)) { printk("[mali-midgard] Failed to get regulator\n"); return MALI_FALSE; } #ifdef CONFIG_PM_DEVFREQ if (of_init_opp_table(dev) || opp_init_devfreq_table(dev, &mali_kbase_devfreq_profile.freq_table)) { printk("[mali-midgard] Failed to init devfreq_table\n"); kbdev->devfreq = NULL; } else { mali_kbase_devfreq_profile.initial_freq = clk_get_rate(kbdev->clk); rcu_read_lock(); mali_kbase_devfreq_profile.max_state = opp_get_opp_count(dev); rcu_read_unlock(); kbdev->devfreq = devfreq_add_device(dev, &mali_kbase_devfreq_profile, "mali_ondemand", NULL); } if (IS_ERR(kbdev->devfreq)) { printk("[mali-midgard] NULL pointer [kbdev->devFreq]\n"); return MALI_FALSE; } /* make devfreq function */ //mali_kbase_devfreq_profile.polling_ms = DEFAULT_POLLING_MS; #if KBASE_HI3635_GPU_IRDROP_ISSUE /* init update work */ sw_policy.kbdev = kbdev; INIT_WORK(&sw_policy.update, handle_switch_policy); #endif /* KBASE_HI3635_GPU_IRDROP_ISSUE */ #endif return MALI_TRUE; }
static int ubx_probe(struct serdev_device *serdev) { struct gnss_serial *gserial; struct ubx_data *data; int ret; gserial = gnss_serial_allocate(serdev, sizeof(*data)); if (IS_ERR(gserial)) { ret = PTR_ERR(gserial); return ret; } gserial->ops = &ubx_gserial_ops; gserial->gdev->type = GNSS_TYPE_UBX; data = gnss_serial_get_drvdata(gserial); data->vcc = devm_regulator_get(&serdev->dev, "vcc"); if (IS_ERR(data->vcc)) { ret = PTR_ERR(data->vcc); goto err_free_gserial; } data->v_bckp = devm_regulator_get_optional(&serdev->dev, "v-bckp"); if (IS_ERR(data->v_bckp)) { ret = PTR_ERR(data->v_bckp); if (ret == -ENODEV) data->v_bckp = NULL; else goto err_free_gserial; } if (data->v_bckp) { ret = regulator_enable(data->v_bckp); if (ret) goto err_free_gserial; } ret = gnss_serial_register(gserial); if (ret) goto err_disable_v_bckp; return 0; err_disable_v_bckp: if (data->v_bckp) regulator_disable(data->v_bckp); err_free_gserial: gnss_serial_free(gserial); return ret; }
static int pil_q6v4_proc_init(struct q6v4_data *drv, struct platform_device *pdev, int i) { static const char *name[2] = { "fw", "sw" }; const struct pil_q6v4_pdata *pdata_p = pdev->dev.platform_data; const struct pil_q6v4_pdata *pdata = pdata_p + i; char reg_name[12]; struct pil_desc *desc; struct resource *res; res = platform_get_resource(pdev, IORESOURCE_MEM, 1 + (i * 2)); if (!res) return -EINVAL; drv->base = devm_ioremap(&pdev->dev, res->start, resource_size(res)); if (!drv->base) return -ENOMEM; res = platform_get_resource(pdev, IORESOURCE_MEM, 2 + (i * 2)); if (!res) return -EINVAL; drv->wdog_base = devm_ioremap(&pdev->dev, res->start, resource_size(res)); if (!drv->wdog_base) return -ENOMEM; snprintf(reg_name, sizeof(reg_name), "%s_core_vdd", name[i]); drv->vreg = devm_regulator_get(&pdev->dev, reg_name); if (IS_ERR(drv->vreg)) return PTR_ERR(drv->vreg); drv->xo = devm_clk_get(&pdev->dev, "xo"); if (IS_ERR(drv->xo)) return PTR_ERR(drv->xo); desc = &drv->desc; desc->name = pdata->name; desc->depends_on = pdata->depends; desc->dev = &pdev->dev; desc->owner = THIS_MODULE; desc->proxy_timeout = 10000; pil_q6v4_init(drv, pdata); if (pas_supported(pdata->pas_id) > 0) { desc->ops = &pil_q6v4_modem_ops_trusted; dev_info(&pdev->dev, "using secure boot for %s\n", name[i]); } else { desc->ops = &pil_q6v4_modem_ops; dev_info(&pdev->dev, "using non-secure boot for %s\n", name[i]); } return 0; }
static int ak4104_spi_probe(struct spi_device *spi) { struct ak4104_private *ak4104; struct gpio_desc *reset_gpiod; unsigned int val; int ret; spi->bits_per_word = 8; spi->mode = SPI_MODE_0; ret = spi_setup(spi); if (ret < 0) return ret; ak4104 = devm_kzalloc(&spi->dev, sizeof(struct ak4104_private), GFP_KERNEL); if (ak4104 == NULL) return -ENOMEM; ak4104->regulator = devm_regulator_get(&spi->dev, "vdd"); if (IS_ERR(ak4104->regulator)) { ret = PTR_ERR(ak4104->regulator); dev_err(&spi->dev, "Unable to get Vdd regulator: %d\n", ret); return ret; } ak4104->regmap = devm_regmap_init_spi(spi, &ak4104_regmap); if (IS_ERR(ak4104->regmap)) { ret = PTR_ERR(ak4104->regmap); return ret; } reset_gpiod = devm_gpiod_get_optional(&spi->dev, "reset", GPIOD_OUT_HIGH); if (IS_ERR(reset_gpiod) && PTR_ERR(reset_gpiod) == -EPROBE_DEFER) return -EPROBE_DEFER; /* read the 'reserved' register - according to the datasheet, it * should contain 0x5b. Not a good way to verify the presence of * the device, but there is no hardware ID register. */ ret = regmap_read(ak4104->regmap, AK4104_REG_RESERVED, &val); if (ret != 0) return ret; if (val != AK4104_RESERVED_VAL) return -ENODEV; spi_set_drvdata(spi, ak4104); ret = devm_snd_soc_register_component(&spi->dev, &soc_component_device_ak4104, &ak4104_dai, 1); return ret; }
static int edp_regulator_init(struct edp_ctrl *ctrl) { struct device *dev = &ctrl->pdev->dev; DBG(""); ctrl->vdda_vreg = devm_regulator_get(dev, "vdda"); if (IS_ERR(ctrl->vdda_vreg)) { pr_err("%s: Could not get vdda reg, ret = %ld\n", __func__, PTR_ERR(ctrl->vdda_vreg)); ctrl->vdda_vreg = NULL; return PTR_ERR(ctrl->vdda_vreg); } ctrl->lvl_vreg = devm_regulator_get(dev, "lvl-vdd"); if (IS_ERR(ctrl->lvl_vreg)) { pr_err("Could not get lvl-vdd reg, %ld", PTR_ERR(ctrl->lvl_vreg)); ctrl->lvl_vreg = NULL; return PTR_ERR(ctrl->lvl_vreg); } return 0; }
static int panel_dpi_probe_of(struct platform_device *pdev) { struct panel_drv_data *ddata = platform_get_drvdata(pdev); struct device_node *node = pdev->dev.of_node; struct omap_dss_device *in; int r; struct display_timing timing; struct videomode vm; struct gpio_desc *gpio; gpio = devm_gpiod_get_optional(&pdev->dev, "enable", GPIOD_OUT_LOW); if (IS_ERR(gpio)) return PTR_ERR(gpio); ddata->enable_gpio = gpio; /* * Many different panels are supported by this driver and there are * probably very different needs for their reset pins in regards to * timing and order relative to the enable gpio. So for now it's just * ensured that the reset line isn't active. */ gpio = devm_gpiod_get_optional(&pdev->dev, "reset", GPIOD_OUT_LOW); if (IS_ERR(gpio)) return PTR_ERR(gpio); ddata->vcc_supply = devm_regulator_get(&pdev->dev, "vcc"); if (IS_ERR(ddata->vcc_supply)) return PTR_ERR(ddata->vcc_supply); ddata->backlight_gpio = -ENOENT; r = of_get_display_timing(node, "panel-timing", &timing); if (r) { dev_err(&pdev->dev, "failed to get video timing\n"); return r; } videomode_from_timing(&timing, &vm); videomode_to_omap_video_timings(&vm, &ddata->videomode); in = omapdss_of_find_source_for_first_ep(node); if (IS_ERR(in)) { dev_err(&pdev->dev, "failed to find video source\n"); return PTR_ERR(in); } ddata->in = in; return 0; }
static int bma2x2_regulator_init(struct device *dev) { int rc = 0; struct bma2x2_regulator_data *regdata = &bma2x2_regu_data; if (!regdata->reg_vdd) regdata->reg_vdd = devm_regulator_get(dev, regdata->id_vdd); if (IS_ERR_OR_NULL(regdata->reg_vdd)) { rc = PTR_ERR(regdata->reg_vdd); dev_err(dev, "%s: regulator_get failed on %s. rc=%d\n", __func__, regdata->id_vdd, rc); rc = rc ? rc : -ENODEV; goto err_vdd; } else { rc = regulator_set_voltage(regdata->reg_vdd, 2850000, 2850000); if (rc) goto err_vdd_set; } if (!regdata->reg_vio) regdata->reg_vio = devm_regulator_get(dev, regdata->id_vio); if (IS_ERR_OR_NULL(regdata->reg_vio)) { rc = PTR_ERR(regdata->reg_vio); dev_err(dev, "%s: regulator_get failed on %s. rc=%d\n", __func__, regdata->id_vio, rc); rc = rc ? rc : -ENODEV; goto err_vio; } return rc; err_vio: regdata->reg_vio = NULL; err_vdd_set: regulator_put(regdata->reg_vdd); err_vdd: regdata->reg_vdd = NULL; return rc; }
static int imx_gpcv2_probe(struct platform_device *pdev) { int ret; struct regulator *pcie_reg, *mipi_reg; if (cpu_is_imx7d()) { pcie_reg = devm_regulator_get(&pdev->dev, "pcie-phy"); if (IS_ERR(pcie_reg)) { ret = PTR_ERR(pcie_reg); dev_info(&pdev->dev, "pcie regulator not ready.\n"); return ret; } nb_pcie.notifier_call = &imx_pcie_regulator_notify; ret = regulator_register_notifier(pcie_reg, &nb_pcie); if (ret) { dev_err(&pdev->dev, "pcie regulator notifier request failed\n"); return ret; } mipi_reg = devm_regulator_get(&pdev->dev, "mipi-phy"); if (IS_ERR(mipi_reg)) { ret = PTR_ERR(mipi_reg); dev_info(&pdev->dev, "mipi regulator not ready.\n"); return ret; } nb_mipi.notifier_call = &imx_mipi_regulator_notify; ret = regulator_register_notifier(mipi_reg, &nb_mipi); if (ret) { dev_err(&pdev->dev, "mipi regulator notifier request failed.\n"); return ret; } } return 0; }