static int __devinit da9052_regulator_probe(struct platform_device *pdev) { struct da9052_regulator_priv *priv; struct da9052_regulator_platform_data *pdata = (pdev->dev.platform_data); struct da9052 *da9052 = dev_get_drvdata(pdev->dev.parent); struct regulator_init_data *init_data; struct da9052_platform_data *da9052_pdata = da9052->dev->platform_data; int i, ret = 0; if ((da9052_pdata == NULL) || (da9052_pdata->num_regulators > DA9052_MAX_REGULATORS) || (da9052_pdata->num_regulators <= 0)) return -EINVAL; priv = kzalloc(sizeof(*priv) + sizeof(priv->regulators[0]) * da9052_pdata->num_regulators, GFP_KERNEL); if (priv == NULL) return -ENOMEM; priv->da9052 = da9052; for (i = 0; i < da9052_pdata->num_regulators; i++) { init_data = &pdata->regulators[i]; init_data->driver_data = da9052; priv->regulators[i] = regulator_register( &da9052_regulators[i].reg_desc, &pdev->dev, init_data, priv); if (IS_ERR(priv->regulators[i])) { ret = PTR_ERR(priv->regulators[i]); goto err; } } platform_set_drvdata(pdev, priv); return 0; err: while (--i >= 0) regulator_unregister(priv->regulators[i]); kfree(priv); return ret; }
static int regulator_fixed_voltage_probe(struct platform_device *pdev) { struct fixed_voltage_config *config = pdev->dev.platform_data; struct fixed_voltage_data *drvdata; int ret; drvdata = kzalloc(sizeof(struct fixed_voltage_data), GFP_KERNEL); if (drvdata == NULL) { ret = -ENOMEM; goto err; } drvdata->desc.name = kstrdup(config->supply_name, GFP_KERNEL); if (drvdata->desc.name == NULL) { ret = -ENOMEM; goto err; } drvdata->desc.type = REGULATOR_VOLTAGE; drvdata->desc.owner = THIS_MODULE; drvdata->desc.ops = &fixed_voltage_ops, drvdata->microvolts = config->microvolts; drvdata->dev = regulator_register(&drvdata->desc, drvdata); if (IS_ERR(drvdata->dev)) { ret = PTR_ERR(drvdata->dev); goto err_name; } platform_set_drvdata(pdev, drvdata); dev_dbg(&pdev->dev, "%s supplying %duV\n", drvdata->desc.name, drvdata->microvolts); return 0; err_name: kfree(drvdata->desc.name); err: kfree(drvdata); return ret; }
static int __devinit pcf50633_regulator_probe(struct platform_device *pdev) { struct regulator_dev *rdev; struct pcf50633 *pcf; /* Already set by core driver */ pcf = dev_to_pcf50633(pdev->dev.parent); rdev = regulator_register(®ulators[pdev->id], &pdev->dev, pdev->dev.platform_data, pcf); if (IS_ERR(rdev)) return PTR_ERR(rdev); platform_set_drvdata(pdev, rdev); if (pcf->pdata->regulator_registered) pcf->pdata->regulator_registered(pcf, pdev->id); return 0; }
static int __devinit ad5398_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct regulator_dev *rdev; struct regulator_init_data *init_data = client->dev.platform_data; struct ad5398_chip_info *chip; const struct ad5398_current_data_format *df = (struct ad5398_current_data_format *)id->driver_data; int ret; if (!init_data) return -EINVAL; chip = kzalloc(sizeof(*chip), GFP_KERNEL); if (!chip) return -ENOMEM; chip->client = client; chip->min_uA = df->min_uA; chip->max_uA = df->max_uA; chip->current_level = 1 << df->current_bits; chip->current_offset = df->current_offset; chip->current_mask = (chip->current_level - 1) << chip->current_offset; rdev = regulator_register(&ad5398_reg, &client->dev, init_data, chip); if (IS_ERR(rdev)) { ret = PTR_ERR(rdev); dev_err(&client->dev, "failed to register %s %s\n", id->name, ad5398_reg.name); goto err; } i2c_set_clientdata(client, chip); dev_dbg(&client->dev, "%s regulator driver is registered.\n", id->name); return 0; err: kfree(chip); return ret; }
static int footswitch_probe(struct platform_device *pdev) { struct footswitch *fs; struct regulator_init_data *init_data; int rc; if (pdev == NULL) return -EINVAL; if (pdev->id >= MAX_FS) return -ENODEV; init_data = pdev->dev.platform_data; fs = &footswitches[pdev->id]; rc = set_rail_state(fs->pcom_id, PCOM_CLKCTL_RPC_RAIL_ENABLE); if (rc) return rc; rc = set_rail_mode(fs->pcom_id, PCOM_RAIL_MODE_MANUAL); if (rc) return rc; rc = get_clocks(&pdev->dev, fs); if (rc) return rc; fs->rdev = regulator_register(&fs->desc, &pdev->dev, init_data, fs, NULL); if (IS_ERR(fs->rdev)) { pr_err("regulator_register(%s) failed\n", fs->desc.name); rc = PTR_ERR(fs->rdev); goto err_register; } return 0; err_register: put_clocks(fs); return rc; }
static int __init bq24022_probe(struct platform_device *pdev) { struct bq24022_mach_info *pdata = pdev->dev.platform_data; struct regulator_dev *bq24022; int ret; if (!pdata || !pdata->gpio_nce || !pdata->gpio_iset2) return -EINVAL; ret = gpio_request(pdata->gpio_nce, "ncharge_en"); if (ret) { dev_dbg(&pdev->dev, "couldn't request nCE GPIO: %d\n", pdata->gpio_nce); goto err_ce; } ret = gpio_request(pdata->gpio_iset2, "charge_mode"); if (ret) { dev_dbg(&pdev->dev, "couldn't request ISET2 GPIO: %d\n", pdata->gpio_iset2); goto err_iset2; } ret = gpio_direction_output(pdata->gpio_iset2, 0); ret = gpio_direction_output(pdata->gpio_nce, 1); bq24022 = regulator_register(&bq24022_desc, &pdev->dev, pdata); if (IS_ERR(bq24022)) { dev_dbg(&pdev->dev, "couldn't register regulator\n"); ret = PTR_ERR(bq24022); goto err_reg; } platform_set_drvdata(pdev, bq24022); dev_dbg(&pdev->dev, "registered regulator\n"); return 0; err_reg: gpio_free(pdata->gpio_iset2); err_iset2: gpio_free(pdata->gpio_nce); err_ce: return ret; }
static int fan53555_regulator_register(struct fan53555_device_info *di, struct regulator_config *config) { struct regulator_desc *rdesc = &di->desc; rdesc->name = "fan53555-reg"; rdesc->ops = &fan53555_regulator_ops; rdesc->type = REGULATOR_VOLTAGE; rdesc->n_voltages = FAN53555_NVOLTAGES; rdesc->enable_reg = di->vol_reg; rdesc->enable_mask = VSEL_BUCK_EN; rdesc->min_uV = di->vsel_min; rdesc->uV_step = di->vsel_step; rdesc->vsel_reg = di->vol_reg; rdesc->vsel_mask = VSEL_NSEL_MASK; rdesc->owner = THIS_MODULE; di->rdev = regulator_register(&di->desc, config); return PTR_RET(di->rdev); }
/** * devm_regulator_register - Resource managed regulator_register() * @regulator_desc: regulator to register * @config: runtime configuration for regulator * * Called by regulator drivers to register a regulator. Returns a * valid pointer to struct regulator_dev on success or an ERR_PTR() on * error. The regulator will automatically be released when the device * is unbound. */ struct regulator_dev *devm_regulator_register(struct device *dev, const struct regulator_desc *regulator_desc, const struct regulator_config *config) { struct regulator_dev **ptr, *rdev; ptr = devres_alloc(devm_rdev_release, sizeof(*ptr), GFP_KERNEL); if (!ptr) return ERR_PTR(-ENOMEM); rdev = regulator_register(regulator_desc, config); if (!IS_ERR(rdev)) { *ptr = rdev; devres_add(dev, ptr); } else { devres_free(ptr); } return rdev; }
static int lp8788_buck_probe(struct platform_device *pdev) { struct lp8788 *lp = dev_get_drvdata(pdev->dev.parent); int id = pdev->id; struct lp8788_buck *buck; struct regulator_config cfg = { }; struct regulator_dev *rdev; int ret; if (id >= LP8788_NUM_BUCKS) return -EINVAL; buck = devm_kzalloc(&pdev->dev, sizeof(struct lp8788_buck), GFP_KERNEL); if (!buck) return -ENOMEM; buck->lp = lp; ret = lp8788_init_dvs(pdev, buck, id); if (ret) return ret; cfg.dev = pdev->dev.parent; cfg.init_data = lp->pdata ? lp->pdata->buck_data[id] : NULL; cfg.driver_data = buck; cfg.regmap = lp->regmap; rdev = regulator_register(&lp8788_buck_desc[id], &cfg); if (IS_ERR(rdev)) { ret = PTR_ERR(rdev); dev_err(&pdev->dev, "BUCK%d regulator register err = %d\n", id + 1, ret); return ret; } buck->regulator = rdev; platform_set_drvdata(pdev, buck); return 0; }
static int smb349_regulator_init(struct smb349_charger *chip) { int rc = 0; struct regulator_init_data *init_data; struct regulator_config cfg = {}; init_data = of_get_regulator_init_data(chip->dev, chip->dev->of_node); if (!init_data) { dev_err(chip->dev, "Unable to allocate memory\n"); return -ENOMEM; } if (init_data->constraints.name) { chip->otg_vreg.rdesc.owner = THIS_MODULE; chip->otg_vreg.rdesc.type = REGULATOR_VOLTAGE; chip->otg_vreg.rdesc.ops = &smb349_chg_otg_reg_ops; chip->otg_vreg.rdesc.name = init_data->constraints.name; cfg.dev = chip->dev; cfg.init_data = init_data; cfg.driver_data = chip; cfg.of_node = chip->dev->of_node; init_data->constraints.valid_ops_mask |= REGULATOR_CHANGE_STATUS; chip->otg_vreg.rdev = regulator_register( &chip->otg_vreg.rdesc, &cfg); if (IS_ERR(chip->otg_vreg.rdev)) { rc = PTR_ERR(chip->otg_vreg.rdev); chip->otg_vreg.rdev = NULL; if (rc != -EPROBE_DEFER) dev_err(chip->dev, "OTG reg failed, rc=%d\n", rc); } } return rc; }
static int __devinit pm822_regulator_probe(struct platform_device *pdev) { struct pm822_chip *chip = dev_get_drvdata(pdev->dev.parent); struct pm822_regulator_info *info = NULL; struct regulator_init_data *pdata = pdev->dev.platform_data; struct resource *res; int i; res = platform_get_resource(pdev, IORESOURCE_IO, 0); if (res == NULL) { dev_err(&pdev->dev, "No I/O resource!\n"); return -EINVAL; } for (i = 0; i < ARRAY_SIZE(pm822_regulator_info); i++) { info = &pm822_regulator_info[i]; if (info->desc.id == res->start) break; } if ((i < 0) || (i > PM822_ID_RG_MAX)) { dev_err(&pdev->dev, "Failed to find regulator %d\n", res->start); return -EINVAL; } info->map = chip->subchip->regmap_power; info->chip = chip; info->regulator = regulator_register(&info->desc, &pdev->dev, pdata, info, NULL); if (IS_ERR(info->regulator)) { dev_err(&pdev->dev, "failed to register regulator %s\n", info->desc.name); return PTR_ERR(info->regulator); } platform_set_drvdata(pdev, info); return 0; }
static int db8500_regulator_register(struct platform_device *pdev, struct regulator_init_data *init_data, int id, struct device_node *np) { struct dbx500_regulator_info *info; struct regulator_config config = { }; int err; /* assign per-regulator data */ info = &dbx500_regulator_info[id]; info->dev = &pdev->dev; config.dev = &pdev->dev; config.init_data = init_data; config.driver_data = info; config.of_node = np; /* register with the regulator framework */ info->rdev = regulator_register(&info->desc, &config); if (IS_ERR(info->rdev)) { err = PTR_ERR(info->rdev); dev_err(&pdev->dev, "failed to register %s: err %i\n", info->desc.name, err); /* if failing, unregister all earlier regulators */ while (--id >= 0) { info = &dbx500_regulator_info[id]; regulator_unregister(info->rdev); } return err; } dev_dbg(rdev_get_dev(info->rdev), "regulator-%s-probed\n", info->desc.name); return 0; }
static int aat2870_regulator_probe(struct platform_device *pdev) { struct aat2870_regulator *ri; struct regulator_dev *rdev; ri = aat2870_get_regulator(pdev->id); if (!ri) { dev_err(&pdev->dev, "Invalid device ID, %d\n", pdev->id); return -EINVAL; } ri->pdev = pdev; rdev = regulator_register(&ri->desc, &pdev->dev, pdev->dev.platform_data, ri); if (IS_ERR(rdev)) { dev_err(&pdev->dev, "Failed to register regulator %s\n", ri->desc.name); return PTR_ERR(rdev); } platform_set_drvdata(pdev, rdev); return 0; }
static int __devinit db8500_regulator_probe(struct platform_device *pdev) { struct regulator_init_data *db8500_init_data = dev_get_platdata(&pdev->dev); int i, err; /* register all regulators */ for (i = 0; i < ARRAY_SIZE(db8500_regulator_info); i++) { struct db8500_regulator_info *info; struct regulator_init_data *init_data = &db8500_init_data[i]; /* assign per-regulator data */ info = &db8500_regulator_info[i]; info->dev = &pdev->dev; /* register with the regulator framework */ info->rdev = regulator_register(&info->desc, &pdev->dev, init_data, info); if (IS_ERR(info->rdev)) { err = PTR_ERR(info->rdev); dev_err(&pdev->dev, "failed to register %s: err %i\n", info->desc.name, err); /* if failing, unregister all earlier regulators */ while (--i >= 0) { info = &db8500_regulator_info[i]; regulator_unregister(info->rdev); } return err; } dev_dbg(rdev_get_dev(info->rdev), "regulator-%s-probed\n", info->desc.name); } return 0; }
static int footswitch_probe(struct platform_device *pdev) { struct footswitch *fs; struct regulator_init_data *init_data; int rc; if (pdev == NULL) return -EINVAL; if (pdev->id >= MAX_FS) return -ENODEV; fs = &footswitches[pdev->id]; if (!fs->is_manual) { pr_err("%s is not in manual mode\n", fs->desc.name); return -EINVAL; } init_data = pdev->dev.platform_data; rc = get_clocks(&pdev->dev, fs); if (rc) return rc; fs->rdev = regulator_register(&fs->desc, &pdev->dev, init_data, fs); if (IS_ERR(fs->rdev)) { pr_err("regulator_register(%s) failed\n", fs->desc.name); rc = PTR_ERR(fs->rdev); goto err_register; } return 0; err_register: put_clocks(fs); return rc; }
static int __devinit tps65217_regulator_probe(struct platform_device *pdev) { struct regulator_dev *rdev; struct tps65217 *tps; struct tps_info *info = &tps65217_pmic_regs[pdev->id]; struct regulator_config config = { }; /* Already set by core driver */ tps = dev_to_tps65217(pdev->dev.parent); tps->info[pdev->id] = info; config.dev = &pdev->dev; config.of_node = pdev->dev.of_node; config.init_data = pdev->dev.platform_data; config.driver_data = tps; rdev = regulator_register(®ulators[pdev->id], &config); if (IS_ERR(rdev)) return PTR_ERR(rdev); platform_set_drvdata(pdev, rdev); return 0; }
static int __devinit cpcap_regulator_probe(struct platform_device *pdev) { struct regulator_dev *rdev; struct cpcap_device *cpcap; struct cpcap_platform_data *data; struct regulator_init_data *init; int i; /* Already set by core driver */ cpcap = platform_get_drvdata(pdev); data = cpcap->spi->controller_data; init = pdev->dev.platform_data; for (i = 0; i < CPCAP_NUM_REGULATORS; i++) { cpcap_regltr_data[i].mode_val = data->regulator_mode_values[i]; cpcap_regltr_data[i].off_mode_val = data->regulator_off_mode_values[i]; } rdev = regulator_register(®ulators[pdev->id], &pdev->dev, init, cpcap); if (IS_ERR(rdev)) return PTR_ERR(rdev); /* this is ok since the cpcap is still reachable from the rdev */ platform_set_drvdata(pdev, rdev); if (pdev->id == CPCAP_SW5) { data->regulator_init = cpcap->regulator_pdev[CPCAP_VUSB]->dev.platform_data; data->regulator_init->supply_regulator_dev = rdev_get_dev(rdev); platform_device_add(cpcap->regulator_pdev[CPCAP_VUSB]); } return 0; }
static int __devinit axp_regulator_probe(struct platform_device *pdev) { struct axp_regulator_info *ri = NULL; struct regulator_dev *rdev; ri = find_regulator_info(pdev->id); if (ri == NULL) { dev_err(&pdev->dev, "invalid regulator ID specified\n"); return -EINVAL; } if (ri->desc.id == AXP_ID_LDO1 || ri->desc.id == AXP_ID_LDO2 \ || ri->desc.id == AXP_ID_LDO3 || ri->desc.id == AXP_ID_BUCK1 \ || ri->desc.id == AXP_ID_BUCK2 ||ri->desc.id == AXP_ID_BUCK3) ri->desc.ops = &axp_ops; if(ri->desc.id == AXP_ID_LDO4) ri->desc.ops = &axp_ldo4_ops; if(ri->desc.id == AXP_ID_LDOIO0) ri->desc.ops = &axp_ldoio0_ops; rdev = regulator_register(&ri->desc, &pdev->dev, pdev->dev.platform_data, ri); if (IS_ERR(rdev)) { dev_err(&pdev->dev, "failed to register regulator %s\n", ri->desc.name); return PTR_ERR(rdev); } platform_set_drvdata(pdev, rdev); return 0; }
static int __devinit pm8058_xo_buffer_probe(struct platform_device *pdev) { struct regulator_desc *rdesc; struct pm8058_xo_buffer *xo; int rc = 0; if (pdev == NULL) return -EINVAL; if (pdev->id >= 0 && pdev->id < PM8058_XO_ID_MAX) { rdesc = &pm8058_xo_buffer_desc[pdev->id]; xo = &pm8058_xo_buffer[pdev->id]; xo->pdata = pdev->dev.platform_data; xo->dev = &pdev->dev; rc = pm8058_init_xo_buffer(xo); if (rc) goto bail; xo->rdev = regulator_register(rdesc, &pdev->dev, &xo->pdata->init_data, xo); if (IS_ERR(xo->rdev)) { rc = PTR_ERR(xo->rdev); pr_err("FAIL: regulator_register(%s): rc=%d\n", pm8058_xo_buffer_desc[pdev->id].name, rc); } } else { rc = -ENODEV; } bail: if (rc) pr_err("Error: xo-id=%d, rc=%d\n", pdev->id, rc); return rc; }
static int __devinit axp_regulator_probe(struct platform_device *pdev) { struct regulator_dev *rdev; struct axp_reg_init * platform_data = (struct axp_reg_init *)(pdev->dev.platform_data); struct axp_regulator_info *info = platform_data->info; int ret; rdev = regulator_register(&info->desc, &pdev->dev, &(platform_data->axp_reg_init_data), info, NULL); if (IS_ERR(rdev)) { dev_err(&pdev->dev, "failed to register regulator %s\n", info->desc.name); return PTR_ERR(rdev); } platform_set_drvdata(pdev, rdev); if(info->desc.id == AXP20_ID_DCDC2 ||info->desc.id == AXP20_ID_DCDC3){ ret = axp_regu_create_attrs(pdev); if(ret){ return ret; } } return 0; }
static int s2mps13_pmic_probe(struct platform_device *pdev) { struct sec_pmic_dev *iodev = dev_get_drvdata(pdev->dev.parent); struct sec_platform_data *pdata = iodev->pdata; struct regulator_config config = { }; struct s2mps13_info *s2mps13; int i, ret; unsigned int s2mps13_desc_type; ret = sec_reg_read(iodev, S2MPS13_REG_ID, &iodev->rev_num); if (ret < 0) return ret; s2mps13_desc_type = SEC_PMIC_REV(iodev) ? S2MPS13_DESC_TYPE1 : S2MPS13_DESC_TYPE0; if (iodev->dev->of_node) { ret = s2mps13_pmic_dt_parse_pdata(iodev, pdata); if (ret) return ret; } if (!pdata) { dev_err(pdev->dev.parent, "Platform data not supplied\n"); return -ENODEV; } s2mps13 = devm_kzalloc(&pdev->dev, sizeof(struct s2mps13_info), GFP_KERNEL); if (!s2mps13) return -ENOMEM; s2mps13->dvs_en = pdata->dvs_en; s2mps13->g3d_en = pdata->g3d_en; s2mps13->iodev = iodev; static_info = s2mps13; if (SEC_PMIC_REV(iodev) > 0x02 && gpio_is_valid(pdata->dvs_pin)) { if (!pdata->dvs_en) { /* Off DVS Control GPIO */ ret = devm_gpio_request(&pdev->dev, pdata->dvs_pin, "S2MPS13 DVS_PIN"); if (ret < 0) return ret; gpio_direction_output(pdata->dvs_pin, 0); } else { /* Set DVS Regulator Voltage */ ret = sec_reg_write(iodev, S2MPS13_REG_B6CTRL3, 0x28); if (ret < 0) return ret; if (!gpio_is_valid(pdata->dvs_pin)) { dev_err(&pdev->dev, "dvs_pin GPIO NOT VALID\n"); return -EINVAL; } } s2mps13->dvs_pin = pdata->dvs_pin; } platform_set_drvdata(pdev, s2mps13); for (i = 0; i < pdata->num_regulators; i++) { int id = pdata->regulators[i].id; config.dev = &pdev->dev; config.regmap = iodev->regmap; config.init_data = pdata->regulators[i].initdata; config.driver_data = s2mps13; config.of_node = pdata->regulators[i].reg_node; s2mps13->opmode[id] = regulators[s2mps13_desc_type][id].enable_mask; s2mps13->rdev[i] = regulator_register( ®ulators[s2mps13_desc_type][id], &config); if (IS_ERR(s2mps13->rdev[i])) { ret = PTR_ERR(s2mps13->rdev[i]); dev_err(&pdev->dev, "regulator init failed for %d\n", i); s2mps13->rdev[i] = NULL; goto err; } } if (pdata->g3d_en && SEC_PMIC_REV(iodev) > 0x02 && gpio_is_valid(pdata->g3d_pin)) { ret = devm_gpio_request(&pdev->dev, pdata->g3d_pin, "S2MPS13 G3D_PIN"); if (pdata->g3d_en) { gpio_direction_output(pdata->g3d_pin, 1); udelay(128); ret = sec_reg_update(iodev, S2MPS13_REG_B6CTRL1, 0x00, 0xC0); ret = sec_reg_update(iodev, S2MPS13_REG_LDO_DVS3, 0x02, 0x02); } else gpio_direction_output(pdata->g3d_pin, 0); s2mps13->g3d_pin = pdata->g3d_pin; } /* PMIC AVP(Adaptive Voltage Positioning) Configuration */ if (pdata->ap_buck_avp_en) { sec_reg_write(iodev, 0x91, 0x4F); /* Buck4 AVP level 11mV/A */ sec_reg_write(iodev, 0x99, 0x4D); /* Buck6 AVP level 7mV/A */ sec_reg_update(iodev, S2MPS13_REG_B4CTRL1, 0x02, 0x02); /* Buck4 AVP On */ sec_reg_update(iodev, S2MPS13_REG_B6CTRL1, 0x02, 0x02); /* Buck6 AVP On */ } if (pdata->sub_buck_avp_en) { sec_reg_write(iodev, 0xBA, 0x4C); /* Buck8 AVP level 90mV/A */ sec_reg_write(iodev, 0xBB, 0x6A); /* Buck9 AVP level 115mV/A */ sec_reg_write(iodev, 0xB1, 0x0A); /* Buck8 AVP amp offset code */ sec_reg_write(iodev, 0xB5, 0x2A); /* Buck9 AVP amp offset code */ sec_reg_update(iodev, S2MPS13_REG_B8CTRL1, 0x02, 0x02); /* Buck8 AVP On */ sec_reg_update(iodev, S2MPS13_REG_B9CTRL1, 0x02, 0x02); /* Buck9 AVP On */ } return 0; err: for (i = 0; i < S2MPS13_REGULATOR_MAX; i++) regulator_unregister(s2mps13->rdev[i]); return ret; }
static int regulator_stub_probe(struct platform_device *pdev) { struct regulator_config reg_config = {}; struct regulator_init_data *init_data = NULL; struct device *dev = &pdev->dev; struct stub_regulator_pdata *vreg_pdata; struct regulator_desc *rdesc; struct regulator_stub *vreg_priv; int rc; vreg_priv = kzalloc(sizeof(*vreg_priv), GFP_KERNEL); if (!vreg_priv) { dev_err(dev, "%s: Unable to allocate memory\n", __func__); return -ENOMEM; } if (dev->of_node) { /* Use device tree. */ init_data = of_get_regulator_init_data(dev, dev->of_node); if (!init_data) { dev_err(dev, "%s: unable to allocate memory\n", __func__); rc = -ENOMEM; goto err_probe; } if (init_data->constraints.name == NULL) { dev_err(dev, "%s: regulator name not specified\n", __func__); rc = -EINVAL; goto err_probe; } if (of_get_property(dev->of_node, "parent-supply", NULL)) init_data->supply_regulator = "parent"; of_property_read_u32(dev->of_node, "qcom,system-load", &vreg_priv->system_uA); of_property_read_u32(dev->of_node, "qcom,hpm-min-load", &vreg_priv->hpm_min_load); init_data->constraints.input_uV = init_data->constraints.max_uV; init_data->constraints.valid_ops_mask |= REGULATOR_CHANGE_STATUS; init_data->constraints.valid_ops_mask |= REGULATOR_CHANGE_VOLTAGE; init_data->constraints.valid_ops_mask |= REGULATOR_CHANGE_MODE | REGULATOR_CHANGE_DRMS; init_data->constraints.valid_modes_mask = REGULATOR_MODE_NORMAL | REGULATOR_MODE_IDLE; } else { /* Use platform data. */ vreg_pdata = dev->platform_data; if (!vreg_pdata) { dev_err(dev, "%s: no platform data\n", __func__); rc = -EINVAL; goto err_probe; } init_data = &vreg_pdata->init_data; vreg_priv->system_uA = vreg_pdata->system_uA; vreg_priv->hpm_min_load = vreg_pdata->hpm_min_load; } dev_set_drvdata(dev, vreg_priv); rdesc = &vreg_priv->rdesc; strlcpy(vreg_priv->name, init_data->constraints.name, STUB_REGULATOR_MAX_NAME); rdesc->name = vreg_priv->name; rdesc->ops = ®ulator_stub_ops; /* * Ensure that voltage set points are handled correctly for regulators * which have a specified voltage constraint range, as well as those * that do not. */ if (init_data->constraints.min_uV == 0 && init_data->constraints.max_uV == 0) rdesc->n_voltages = 0; else rdesc->n_voltages = 2; rdesc->id = pdev->id; rdesc->owner = THIS_MODULE; rdesc->type = REGULATOR_VOLTAGE; vreg_priv->voltage = init_data->constraints.min_uV; if (vreg_priv->system_uA >= vreg_priv->hpm_min_load) vreg_priv->mode = REGULATOR_MODE_NORMAL; else vreg_priv->mode = REGULATOR_MODE_IDLE; reg_config.dev = dev; reg_config.init_data = init_data; reg_config.driver_data = vreg_priv; reg_config.of_node = dev->of_node; vreg_priv->rdev = regulator_register(rdesc, ®_config); if (IS_ERR(vreg_priv->rdev)) { rc = PTR_ERR(vreg_priv->rdev); vreg_priv->rdev = NULL; if (rc != -EPROBE_DEFER) dev_err(dev, "%s: regulator_register failed\n", __func__); goto err_probe; } return 0; err_probe: regulator_stub_cleanup(vreg_priv); return rc; }
static int __devinit anatop_regulator_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct device_node *np = dev->of_node; struct regulator_desc *rdesc; struct regulator_dev *rdev; struct anatop_regulator *sreg; struct regulator_init_data *initdata; struct anatop *anatopmfd = dev_get_drvdata(pdev->dev.parent); int ret = 0; initdata = of_get_regulator_init_data(dev, np); sreg = devm_kzalloc(dev, sizeof(*sreg), GFP_KERNEL); if (!sreg) return -ENOMEM; sreg->initdata = initdata; sreg->name = kstrdup(of_get_property(np, "regulator-name", NULL), GFP_KERNEL); rdesc = &sreg->rdesc; memset(rdesc, 0, sizeof(*rdesc)); rdesc->name = sreg->name; rdesc->ops = &anatop_rops; rdesc->type = REGULATOR_VOLTAGE; rdesc->owner = THIS_MODULE; sreg->mfd = anatopmfd; ret = of_property_read_u32(np, "anatop-reg-offset", &sreg->control_reg); if (ret) { dev_err(dev, "no anatop-reg-offset property set\n"); goto anatop_probe_end; } ret = of_property_read_u32(np, "anatop-vol-bit-width", &sreg->vol_bit_width); if (ret) { dev_err(dev, "no anatop-vol-bit-width property set\n"); goto anatop_probe_end; } ret = of_property_read_u32(np, "anatop-vol-bit-shift", &sreg->vol_bit_shift); if (ret) { dev_err(dev, "no anatop-vol-bit-shift property set\n"); goto anatop_probe_end; } ret = of_property_read_u32(np, "anatop-min-bit-val", &sreg->min_bit_val); if (ret) { dev_err(dev, "no anatop-min-bit-val property set\n"); goto anatop_probe_end; } ret = of_property_read_u32(np, "anatop-min-voltage", &sreg->min_voltage); if (ret) { dev_err(dev, "no anatop-min-voltage property set\n"); goto anatop_probe_end; } ret = of_property_read_u32(np, "anatop-max-voltage", &sreg->max_voltage); if (ret) { dev_err(dev, "no anatop-max-voltage property set\n"); goto anatop_probe_end; } rdesc->n_voltages = (sreg->max_voltage - sreg->min_voltage) / 25000 + 1; rdev = regulator_register(rdesc, dev, initdata, sreg, pdev->dev.of_node); if (IS_ERR(rdev)) { dev_err(dev, "failed to register %s\n", rdesc->name); ret = PTR_ERR(rdev); goto anatop_probe_end; } platform_set_drvdata(pdev, rdev); anatop_probe_end: if (ret) kfree(sreg->name); return ret; }
static int __devinit ncp6335d_regulator_probe(struct i2c_client *client, const struct i2c_device_id *id) { int rc; unsigned int val = 0, val1 = 0; struct ncp6335d_info *dd; const struct ncp6335d_platform_data *pdata; pdata = client->dev.platform_data; if (!pdata) { dev_err(&client->dev, "Platform data not specified\n"); return -EINVAL; } dd = devm_kzalloc(&client->dev, sizeof(*dd), GFP_KERNEL); if (!dd) { dev_err(&client->dev, "Unable to allocate memory\n"); return -ENOMEM; } dd->regmap = devm_regmap_init_i2c(client, &ncp6335d_regmap_config); if (IS_ERR(dd->regmap)) { dev_err(&client->dev, "Error allocating regmap\n"); return PTR_ERR(dd->regmap); } rc = regmap_read(dd->regmap, REG_NCP6335D_PID, &val); if (rc) { dev_err(&client->dev, "Unable to identify NCP6335D (PID), rc(%d)\n", rc); return rc; } rc = regmap_read(dd->regmap, REG_NCP6335D_FID, &val1); if (rc) { dev_err(&client->dev, "Unable to identify NCP6335D (FID), rc(%d)\n", rc); return rc; } dev_info(&client->dev, "Detected Regulator NCP6335D PID = %d, FID = %d\n", val, val1); dd->init_data = pdata->init_data; dd->dev = &client->dev; i2c_set_clientdata(client, dd); rc = ncp6335d_init(dd, pdata); if (rc) { dev_err(&client->dev, "Unable to intialize the regulator\n"); return -EINVAL; } dd->regulator = regulator_register(&rdesc, &client->dev, dd->init_data, dd, NULL); if (IS_ERR(dd->regulator)) { dev_err(&client->dev, "Unable to register regulator rc(%ld)", PTR_ERR(dd->regulator)); return PTR_ERR(dd->regulator); } ncp6335d = dd; return 0; }
static int gdsc_probe(struct platform_device *pdev) { static atomic_t gdsc_count = ATOMIC_INIT(-1); struct regulator_config reg_config = {}; struct regulator_init_data *init_data; struct resource *res; struct gdsc *sc; uint32_t regval; bool retain_mem, retain_periph, support_hw_trigger; int i, ret; sc = devm_kzalloc(&pdev->dev, sizeof(struct gdsc), GFP_KERNEL); if (sc == NULL) return -ENOMEM; init_data = of_get_regulator_init_data(&pdev->dev, pdev->dev.of_node); if (init_data == NULL) return -ENOMEM; if (of_get_property(pdev->dev.of_node, "parent-supply", NULL)) init_data->supply_regulator = "parent"; ret = of_property_read_string(pdev->dev.of_node, "regulator-name", &sc->rdesc.name); if (ret) return ret; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (res == NULL) return -EINVAL; sc->gdscr = devm_ioremap(&pdev->dev, res->start, resource_size(res)); if (sc->gdscr == NULL) return -ENOMEM; sc->clock_count = of_property_count_strings(pdev->dev.of_node, "clock-names"); if (sc->clock_count == -EINVAL) { sc->clock_count = 0; } else if (IS_ERR_VALUE(sc->clock_count)) { dev_err(&pdev->dev, "Failed to get clock names\n"); return -EINVAL; } sc->clocks = devm_kzalloc(&pdev->dev, sizeof(struct clk *) * sc->clock_count, GFP_KERNEL); if (!sc->clocks) return -ENOMEM; sc->root_en = of_property_read_bool(pdev->dev.of_node, "qcom,enable-root-clk"); for (i = 0; i < sc->clock_count; i++) { const char *clock_name; of_property_read_string_index(pdev->dev.of_node, "clock-names", i, &clock_name); sc->clocks[i] = devm_clk_get(&pdev->dev, clock_name); if (IS_ERR(sc->clocks[i])) { int rc = PTR_ERR(sc->clocks[i]); if (rc != -EPROBE_DEFER) dev_err(&pdev->dev, "Failed to get %s\n", clock_name); return rc; } } sc->rdesc.id = atomic_inc_return(&gdsc_count); sc->rdesc.ops = &gdsc_ops; sc->rdesc.type = REGULATOR_VOLTAGE; sc->rdesc.owner = THIS_MODULE; platform_set_drvdata(pdev, sc); /* * Disable HW trigger: collapse/restore occur based on registers writes. * Disable SW override: Use hardware state-machine for sequencing. */ regval = readl_relaxed(sc->gdscr); regval &= ~(HW_CONTROL_MASK | SW_OVERRIDE_MASK); /* Configure wait time between states. */ regval &= ~(EN_REST_WAIT_MASK | EN_FEW_WAIT_MASK | CLK_DIS_WAIT_MASK); regval |= EN_REST_WAIT_VAL | EN_FEW_WAIT_VAL | CLK_DIS_WAIT_VAL; writel_relaxed(regval, sc->gdscr); retain_mem = of_property_read_bool(pdev->dev.of_node, "qcom,retain-mem"); sc->toggle_mem = !retain_mem; retain_periph = of_property_read_bool(pdev->dev.of_node, "qcom,retain-periph"); sc->toggle_periph = !retain_periph; sc->toggle_logic = !of_property_read_bool(pdev->dev.of_node, "qcom,skip-logic-collapse"); support_hw_trigger = of_property_read_bool(pdev->dev.of_node, "qcom,support-hw-trigger"); if (support_hw_trigger) { init_data->constraints.valid_ops_mask |= REGULATOR_CHANGE_MODE; init_data->constraints.valid_modes_mask |= REGULATOR_MODE_NORMAL | REGULATOR_MODE_FAST; } if (!sc->toggle_logic) { regval &= ~SW_COLLAPSE_MASK; writel_relaxed(regval, sc->gdscr); ret = readl_tight_poll_timeout(sc->gdscr, regval, regval & PWR_ON_MASK, TIMEOUT_US); if (ret) { dev_err(&pdev->dev, "%s enable timed out: 0x%x\n", sc->rdesc.name, regval); return ret; } } for (i = 0; i < sc->clock_count; i++) { if (retain_mem || (regval & PWR_ON_MASK)) clk_set_flags(sc->clocks[i], CLKFLAG_RETAIN_MEM); else clk_set_flags(sc->clocks[i], CLKFLAG_NORETAIN_MEM); if (retain_periph || (regval & PWR_ON_MASK)) clk_set_flags(sc->clocks[i], CLKFLAG_RETAIN_PERIPH); else clk_set_flags(sc->clocks[i], CLKFLAG_NORETAIN_PERIPH); } reg_config.dev = &pdev->dev; reg_config.init_data = init_data; reg_config.driver_data = sc; reg_config.of_node = pdev->dev.of_node; sc->rdev = regulator_register(&sc->rdesc, ®_config); if (IS_ERR(sc->rdev)) { dev_err(&pdev->dev, "regulator_register(\"%s\") failed.\n", sc->rdesc.name); return PTR_ERR(sc->rdev); } return 0; }
static int max8973_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct max8973_regulator_platform_data *pdata; struct regulator_config config = { }; struct regulator_dev *rdev; struct max8973_chip *max; int ret; pdata = client->dev.platform_data; if (!pdata) { dev_err(&client->dev, "No Platform data"); return -EIO; } max = devm_kzalloc(&client->dev, sizeof(*max), GFP_KERNEL); if (!max) { dev_err(&client->dev, "Memory allocation for max failed\n"); return -ENOMEM; } max->regmap = devm_regmap_init_i2c(client, &max8973_regmap_config); if (IS_ERR(max->regmap)) { ret = PTR_ERR(max->regmap); dev_err(&client->dev, "regmap init failed, err %d\n", ret); return ret; } i2c_set_clientdata(client, max); max->dev = &client->dev; max->desc.name = id->name; max->desc.id = 0; max->desc.ops = &max8973_dcdc_ops; max->desc.type = REGULATOR_VOLTAGE; max->desc.owner = THIS_MODULE; max->desc.min_uV = MAX8973_MIN_VOLATGE; max->desc.uV_step = MAX8973_VOLATGE_STEP; max->desc.n_voltages = MAX8973_BUCK_N_VOLTAGE; if (!pdata->enable_ext_control) { max->desc.enable_reg = MAX8973_VOUT; max->desc.enable_mask = MAX8973_VOUT_ENABLE; max8973_dcdc_ops.enable = regulator_enable_regmap; max8973_dcdc_ops.disable = regulator_disable_regmap; max8973_dcdc_ops.is_enabled = regulator_is_enabled_regmap; } max->enable_external_control = pdata->enable_ext_control; max->dvs_gpio = pdata->dvs_gpio; max->curr_gpio_val = pdata->dvs_def_state; max->curr_vout_reg = MAX8973_VOUT + pdata->dvs_def_state; max->lru_index[0] = max->curr_vout_reg; max->valid_dvs_gpio = false; if (gpio_is_valid(max->dvs_gpio)) { int gpio_flags; int i; gpio_flags = (pdata->dvs_def_state) ? GPIOF_OUT_INIT_HIGH : GPIOF_OUT_INIT_LOW; ret = devm_gpio_request_one(&client->dev, max->dvs_gpio, gpio_flags, "max8973-dvs"); if (ret) { dev_err(&client->dev, "gpio_request for gpio %d failed, err = %d\n", max->dvs_gpio, ret); return ret; } max->valid_dvs_gpio = true; /* * Initialize the lru index with vout_reg id * The index 0 will be most recently used and * set with the max->curr_vout_reg */ for (i = 0; i < MAX8973_MAX_VOUT_REG; ++i) max->lru_index[i] = i; max->lru_index[0] = max->curr_vout_reg; max->lru_index[max->curr_vout_reg] = 0; } ret = max8973_init_dcdc(max, pdata); if (ret < 0) { dev_err(max->dev, "Max8973 Init failed, err = %d\n", ret); return ret; } config.dev = &client->dev; config.init_data = pdata->reg_init_data; config.driver_data = max; config.of_node = client->dev.of_node; config.regmap = max->regmap; /* Register the regulators */ rdev = regulator_register(&max->desc, &config); if (IS_ERR(rdev)) { ret = PTR_ERR(rdev); dev_err(max->dev, "regulator register failed, err %d\n", ret); return ret; } max->rdev = rdev; return 0; }
static int ncp6335d_regulator_probe(struct i2c_client *client, const struct i2c_device_id *id) { int rc; unsigned int val = 0; struct ncp6335d_info *dd; const struct ncp6335d_platform_data *pdata; struct regulator_config config = { }; #ifdef CONFIG_MACH_YULONG /* the i2c address of ncp6335d is somehow changed, trying to poll if failed. [email protected] 2014-12-29*/ int i2c_addr_backup[3] = { 0x18, 0x10, 0x14}; int i_a = 0; pr_err("%s:ncp addr is 0x%2x\n",__func__,client->addr); #endif if (client->dev.of_node) pdata = ncp6335d_get_of_platform_data(client); else pdata = client->dev.platform_data; if (!pdata) { dev_err(&client->dev, "Platform data not specified\n"); return -EINVAL; } dd = devm_kzalloc(&client->dev, sizeof(*dd), GFP_KERNEL); if (!dd) { dev_err(&client->dev, "Unable to allocate memory\n"); return -ENOMEM; } if (client->dev.of_node) { rc = ncp6335d_parse_dt(client, dd); if (rc) return rc; } else { dd->step_size = NCP6335D_STEP_VOLTAGE_UV; dd->min_voltage = NCP6335D_MIN_VOLTAGE_UV; dd->min_slew_ns = NCP6335D_MIN_SLEW_NS; dd->max_slew_ns = NCP6335D_MAX_SLEW_NS; } dd->regmap = devm_regmap_init_i2c(client, &ncp6335d_regmap_config); if (IS_ERR(dd->regmap)) { dev_err(&client->dev, "Error allocating regmap\n"); return PTR_ERR(dd->regmap); } #ifdef CONFIG_MACH_YULONG AGAIN: #endif rc = ncp6335x_read(dd, REG_NCP6335D_PID, &val); if (rc) { dev_err(&client->dev, "Unable to identify NCP6335D, rc(%d)\n", rc); #ifdef CONFIG_MACH_YULONG dev_err(&client->dev, "ncp addr is 0x%2x, force addr as 0x%2x and retry\n", client->addr, i2c_addr_backup[i_a]); while (i_a < 3) { client->addr = i2c_addr_backup[i_a]; i_a++; goto AGAIN; } #endif return rc; } dev_info(&client->dev, "Detected Regulator NCP6335D PID = %d\n", val); dd->init_data = pdata->init_data; dd->dev = &client->dev; i2c_set_clientdata(client, dd); mutex_init(&dd->ncp_mutex); rc = ncp6335d_init(client, dd, pdata); if (rc) { dev_err(&client->dev, "Unable to intialize the regulator\n"); return -EINVAL; } config.dev = &client->dev; config.init_data = dd->init_data; config.regmap = dd->regmap; config.driver_data = dd; config.of_node = client->dev.of_node; dd->regulator = regulator_register(&rdesc, &config); if (IS_ERR(dd->regulator)) { dev_err(&client->dev, "Unable to register regulator rc(%ld)", PTR_ERR(dd->regulator)); return PTR_ERR(dd->regulator); } dd->debug_root = debugfs_create_dir("ncp6335x", NULL); if (!dd->debug_root) dev_err(&client->dev, "Couldn't create debug dir\n"); if (dd->debug_root) { struct dentry *ent; ent = debugfs_create_x32("address", S_IFREG | S_IWUSR | S_IRUGO, dd->debug_root, &(dd->peek_poke_address)); if (!ent) dev_err(&client->dev, "Couldn't create address debug file rc = %d\n", rc); ent = debugfs_create_file("data", S_IFREG | S_IWUSR | S_IRUGO, dd->debug_root, dd, &poke_poke_debug_ops); if (!ent) dev_err(&client->dev, "Couldn't create data debug file rc = %d\n", rc); } return 0; }
static int regulator_fixed_voltage_probe(struct platform_device *pdev) { struct fixed_voltage_config *config = pdev->dev.platform_data; struct fixed_voltage_data *drvdata; int ret; drvdata = kzalloc(sizeof(struct fixed_voltage_data), GFP_KERNEL); if (drvdata == NULL) { dev_err(&pdev->dev, "Failed to allocate device data\n"); ret = -ENOMEM; goto err; } drvdata->desc.name = kstrdup(config->supply_name, GFP_KERNEL); if (drvdata->desc.name == NULL) { dev_err(&pdev->dev, "Failed to allocate supply name\n"); ret = -ENOMEM; goto err; } drvdata->desc.type = REGULATOR_VOLTAGE; drvdata->desc.owner = THIS_MODULE; drvdata->desc.ops = &fixed_voltage_ops; drvdata->desc.n_voltages = 1; drvdata->microvolts = config->microvolts; drvdata->gpio = config->gpio; if (gpio_is_valid(config->gpio)) { drvdata->enable_high = config->enable_high; /* FIXME: Remove below print warning * * config->gpio must be set to -EINVAL by platform code if * GPIO control is not required. However, early adopters * not requiring GPIO control may forget to initialize * config->gpio to -EINVAL. This will cause GPIO 0 to be used * for GPIO control. * * This warning will be removed once there are a couple of users * for this driver. */ if (!config->gpio) dev_warn(&pdev->dev, "using GPIO 0 for regulator enable control\n"); ret = gpio_request(config->gpio, config->supply_name); if (ret) { dev_err(&pdev->dev, "Could not obtain regulator enable GPIO %d: %d\n", config->gpio, ret); goto err_name; } /* set output direction without changing state * to prevent glitch */ drvdata->is_enabled = config->enabled_at_boot; ret = drvdata->is_enabled ? config->enable_high : !config->enable_high; ret = gpio_direction_output(config->gpio, ret); if (ret) { dev_err(&pdev->dev, "Could not configure regulator enable GPIO %d direction: %d\n", config->gpio, ret); goto err_gpio; } } else { /* Regulator without GPIO control is considered * always enabled */ drvdata->is_enabled = 1; } drvdata->dev = regulator_register(&drvdata->desc, &pdev->dev, config->init_data, drvdata); if (IS_ERR(drvdata->dev)) { ret = PTR_ERR(drvdata->dev); dev_err(&pdev->dev, "Failed to register regulator: %d\n", ret); goto err_gpio; } platform_set_drvdata(pdev, drvdata); dev_dbg(&pdev->dev, "%s supplying %duV\n", drvdata->desc.name, drvdata->microvolts); return 0; err_gpio: if (gpio_is_valid(config->gpio)) gpio_free(config->gpio); err_name: kfree(drvdata->desc.name); err: kfree(drvdata); return ret; }
static __devinit int wm8994_ldo_probe(struct platform_device *pdev) { struct wm8994 *wm8994 = dev_get_drvdata(pdev->dev.parent); struct wm8994_pdata *pdata = wm8994->dev->platform_data; int id = pdev->id % ARRAY_SIZE(pdata->ldo); struct wm8994_ldo *ldo; int ret; dev_dbg(&pdev->dev, "Probing LDO%d\n", id + 1); if (!pdata) return -ENODEV; ldo = kzalloc(sizeof(struct wm8994_ldo), GFP_KERNEL); if (ldo == NULL) { dev_err(&pdev->dev, "Unable to allocate private data\n"); return -ENOMEM; } ldo->wm8994 = wm8994; if(pdata->ldo[id].iomux_name != NULL) rk29_mux_api_set(pdata->ldo[id].iomux_name, pdata->ldo[id].iomux_mode); if (pdata->ldo[id].enable && gpio_is_valid(pdata->ldo[id].enable)) { ldo->enable = pdata->ldo[id].enable; ldo->is_enabled = true; ret = gpio_request(ldo->enable, "WM8994 LDO enable"); if (ret < 0) { dev_err(&pdev->dev, "Failed to get enable GPIO: %d\n", ret); goto err; } ret = gpio_direction_output(ldo->enable, ldo->is_enabled); if (ret < 0) { dev_err(&pdev->dev, "Failed to set GPIO up: %d\n", ret); goto err_gpio; } msleep(50); } else ldo->is_enabled = true; ldo->regulator = regulator_register(&wm8994_ldo_desc[id], &pdev->dev, pdata->ldo[id].init_data, ldo); if (IS_ERR(ldo->regulator)) { ret = PTR_ERR(ldo->regulator); dev_err(wm8994->dev, "Failed to register LDO%d: %d\n", id + 1, ret); goto err_gpio; } platform_set_drvdata(pdev, ldo); return 0; err_gpio: if (gpio_is_valid(ldo->enable)) gpio_free(ldo->enable); err: kfree(ldo); return ret; }
static int tps80031_regulator_probe(struct platform_device *pdev) { struct tps80031_platform_data *pdata; struct tps80031_regulator_platform_data *tps_pdata; struct tps80031_regulator *ri; struct tps80031_regulator *pmic; struct regulator_dev *rdev; struct regulator_config config = { }; struct tps80031 *tps80031_mfd = dev_get_drvdata(pdev->dev.parent); int ret; int num; pdata = dev_get_platdata(pdev->dev.parent); if (!pdata) { dev_err(&pdev->dev, "No platform data\n"); return -EINVAL; } pmic = devm_kzalloc(&pdev->dev, TPS80031_REGULATOR_MAX * sizeof(*pmic), GFP_KERNEL); if (!pmic) { dev_err(&pdev->dev, "mem alloc for pmic failed\n"); return -ENOMEM; } for (num = 0; num < TPS80031_REGULATOR_MAX; ++num) { tps_pdata = pdata->regulator_pdata[num]; ri = &pmic[num]; ri->rinfo = &tps80031_rinfo[num]; ri->dev = &pdev->dev; check_smps_mode_mult(pdev->dev.parent, ri); config.dev = &pdev->dev; config.init_data = NULL; config.driver_data = ri; config.regmap = tps80031_mfd->regmap[ri->rinfo->volt_id]; if (tps_pdata) { config.init_data = tps_pdata->reg_init_data; ri->config_flags = tps_pdata->config_flags; ri->ext_ctrl_flag = tps_pdata->ext_ctrl_flag; ret = tps80031_regulator_config(pdev->dev.parent, ri, tps_pdata); if (ret < 0) { dev_err(&pdev->dev, "regulator config failed, e %d\n", ret); goto fail; } ret = tps80031_power_req_config(pdev->dev.parent, ri, tps_pdata); if (ret < 0) { dev_err(&pdev->dev, "pwr_req config failed, err %d\n", ret); goto fail; } } rdev = regulator_register(&ri->rinfo->desc, &config); if (IS_ERR(rdev)) { dev_err(&pdev->dev, "register regulator failed %s\n", ri->rinfo->desc.name); ret = PTR_ERR(rdev); goto fail; } ri->rdev = rdev; } platform_set_drvdata(pdev, pmic); return 0; fail: while (--num >= 0) { ri = &pmic[num]; regulator_unregister(ri->rdev); } return ret; }