static int tps6130x_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct tps_info *info = (void *)id->driver_data; struct regulator_init_data *init_data; struct regulator_dev *rdev; struct tps_pmic *tps; int revid, ret; if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA)) return -EIO; init_data = client->dev.platform_data; if (!init_data) return -EIO; tps = kzalloc(sizeof(*tps), GFP_KERNEL); if (!tps) return -ENOMEM; mutex_init(&tps->io_lock); tps->client = client; tps->info = info; tps->desc = &tps6130x_desc; if (init_data->driver_data) tps->pdata = init_data->driver_data; /* register the regulator */ rdev = regulator_register(tps->desc, &client->dev, init_data, tps); if (IS_ERR(rdev)) { dev_err(&client->dev, "failed to register %s\n", id->name); ret = PTR_ERR(rdev); goto reg_err; } tps->rdev = rdev; i2c_set_clientdata(client, tps); ret = tps6130x_chip_enable(tps, 1); if (ret) goto enable_err; revid = tps6130x_reg_read(tps, TPS6130X_REGISTER7); if (revid < 0) { dev_err(&client->dev, "failed to access device\n"); ret = revid; goto rev_err; } dev_info(&client->dev, "Revision %d\n", revid & TPS6130X_REVID_MASK); /* default output voltage: 4.950V */ tps->info->vsel = 9; ret = tps6130x_chip_enable(tps, 0); if (ret) goto rev_err; return 0; rev_err: tps6130x_chip_enable(tps, 0); enable_err: i2c_set_clientdata(client, NULL); regulator_unregister(tps->rdev); reg_err: mutex_destroy(&tps->io_lock); tps->client = NULL; kfree(tps); return ret; }
static __devinit int wm831x_aldo_probe(struct platform_device *pdev) { struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent); struct wm831x_pdata *pdata = wm831x->dev->platform_data; int id; struct wm831x_ldo *ldo; struct resource *res; int ret, irq; if (pdata && pdata->wm831x_num) id = (pdata->wm831x_num * 10) + 1; else id = 0; id = pdev->id - id; dev_dbg(&pdev->dev, "Probing LDO%d\n", id + 1); if (pdata == NULL || pdata->ldo[id] == NULL) return -ENODEV; ldo = kzalloc(sizeof(struct wm831x_ldo), GFP_KERNEL); if (ldo == NULL) { dev_err(&pdev->dev, "Unable to allocate private data\n"); return -ENOMEM; } ldo->wm831x = wm831x; res = platform_get_resource(pdev, IORESOURCE_IO, 0); if (res == NULL) { dev_err(&pdev->dev, "No I/O resource\n"); ret = -EINVAL; goto err; } ldo->base = res->start; snprintf(ldo->name, sizeof(ldo->name), "LDO%d", id + 1); ldo->desc.name = ldo->name; ldo->desc.id = id; ldo->desc.type = REGULATOR_VOLTAGE; ldo->desc.n_voltages = WM831X_ALDO_MAX_SELECTOR + 1; ldo->desc.ops = &wm831x_aldo_ops; ldo->desc.owner = THIS_MODULE; ldo->regulator = regulator_register(&ldo->desc, &pdev->dev, pdata->ldo[id], ldo); if (IS_ERR(ldo->regulator)) { ret = PTR_ERR(ldo->regulator); dev_err(wm831x->dev, "Failed to register LDO%d: %d\n", id + 1, ret); goto err; } irq = platform_get_irq_byname(pdev, "UV"); ret = request_threaded_irq(irq, NULL, wm831x_ldo_uv_irq, IRQF_TRIGGER_RISING, ldo->name, ldo); if (ret != 0) { dev_err(&pdev->dev, "Failed to request UV IRQ %d: %d\n", irq, ret); goto err_regulator; } platform_set_drvdata(pdev, ldo); return 0; err_regulator: regulator_unregister(ldo->regulator); err: kfree(ldo); return ret; }
static int tps80031_charger_probe(struct platform_device *pdev) { int ret = 0; struct device *dev = &pdev->dev; struct tps80031_charger *charger; struct tps80031_platform_data *tps80031_pdata; struct tps80031_charger_platform_data *pdata; struct regulator_config config = { }; dev_info(dev, "%s()\n", __func__); tps80031_pdata = dev_get_platdata(pdev->dev.parent); if (!tps80031_pdata) { dev_err(&pdev->dev, "no tps80031 platform_data specified\n"); return -EINVAL; } pdata = tps80031_pdata->battery_charger_pdata; if (!pdata) { dev_err(dev, "%s() No platform data, exiting..\n", __func__); return -ENODEV; } if (!pdata->num_consumer_supplies) { dev_err(dev, "%s() No consumer supply list, exiting..\n", __func__); return -ENODEV; } charger = kzalloc(sizeof(*charger), GFP_KERNEL); if (!charger) { dev_err(dev, "failed to allocate memory status\n"); return -ENOMEM; } charger->dev = &pdev->dev; charger->max_charge_current_mA = (pdata->max_charge_current_mA) ? pdata->max_charge_current_mA : 1000; charger->max_charge_volt_mV = (pdata->max_charge_volt_mV) ? pdata->max_charge_volt_mV : 4200; charger->irq_base = pdata->irq_base; charger->watch_time_sec = min(pdata->watch_time_sec, 127); if (!charger->watch_time_sec) charger->watch_time_sec = 127; charger->charging_term_current_mA = min(50, pdata->charging_term_current_mA); if (charger->charging_term_current_mA < 50) charger->charging_term_current_mA = 50; charger->reg_desc.name = "vbus_charger"; charger->reg_desc.id = pdata->regulator_id; charger->reg_desc.ops = &tegra_regulator_ops; charger->reg_desc.type = REGULATOR_CURRENT; charger->reg_desc.owner = THIS_MODULE; charger->reg_init_data.supply_regulator = NULL; charger->reg_init_data.num_consumer_supplies = pdata->num_consumer_supplies; charger->reg_init_data.consumer_supplies = pdata->consumer_supplies; charger->reg_init_data.regulator_init = NULL; charger->reg_init_data.driver_data = charger; charger->reg_init_data.constraints.name = "vbus_charger"; charger->reg_init_data.constraints.min_uA = 0; charger->reg_init_data.constraints.max_uA = pdata->max_charge_current_mA * 1000; charger->reg_init_data.constraints.valid_modes_mask = REGULATOR_MODE_NORMAL | REGULATOR_MODE_STANDBY; charger->reg_init_data.constraints.valid_ops_mask = REGULATOR_CHANGE_MODE | REGULATOR_CHANGE_STATUS | REGULATOR_CHANGE_CURRENT; charger->board_init = pdata->board_init; charger->board_data = pdata->board_data; charger->state = charging_state_idle; config.dev = &pdev->dev; config.init_data = &charger->reg_init_data; config.driver_data = charger; config.of_node = NULL; charger->rdev = regulator_register(&charger->reg_desc, &config); if (IS_ERR(charger->rdev)) { dev_err(&pdev->dev, "failed to register %s\n", charger->reg_desc.name); ret = PTR_ERR(charger->rdev); goto regulator_fail; } ret = request_threaded_irq(charger->irq_base + TPS80031_INT_LINCH_GATED, NULL, linch_status_isr, 0, "tps80031-linch", charger); if (ret) { dev_err(&pdev->dev, "Unable to register irq %d; error %d\n", charger->irq_base + TPS80031_INT_LINCH_GATED, ret); goto irq_linch_fail; } ret = request_threaded_irq(charger->irq_base + TPS80031_INT_FAULT_WDG, NULL, watchdog_expire_isr, 0, "tps80031-wdg", charger); if (ret) { dev_err(&pdev->dev, "Unable to register irq %d; error %d\n", charger->irq_base + TPS80031_INT_FAULT_WDG, ret); goto irq_wdg_fail; } ret = configure_charging_parameter(charger); if (ret) goto config_fail; dev_set_drvdata(&pdev->dev, charger); charger_data = charger; return ret; config_fail: free_irq(charger->irq_base + TPS80031_INT_FAULT_WDG, charger); irq_wdg_fail: free_irq(charger->irq_base + TPS80031_INT_LINCH_GATED, charger); irq_linch_fail: regulator_unregister(charger->rdev); regulator_fail: kfree(charger); return ret; }
static __devinit int wm831x_buckv_probe(struct platform_device *pdev) { struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent); struct wm831x_pdata *pdata = wm831x->dev->platform_data; int id = pdev->id % ARRAY_SIZE(pdata->dcdc); struct wm831x_dcdc *dcdc; struct resource *res; int ret, irq; dev_dbg(&pdev->dev, "Probing DCDC%d\n", id + 1); if (pdata == NULL || pdata->dcdc[id] == NULL) return -ENODEV; dcdc = kzalloc(sizeof(struct wm831x_dcdc), GFP_KERNEL); if (dcdc == NULL) { dev_err(&pdev->dev, "Unable to allocate private data\n"); return -ENOMEM; } dcdc->wm831x = wm831x; res = platform_get_resource(pdev, IORESOURCE_IO, 0); if (res == NULL) { dev_err(&pdev->dev, "No I/O resource\n"); ret = -EINVAL; goto err; } dcdc->base = res->start; snprintf(dcdc->name, sizeof(dcdc->name), "DCDC%d", id + 1); dcdc->desc.name = dcdc->name; dcdc->desc.id = id; dcdc->desc.type = REGULATOR_VOLTAGE; dcdc->desc.n_voltages = WM831X_BUCKV_MAX_SELECTOR + 1; dcdc->desc.ops = &wm831x_buckv_ops; dcdc->desc.owner = THIS_MODULE; ret = wm831x_reg_read(wm831x, dcdc->base + WM831X_DCDC_ON_CONFIG); if (ret < 0) { dev_err(wm831x->dev, "Failed to read ON VSEL: %d\n", ret); goto err; } dcdc->on_vsel = ret & WM831X_DC1_ON_VSEL_MASK; ret = wm831x_reg_read(wm831x, dcdc->base + WM831X_DCDC_ON_CONFIG); if (ret < 0) { dev_err(wm831x->dev, "Failed to read DVS VSEL: %d\n", ret); goto err; } dcdc->dvs_vsel = ret & WM831X_DC1_DVS_VSEL_MASK; if (pdata->dcdc[id]) wm831x_buckv_dvs_init(dcdc, pdata->dcdc[id]->driver_data); dcdc->regulator = regulator_register(&dcdc->desc, &pdev->dev, pdata->dcdc[id], dcdc); if (IS_ERR(dcdc->regulator)) { ret = PTR_ERR(dcdc->regulator); dev_err(wm831x->dev, "Failed to register DCDC%d: %d\n", id + 1, ret); goto err; } irq = platform_get_irq_byname(pdev, "UV"); ret = wm831x_request_irq(wm831x, irq, wm831x_dcdc_uv_irq, IRQF_TRIGGER_RISING, dcdc->name, dcdc); if (ret != 0) { dev_err(&pdev->dev, "Failed to request UV IRQ %d: %d\n", irq, ret); goto err_regulator; } irq = platform_get_irq_byname(pdev, "HC"); ret = wm831x_request_irq(wm831x, irq, wm831x_dcdc_oc_irq, IRQF_TRIGGER_RISING, dcdc->name, dcdc); if (ret != 0) { dev_err(&pdev->dev, "Failed to request HC IRQ %d: %d\n", irq, ret); goto err_uv; } platform_set_drvdata(pdev, dcdc); return 0; err_uv: wm831x_free_irq(wm831x, platform_get_irq_byname(pdev, "UV"), dcdc); err_regulator: regulator_unregister(dcdc->regulator); err: if (dcdc->dvs_gpio) gpio_free(dcdc->dvs_gpio); kfree(dcdc); return ret; }
static int tps6586x_regulator_probe(struct platform_device *pdev) { struct tps6586x_regulator *ri = NULL; struct regulator_config config = { }; struct regulator_dev **rdev; struct regulator_init_data *reg_data; struct tps6586x_platform_data *pdata; struct of_regulator_match *tps6586x_reg_matches = NULL; int id; int err; dev_dbg(&pdev->dev, "Probing regulator\n"); pdata = dev_get_platdata(pdev->dev.parent); if ((!pdata) && (pdev->dev.parent->of_node)) pdata = tps6586x_parse_regulator_dt(pdev, &tps6586x_reg_matches); if (!pdata) { dev_err(&pdev->dev, "Platform data not available, exiting\n"); return -ENODEV; } rdev = devm_kzalloc(&pdev->dev, TPS6586X_ID_MAX_REGULATOR * sizeof(*rdev), GFP_KERNEL); if (!rdev) { dev_err(&pdev->dev, "Mmemory alloc failed\n"); return -ENOMEM; } for (id = 0; id < TPS6586X_ID_MAX_REGULATOR; ++id) { reg_data = pdata->reg_init_data[id]; ri = find_regulator_info(id); if (!ri) { dev_err(&pdev->dev, "invalid regulator ID specified\n"); err = -EINVAL; goto fail; } err = tps6586x_regulator_preinit(pdev->dev.parent, ri); if (err) { dev_err(&pdev->dev, "regulator %d preinit failed, e %d\n", id, err); goto fail; } config.dev = pdev->dev.parent; config.init_data = reg_data; config.driver_data = ri; if (tps6586x_reg_matches) config.of_node = tps6586x_reg_matches[id].of_node; rdev[id] = regulator_register(&ri->desc, &config); if (IS_ERR(rdev[id])) { dev_err(&pdev->dev, "failed to register regulator %s\n", ri->desc.name); err = PTR_ERR(rdev[id]); goto fail; } if (reg_data) { err = tps6586x_regulator_set_slew_rate(pdev, id, reg_data); if (err < 0) { dev_err(&pdev->dev, "Slew rate config failed, e %d\n", err); regulator_unregister(rdev[id]); goto fail; } } } platform_set_drvdata(pdev, rdev); return 0; fail: while (--id >= 0) regulator_unregister(rdev[id]); return err; }
static int lp8755_probe(struct i2c_client *client, const struct i2c_device_id *id) { int ret, icnt; struct lp8755_chip *pchip; struct lp8755_platform_data *pdata = client->dev.platform_data; if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { dev_err(&client->dev, "i2c functionality check fail.\n"); return -EOPNOTSUPP; } pchip = devm_kzalloc(&client->dev, sizeof(struct lp8755_chip), GFP_KERNEL); if (!pchip) return -ENOMEM; pchip->dev = &client->dev; pchip->regmap = devm_regmap_init_i2c(client, &lp8755_regmap); if (IS_ERR(pchip->regmap)) { ret = PTR_ERR(pchip->regmap); dev_err(&client->dev, "fail to allocate regmap %d\n", ret); return ret; } i2c_set_clientdata(client, pchip); if (pdata != NULL) { pchip->pdata = pdata; pchip->mphase = pdata->mphase; } else { pchip->pdata = devm_kzalloc(pchip->dev, sizeof(struct lp8755_platform_data), GFP_KERNEL); if (!pchip->pdata) return -ENOMEM; ret = lp8755_init_data(pchip); if (ret < 0) { dev_err(&client->dev, "fail to initialize chip\n"); return ret; } } ret = lp8755_regulator_init(pchip); if (ret < 0) { dev_err(&client->dev, "fail to initialize regulators\n"); goto err_regulator; } pchip->irq = client->irq; ret = lp8755_int_config(pchip); if (ret < 0) { dev_err(&client->dev, "fail to irq config\n"); goto err_irq; } return ret; err_irq: for (icnt = 0; icnt < mphase_buck[pchip->mphase].nreg; icnt++) regulator_unregister(pchip->rdev[icnt]); err_regulator: /* output disable */ for (icnt = 0; icnt < LP8755_BUCK_MAX; icnt++) lp8755_write(pchip, icnt, 0x00); return ret; }
static inline struct regulator_dev* rt5746_regulator_register( struct regulator_desc *regulator_desc, struct device *dev, struct regulator_init_data *init_data, void *driver_data) { #if (LINUX_VERSION_CODE>=KERNEL_VERSION(3,5,0)) struct regulator_config config = { .dev = dev, .init_data = init_data, .driver_data = driver_data, .of_node = dev->of_node, }; return regulator_register(®ulator_desc, &config); #elif (LINUX_VERSION_CODE>=KERNEL_VERSION(3,0,0)) return regulator_register(regulator_desc,dev,init_data, driver_data,dev->of_node); #else return regulator_register(regulator_desc,dev,init_data,driver_data); #endif /* LINUX_VERSION_CODE>=KERNEL_VERSION(3,5,0)) */ } static irqreturn_t rt5746_irq_handler(int irqno, void *param) { struct rt5746_regulator_info *ri = param; int regval; int i; if (ri->suspend) { schedule_delayed_work(&ri->irq_dwork, msecs_to_jiffies(50)); goto fin_intr; } regval = rt5746_reg_read(ri->i2c, RT5746_REG_INTACK); if (regval<0) dev_err(ri->dev, "read irq event io fail\n"); else { if (regval == 0) goto fin_intr; regval &= (~rt5746_init_regval[0]); for (i=0; i<RT5746_IRQ_MAX; i++) { if (regval&(1<<i)) { switch (i) { case RT5746_IRQ_PGOOD: dev_err(ri->dev, "pgood event occur\n"); break; case RT5746_IRQ_IDCDC: dev_err(ri->dev, "dcdc over current\n"); break; case RT5746_IRQ_UVLO: dev_err(ri->dev, "uvlo event occur\n"); break; case RT5746_IRQ_TPREW: dev_info(ri->dev, "thermal pre-warning\n"); break; case RT5746_IRQ_TWARN: dev_warn(ri->dev, "thermal warning\n"); break; case RT5746_IRQ_TSD: dev_err(ri->dev, "thermal shutdown\n"); break; default: dev_err(ri->dev, "unrecognized event\n"); break; } } } } fin_intr: return IRQ_HANDLED; } static void rt5746_irq_dwork_func(struct work_struct *work) { struct rt5746_regulator_info *ri = container_of(work, struct rt5746_regulator_info, irq_dwork.work); rt5746_irq_handler(0, ri); } static void rt5746_interrupt_init(struct rt5746_regulator_info *ri) { struct rt5746_platform_data *pdata = ri->dev->platform_data; int rc = (int)0, irq_no = (int)0; if (gpio_is_valid(pdata->irq_gpio)) { rc = gpio_request(pdata->irq_gpio, "rt5746_irq_gpio"); if (rc<0) { dev_err(ri->dev, "gpio request failed\n"); return; } gpio_direction_input(pdata->irq_gpio); irq_no = gpio_to_irq(pdata->irq_gpio); if (irq_no<0) { dev_err(ri->dev, "gpio to irq fail\n"); gpio_free(pdata->irq_gpio); return; } if (devm_request_threaded_irq(ri->dev, irq_no, NULL, rt5746_irq_handler, IRQF_TRIGGER_FALLING|IRQF_NO_SUSPEND|IRQF_DISABLED, "rt5746_irq", ri)) { dev_err(ri->dev, "request irq fail\n"); gpio_free(pdata->irq_gpio); return; } enable_irq_wake(irq_no); schedule_delayed_work(&ri->irq_dwork, msecs_to_jiffies(100)); } else dev_info(ri->dev, "gpio is not valid\n"); } static void rt_parse_dt(struct device *dev) { #ifdef CONFIG_OF struct regulator_init_data *init_data = NULL; struct rt5746_platform_data *pdata = dev->platform_data; struct device_node *np = dev->of_node; int rc; u32 tmp; #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0)) init_data = of_get_regulator_init_data(dev, dev->of_node); #else init_data = of_get_regulator_init_data(dev); #endif /* #if (LINUX_KERNEL_VERSION >= KERNEL_VERSION(3,3,0)) */ pdata->regulator = init_data; rc = of_property_read_u32(np, "rt,standby_uV", &tmp); if (rc<0) dev_info(dev, "no standby voltage setting, use ic default\n"); else pdata->standby_uV = tmp; rc = of_property_read_u32(np, "rt,rampup_sel", &tmp); if (rc) dev_info(dev, "no rampup_sel property, use ic default value\n"); else { if (tmp>RT5746_RAMPUP_MAX) tmp = RT5746_RAMPUP_MAX; pdata->rampup_sel = tmp; } rc = of_property_read_u32(np, "rt,rampdn_sel", &tmp); if (rc) dev_info(dev, "no rampdn_sel property, use ic default value\n"); else { if (tmp>RT5746_RAMPDN_MAX) tmp = RT5746_RAMPDN_MAX; pdata->rampdn_sel = tmp; } rc = of_property_read_u32(np, "rt,ipeak_sel", &tmp); if (rc) dev_info(dev, "no ipeak_sel property, use ic default value\n"); else { if (tmp>RT5746_IPEAK_MAX) tmp = RT5746_IPEAK_MAX; pdata->ipeak_sel = tmp; } rc = of_property_read_u32(np, "rt,tpwth_sel", &tmp); if (rc) dev_info(dev, "no tpwth_sel property, use ic default value\n"); else { if (tmp>RT5746_TPWTH_MAX) tmp = RT5746_TPWTH_MAX; pdata->tpwth_sel = tmp; } if (of_property_read_bool(np, "rt,rearm_en")) pdata->rearm_en = 1; if (of_property_read_bool(np, "rt,discharge_en")) pdata->discharge_en = 1; pdata->irq_gpio = of_get_named_gpio(np, "rt,irq_gpio", 0); #endif /* #ifdef CONFIG_OF */ } static int rt5746_regulator_probe(struct i2c_client *i2c, const struct i2c_device_id *id) { struct rt5746_regulator_info *ri; struct rt5746_platform_data *pdata = i2c->dev.platform_data; struct regulator_dev *rdev; struct regulator_init_data *init_data; bool use_dt = i2c->dev.of_node; int val = 0; int ret = 0; ri = &rt5746_regulator_info; if (use_dt) { pdata = devm_kzalloc(&i2c->dev, sizeof(*pdata), GFP_KERNEL); if (!pdata) { ret = -ENOMEM; goto err_init; } i2c->dev.platform_data = pdata; rt_parse_dt(&i2c->dev); } else { if (!pdata) { ret = -EINVAL; goto err_init; } } init_data = pdata->regulator; if (!init_data) { dev_err(&i2c->dev, "no initializing data\n"); ret = -EINVAL; goto err_init; } mutex_init(&ri->io_lock); INIT_DELAYED_WORK(&ri->irq_dwork, rt5746_irq_dwork_func); ri->i2c = i2c; ri->dev = &i2c->dev; i2c_set_clientdata(i2c, ri); //check ic communication & ic vendor id val = rt5746_reg_read(i2c, RT5746_REG_VID); if (val<0) { ret = -EIO; goto err_init; } else { dev_info(&i2c->dev, "vendor id = %02x\n", val); if (val!=RT5746_VEN_ID) { ret = -EINVAL; goto err_init; } } rt5746_parse_initconfig(pdata); rt5746_register_init(i2c); //interrupt gpio init if (pdata->irq_gpio<0) dev_info(&i2c->dev, "no interrupt irq specified\n"); else rt5746_interrupt_init(ri); rdev = rt5746_regulator_register(&ri->desc, &i2c->dev, init_data, ri); if (IS_ERR(rdev)) { dev_err(&i2c->dev, "failed to register regulator %s\n", ri->desc.name); return PTR_ERR(rdev); } ri->rdev = rdev; //set suspend voltage if (pdata->standby_uV>0) rt5746_set_suspend_voltage(rdev, pdata->standby_uV); rt_dbg_create_attrs(&i2c->dev); dev_info(&i2c->dev, "regulator successfully registered\n"); err_init: return ret; } static int rt5746_regulator_remove(struct i2c_client *i2c) { struct rt5746_regulator_info *ri = i2c_get_clientdata(i2c); regulator_unregister(ri->rdev); dev_info(&i2c->dev, "regulator driver removed\n"); return 0; } static int rt5746_regulator_suspend(struct i2c_client *i2c, pm_message_t mesg) { struct rt5746_regulator_info *ri = i2c_get_clientdata(i2c); ri->suspend = 1; return 0; } static int rt5746_regulator_resume(struct i2c_client *i2c) { struct rt5746_regulator_info *ri = i2c_get_clientdata(i2c); ri->suspend = 0; return 0; } static const struct of_device_id rt_match_table[] = { { .compatible = "richtek,rt5746",}, {}, };
static int __devinit bq2419x_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct bq2419x_chip *bq2419x; struct bq2419x_platform_data *pdata; int ret = 0; pdata = client->dev.platform_data; if (!pdata) { dev_err(&client->dev, "No Platform data"); return -EINVAL; } bq2419x = devm_kzalloc(&client->dev, sizeof(*bq2419x), GFP_KERNEL); if (!bq2419x) { dev_err(&client->dev, "Memory allocation failed\n"); return -ENOMEM; } bq2419x->regmap = devm_regmap_init_i2c(client, &bq2419x_regmap_config); if (IS_ERR(bq2419x->regmap)) { ret = PTR_ERR(bq2419x->regmap); dev_err(&client->dev, "regmap init failed with err %d\n", ret); return ret; } bq2419x->dev = &client->dev; if (pdata->bcharger_pdata) { bq2419x->use_usb = pdata->bcharger_pdata->use_usb; bq2419x->use_mains = pdata->bcharger_pdata->use_mains; bq2419x->update_status = pdata->bcharger_pdata->update_status; bq2419x->rtc_alarm_time = pdata->bcharger_pdata->rtc_alarm_time; bq2419x->wdt_time_sec = pdata->bcharger_pdata->wdt_timeout; bq2419x->chg_restart_time = pdata->bcharger_pdata->chg_restart_time; bq2419x->chg_enable = true; } bq2419x->wdt_refresh_timeout = 25; i2c_set_clientdata(client, bq2419x); bq2419x->irq = client->irq; bq2419x->rtc = alarmtimer_get_rtcdev(); mutex_init(&bq2419x->mutex); bq2419x->suspended = 0; bq2419x->chg_restart_timeout = 0; ret = bq2419x_show_chip_version(bq2419x); if (ret < 0) { dev_err(&client->dev, "version read failed %d\n", ret); return ret; } ret = bq2419x_charger_init(bq2419x); if (ret < 0) { dev_err(bq2419x->dev, "Charger init failed: %d\n", ret); return ret; } ret = bq2419x_init_charger_regulator(bq2419x, pdata); if (ret < 0) { dev_err(&client->dev, "Charger regualtor init failed %d\n", ret); return ret; } ret = bq2419x_psy_init(bq2419x); if (ret < 0) { dev_err(&client->dev, "Charger power supply init failed %d\n", ret); goto scrub_chg_reg; } ret = bq2419x_init_vbus_regulator(bq2419x, pdata); if (ret < 0) { dev_err(&client->dev, "VBUS regualtor init failed %d\n", ret); goto scrub_psy; } init_kthread_worker(&bq2419x->bq_kworker); bq2419x->bq_kworker_task = kthread_run(kthread_worker_fn, &bq2419x->bq_kworker, dev_name(bq2419x->dev)); if (IS_ERR(bq2419x->bq_kworker_task)) { ret = PTR_ERR(bq2419x->bq_kworker_task); dev_err(&client->dev, "Kworker task creation failed %d\n", ret); goto scrub_vbus_reg; } init_kthread_work(&bq2419x->bq_wdt_work, bq2419x_work_thread); sched_setscheduler(bq2419x->bq_kworker_task, SCHED_FIFO, &bq2419x_param); queue_kthread_work(&bq2419x->bq_kworker, &bq2419x->bq_wdt_work); ret = bq2419x_watchdog_init(bq2419x, bq2419x->wdt_time_sec, "PROBE"); if (ret < 0) { dev_err(bq2419x->dev, "BQWDT init failed %d\n", ret); return ret; } ret = bq2419x_fault_clear_sts(bq2419x); if (ret < 0) { dev_err(bq2419x->dev, "fault clear status failed %d\n", ret); return ret; } ret = request_threaded_irq(bq2419x->irq, NULL, bq2419x_irq, IRQF_TRIGGER_FALLING, dev_name(bq2419x->dev), bq2419x); if (ret < 0) { dev_err(bq2419x->dev, "request IRQ %d fail, err = %d\n", bq2419x->irq, ret); goto scrub_kthread; } /* enable charging */ ret = bq2419x_charger_enable(bq2419x); if (ret < 0) goto scrub_irq; return 0; scrub_irq: free_irq(bq2419x->irq, bq2419x); scrub_kthread: bq2419x->stop_thread = true; flush_kthread_worker(&bq2419x->bq_kworker); kthread_stop(bq2419x->bq_kworker_task); scrub_vbus_reg: regulator_unregister(bq2419x->vbus_rdev); scrub_psy: if (bq2419x->use_usb) power_supply_unregister(&bq2419x->usb); if (bq2419x->use_mains) power_supply_unregister(&bq2419x->ac); scrub_chg_reg: regulator_unregister(bq2419x->chg_rdev); mutex_destroy(&bq2419x->mutex); return ret; }
static int __devexit tps6105x_regulator_remove(struct platform_device *pdev) { struct tps6105x *tps6105x = dev_get_platdata(&pdev->dev); regulator_unregister(tps6105x->regulator); return 0; }
static int mc13892_regulator_probe(struct platform_device *pdev) { struct mc13xxx_regulator_priv *priv; struct mc13xxx *mc13892 = dev_get_drvdata(pdev->dev.parent); struct mc13xxx_regulator_platform_data *pdata = dev_get_platdata(&pdev->dev); struct mc13xxx_regulator_init_data *mc13xxx_data; struct regulator_config config = { }; int i, ret; int num_regulators = 0; u32 val; num_regulators = mc13xxx_get_num_regulators_dt(pdev); if (num_regulators <= 0 && pdata) num_regulators = pdata->num_regulators; if (num_regulators <= 0) return -EINVAL; priv = devm_kzalloc(&pdev->dev, sizeof(*priv) + num_regulators * sizeof(priv->regulators[0]), GFP_KERNEL); if (!priv) return -ENOMEM; priv->num_regulators = num_regulators; priv->mc13xxx_regulators = mc13892_regulators; priv->mc13xxx = mc13892; platform_set_drvdata(pdev, priv); mc13xxx_lock(mc13892); ret = mc13xxx_reg_read(mc13892, MC13892_REVISION, &val); if (ret) goto err_unlock; /* enable switch auto mode */ if ((val & 0x0000FFFF) == 0x45d0) { ret = mc13xxx_reg_rmw(mc13892, MC13892_SWITCHERS4, MC13892_SWITCHERS4_SW1MODE_M | MC13892_SWITCHERS4_SW2MODE_M, MC13892_SWITCHERS4_SW1MODE_AUTO | MC13892_SWITCHERS4_SW2MODE_AUTO); if (ret) goto err_unlock; ret = mc13xxx_reg_rmw(mc13892, MC13892_SWITCHERS5, MC13892_SWITCHERS5_SW3MODE_M | MC13892_SWITCHERS5_SW4MODE_M, MC13892_SWITCHERS5_SW3MODE_AUTO | MC13892_SWITCHERS5_SW4MODE_AUTO); if (ret) goto err_unlock; } mc13xxx_unlock(mc13892); mc13892_regulators[MC13892_VCAM].desc.ops->set_mode = mc13892_vcam_set_mode; mc13892_regulators[MC13892_VCAM].desc.ops->get_mode = mc13892_vcam_get_mode; mc13xxx_data = mc13xxx_parse_regulators_dt(pdev, mc13892_regulators, ARRAY_SIZE(mc13892_regulators)); for (i = 0; i < num_regulators; i++) { struct regulator_init_data *init_data; struct regulator_desc *desc; struct device_node *node = NULL; int id; if (mc13xxx_data) { id = mc13xxx_data[i].id; init_data = mc13xxx_data[i].init_data; node = mc13xxx_data[i].node; } else { id = pdata->regulators[i].id; init_data = pdata->regulators[i].init_data; } desc = &mc13892_regulators[id].desc; config.dev = &pdev->dev; config.init_data = init_data; config.driver_data = priv; config.of_node = node; priv->regulators[i] = regulator_register(desc, &config); if (IS_ERR(priv->regulators[i])) { dev_err(&pdev->dev, "failed to register regulator %s\n", mc13892_regulators[i].desc.name); ret = PTR_ERR(priv->regulators[i]); goto err; } } return 0; err: while (--i >= 0) regulator_unregister(priv->regulators[i]); return ret; err_unlock: mc13xxx_unlock(mc13892); return ret; }
static int bq2419x_init_vbus_regulator(struct bq2419x_chip *bq2419x, struct bq2419x_platform_data *pdata) { int ret = 0; if (!pdata->vbus_pdata) { dev_err(bq2419x->dev, "No vbus platform data\n"); return 0; } bq2419x->gpio_otg_iusb = pdata->vbus_pdata->gpio_otg_iusb; bq2419x->vbus_reg_desc.name = "bq2419x-vbus"; bq2419x->vbus_reg_desc.ops = &bq2419x_vbus_ops; bq2419x->vbus_reg_desc.type = REGULATOR_VOLTAGE; bq2419x->vbus_reg_desc.owner = THIS_MODULE; bq2419x->vbus_reg_init_data.supply_regulator = NULL; bq2419x->vbus_reg_init_data.regulator_init = NULL; bq2419x->vbus_reg_init_data.num_consumer_supplies = pdata->vbus_pdata->num_consumer_supplies; bq2419x->vbus_reg_init_data.consumer_supplies = pdata->vbus_pdata->consumer_supplies; bq2419x->vbus_reg_init_data.driver_data = bq2419x; bq2419x->vbus_reg_init_data.constraints.name = "bq2419x-vbus"; bq2419x->vbus_reg_init_data.constraints.min_uV = 0; bq2419x->vbus_reg_init_data.constraints.max_uV = 5000000, bq2419x->vbus_reg_init_data.constraints.valid_modes_mask = REGULATOR_MODE_NORMAL | REGULATOR_MODE_STANDBY; bq2419x->vbus_reg_init_data.constraints.valid_ops_mask = REGULATOR_CHANGE_MODE | REGULATOR_CHANGE_STATUS | REGULATOR_CHANGE_VOLTAGE; if (gpio_is_valid(bq2419x->gpio_otg_iusb)) { ret = gpio_request_one(bq2419x->gpio_otg_iusb, GPIOF_OUT_INIT_HIGH, dev_name(bq2419x->dev)); if (ret < 0) { dev_err(bq2419x->dev, "gpio request failed %d\n", ret); return ret; } } /* Register the regulators */ bq2419x->vbus_rdev = regulator_register(&bq2419x->vbus_reg_desc, bq2419x->dev, &bq2419x->vbus_reg_init_data, bq2419x, NULL); if (IS_ERR(bq2419x->vbus_rdev)) { ret = PTR_ERR(bq2419x->vbus_rdev); dev_err(bq2419x->dev, "VBUS regulator register failed %d\n", ret); goto scrub; } /* Disable the VBUS regulator and enable charging */ ret = bq2419x_charger_enable(bq2419x); if (ret < 0) { dev_err(bq2419x->dev, "Charging enable failed %d", ret); goto scrub_reg; } return ret; scrub_reg: regulator_unregister(bq2419x->vbus_rdev); bq2419x->vbus_rdev = NULL; scrub: if (gpio_is_valid(bq2419x->gpio_otg_iusb)) gpio_free(bq2419x->gpio_otg_iusb); return ret; }
static int __devexit pm8901_vreg_remove(struct platform_device *pdev) { regulator_unregister(pm8901_vreg[pdev->id].rdev); return 0; }
static int __devinit mc13892_regulator_probe(struct platform_device *pdev) { struct mc13xxx_regulator_priv *priv; struct mc13xxx *mc13892 = dev_get_drvdata(pdev->dev.parent); struct mc13xxx_regulator_platform_data *pdata = dev_get_platdata(&pdev->dev); struct mc13xxx_regulator_init_data *init_data; int i, ret; u32 val; priv = kzalloc(sizeof(*priv) + pdata->num_regulators * sizeof(priv->regulators[0]), GFP_KERNEL); if (!priv) return -ENOMEM; priv->mc13xxx_regulators = mc13892_regulators; priv->mc13xxx = mc13892; mc13xxx_lock(mc13892); ret = mc13xxx_reg_read(mc13892, MC13892_REVISION, &val); if (ret) goto err_free; /* enable switch auto mode */ if ((val & 0x0000FFFF) == 0x45d0) { ret = mc13xxx_reg_rmw(mc13892, MC13892_SWITCHERS4, MC13892_SWITCHERS4_SW1MODE_M | MC13892_SWITCHERS4_SW2MODE_M, MC13892_SWITCHERS4_SW1MODE_AUTO | MC13892_SWITCHERS4_SW2MODE_AUTO); if (ret) goto err_free; ret = mc13xxx_reg_rmw(mc13892, MC13892_SWITCHERS5, MC13892_SWITCHERS5_SW3MODE_M | MC13892_SWITCHERS5_SW4MODE_M, MC13892_SWITCHERS5_SW3MODE_AUTO | MC13892_SWITCHERS5_SW4MODE_AUTO); if (ret) goto err_free; } mc13xxx_unlock(mc13892); pax_open_kernel(); *(void **)&mc13892_regulators[MC13892_VCAM].desc.ops->set_mode = mc13892_vcam_set_mode; *(void **)&mc13892_regulators[MC13892_VCAM].desc.ops->get_mode = mc13892_vcam_get_mode; pax_close_kernel(); for (i = 0; i < pdata->num_regulators; i++) { init_data = &pdata->regulators[i]; priv->regulators[i] = regulator_register( &mc13892_regulators[init_data->id].desc, &pdev->dev, init_data->init_data, priv); if (IS_ERR(priv->regulators[i])) { dev_err(&pdev->dev, "failed to register regulator %s\n", mc13892_regulators[i].desc.name); ret = PTR_ERR(priv->regulators[i]); goto err; } } platform_set_drvdata(pdev, priv); return 0; err: while (--i >= 0) regulator_unregister(priv->regulators[i]); err_free: mc13xxx_unlock(mc13892); kfree(priv); return ret; }
static int crystal_cove_pmic_remove(struct platform_device *pdev) { regulator_unregister(platform_get_drvdata(pdev)); return 0; }
static int max17135_regulator_remove(struct platform_device *pdev) { struct regulator_dev *rdev = platform_get_drvdata(pdev); regulator_unregister(rdev); return 0; }
static int rt5033_regulator_probe(struct platform_device *pdev) { struct rt5033_mfd_chip *chip = dev_get_drvdata(pdev->dev.parent); struct rt5033_mfd_platform_data *mfd_pdata = chip->dev->platform_data; const struct rt5033_regulator_platform_data* pdata; const struct rt5033_pmic_irq_handler *irq_handler = NULL; int irq_handler_size = 0; struct rt5033_regulator_info *ri; struct regulator_dev *rdev; struct regulator_init_data* init_data; int ret; dev_info(&pdev->dev, "Richtek RT5033 regulator driver probing (id = %d)...\n", pdev->id); chip_rev = chip->rev_id; #ifdef CONFIG_OF #if (LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)) if (pdev->dev.parent->of_node) { pdev->dev.of_node = of_find_compatible_node( of_node_get(pdev->dev.parent->of_node), NULL, rt5033_regulator_match_table[pdev->id].compatible); } #endif #endif if (pdev->dev.of_node) { dev_info(&pdev->dev, "Use DT...\n"); #if (LINUX_VERSION_CODE>=KERNEL_VERSION(3,1,0)) init_data = of_get_regulator_init_data(&pdev->dev, pdev->dev.of_node); #else init_data = of_get_regulator_init_data(&pdev->dev); #endif if (init_data == NULL) { dev_info(&pdev->dev, "Cannot find DTS data...\n"); init_data = default_rv_pdata.regulator[pdev->id]; } } else { BUG_ON(mfd_pdata == NULL); if (mfd_pdata->regulator_platform_data == NULL) mfd_pdata->regulator_platform_data = &default_rv_pdata; pdata = mfd_pdata->regulator_platform_data; init_data = pdata->regulator[pdev->id]; } ri = find_regulator_info(pdev->id); if (ri == NULL) { dev_err(&pdev->dev, "invalid regulator ID specified\n"); return -EINVAL; } if (init_data == NULL) { dev_err(&pdev->dev, "no initializing data\n"); return -EINVAL; } ri->i2c = chip->i2c_client; ri->chip = chip; chip->regulator_info[pdev->id] = ri; rdev = rt5033_regulator_register(&ri->desc, &pdev->dev, init_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); ret = rt5033_regulator_init_regs(rdev); if (ret<0) goto err_init_device; dev_info(&pdev->dev, "RT5033 Regulator %s driver loaded successfully...\n", rdev->desc->name); switch (pdev->id) { case RT5033_ID_LDO_SAFE: irq_handler = rt5033_pmic_safeldo_irq_handlers; irq_handler_size = ARRAY_SIZE(rt5033_pmic_safeldo_irq_handlers); break; case RT5033_ID_LDO1: irq_handler = rt5033_pmic_ldo_irq_handlers; irq_handler_size = ARRAY_SIZE(rt5033_pmic_ldo_irq_handlers); break; case RT5033_ID_DCDC1: irq_handler = rt5033_pmic_buck_irq_handlers; irq_handler_size = ARRAY_SIZE(rt5033_pmic_buck_irq_handlers); break; default: pr_err("Error : invalid ID\n"); } ret = register_irq(pdev, rdev, irq_handler, irq_handler_size); if (ret < 0) { pr_err("Error : can't register irq\n"); goto err_register_irq; } return 0; err_register_irq: err_init_device: dev_info(&pdev->dev, "RT5033 Regulator %s unregistered...\n", rdev->desc->name); regulator_unregister(rdev); return ret; }
static int __devexit gdsc_remove(struct platform_device *pdev) { struct gdsc *sc = platform_get_drvdata(pdev); regulator_unregister(sc->rdev); return 0; }
static int s2mps16_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 s2mps16_info *s2mps16; int i, ret, delta_sel; unsigned int temp; unsigned int s2mps16_desc_type; unsigned int buck2_temp = 0; ret = sec_reg_read(iodev, S2MPS16_REG_ID, &SEC_PMIC_REV(iodev)); if (ret < 0) return ret; s2mps16_desc_type = S2MPS16_DESC_TYPE0; if (iodev->dev->of_node) { ret = s2mps16_pmic_dt_parse_pdata(iodev, pdata); if (ret) return ret; } if (!pdata) { dev_err(pdev->dev.parent, "Platform data not supplied\n"); return -ENODEV; } s2mps16 = devm_kzalloc(&pdev->dev, sizeof(struct s2mps16_info), GFP_KERNEL); if (!s2mps16) return -ENOMEM; s2mps16->desc_type = s2mps16_desc_type; s2mps16->iodev = iodev; s2mps16->buck11_en = (const char *)of_find_property(iodev->dev->of_node, "buck11_en", NULL); mutex_init(&s2mps16->lock); static_info = s2mps16; s2mps16->dvs_en = pdata->dvs_en; s2mps16->g3d_en = pdata->g3d_en; s2mps16->cache_data = pdata->cache_data; s2mps16->int_max = 0; s2mps16->buck_dvs_on = pdata->buck_dvs_on; if (s2mps16->buck_dvs_on) dev_info(&pdev->dev, "Buck dvs mode enabled \n"); if (gpio_is_valid(pdata->dvs_pin)) { ret = devm_gpio_request(&pdev->dev, pdata->dvs_pin, "S2MPS16 DVS_PIN"); if (ret < 0) return ret; if (pdata->dvs_en) { /* Set DVS Regulator Voltage 0x20 - 0.5 voltage */ ret = sec_reg_write(iodev, S2MPS16_REG_B6CTRL2, 0x20); if (ret < 0) return ret; s2m_init_dvs(); s2mps16->dvs_pin = pdata->dvs_pin; } else dev_err(&pdev->dev, "g3d dvs is not enabled.\n"); } platform_set_drvdata(pdev, s2mps16); 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 = s2mps16; config.of_node = pdata->regulators[i].reg_node; s2mps16->opmode[id] = regulators[s2mps16_desc_type][id].enable_mask; s2mps16->rdev[i] = regulator_register( ®ulators[s2mps16_desc_type][id], &config); if (IS_ERR(s2mps16->rdev[i])) { ret = PTR_ERR(s2mps16->rdev[i]); dev_err(&pdev->dev, "regulator init failed for %d\n", i); s2mps16->rdev[i] = NULL; goto err; } if ((id == S2MPS16_BUCK1 || id == S2MPS16_BUCK2 || id == S2MPS16_BUCK3 || id == S2MPS16_LDO8) && s2mps16->buck_dvs_on) { mutex_lock(&s2mps16->lock); ret = s2m_set_ldo_dvs_control(s2mps16->rdev[i]); if (ret < 0) dev_err(&pdev->dev, "failed vth/delta init, id(%d)\n", id); mutex_unlock(&s2mps16->lock); } } s2mps16->num_regulators = pdata->num_regulators; if (s2mps16->buck_dvs_on) { delta_sel = 0; if (s2mps16->buck2_dvs == 0) delta_sel = 100000; else if (s2mps16->buck2_dvs == 1) delta_sel = 0; else if (s2mps16->buck2_dvs == 2) delta_sel = 75000; else if (s2mps16->buck2_dvs == 3) delta_sel = 50000; else delta_sel = 0; delta_sel = delta_sel / S2MPS16_BUCK_STEP1; /* Read BUCK2_OUT value */ ret = sec_reg_read(iodev, S2MPS16_REG_B2CTRL2, &temp); if (ret < 0) goto err; buck2_temp = temp; /* Check tar_volt+delta range (0x98 means 1250000uV) */ s2mps16->buck2_sync = (temp + delta_sel > 0x98) ? false : true; if (!s2mps16->buck2_sync) { /* Set BUCK2 output voltage 1150000uV */ ret = sec_reg_write(s2mps16->iodev, S2MPS16_REG_B2CTRL2, 0x88); if (ret < 0) goto err; /* Disable buck2 dvs mode */ ret = sec_reg_update(s2mps16->iodev, S2MPS16_REG_LDO7_DVS, 0 << 2, 0x1 << 2); if (ret < 0) goto err; /* Set buck previous target voltage */ ret = sec_reg_write(s2mps16->iodev, S2MPS16_REG_B2CTRL2, buck2_temp); if (ret < 0) goto err; } ret = sec_reg_read(iodev, S2MPS16_REG_LDO7_DVS, &temp); if (ret < 0) goto err; ret = sec_reg_read(iodev, S2MPS16_REG_B4CTRL2, &s2mps16->buck4_sel); if (ret < 0) goto err; ret = sec_reg_read(iodev, S2MPS16_REG_B5CTRL2, &s2mps16->buck5_sel); if (ret < 0) goto err; dev_info(&pdev->dev, "S2MPS16_REG_LDO7_DVS : %8.x \n", temp); dev_info(&pdev->dev, "S2MPS16_REG_B4CTRL2 : %8.x \n", s2mps16->buck4_sel); dev_info(&pdev->dev, "S2MPS16_REG_B5CTRL2 : %8.x \n", s2mps16->buck5_sel); s2mps16->int_max = s2m_get_max_int_voltage(s2mps16); } if (pdata->g3d_en) { /* for buck6 gpio control, disable i2c control */ ret = sec_reg_update(iodev, S2MPS16_REG_B6CTRL1, 0x80, 0xC0); if (ret) { dev_err(&pdev->dev, "buck6 gpio control error\n"); goto err; } if (!s2mps16->buck11_en) { ret = sec_reg_update(iodev, S2MPS16_REG_L11CTRL, 0x00, 0xC0); if (ret) { dev_err(&pdev->dev, "regulator sync enable error\n"); goto err; } } else { /* for buck11 gpio control, disable i2c control */ ret = sec_reg_update(iodev, S2MPS16_REG_B11CTRL1, 0x80, 0xC0); if (ret) { dev_err(&pdev->dev, "buck11 gpio control error\n"); goto err; } } } if (pdata->smpl_warn_en) { ret = sec_reg_update(iodev, S2MPS16_REG_CTRL2, pdata->smpl_warn_vth, 0xe0); if (ret) { dev_err(&pdev->dev, "set smpl_warn configuration i2c write error\n"); goto err; } pr_info("%s: smpl_warn vth is 0x%x\n", __func__, pdata->smpl_warn_vth); ret = sec_reg_update(iodev, S2MPS16_REG_CTRL2, pdata->smpl_warn_hys, 0x18); if (ret) { dev_err(&pdev->dev, "set smpl_warn configuration i2c write error\n"); goto err; } pr_info("%s: smpl_warn hysteresis is 0x%x\n", __func__, pdata->smpl_warn_hys); } /* RTC Low jitter mode */ ret = sec_reg_update(iodev, S2MPS16_REG_RTC_BUF, 0x10, 0x10); if (ret) { dev_err(&pdev->dev, "set low jitter mode i2c write error\n"); goto err; } /* SELMIF set LDO2,4,5,6,8,9,12,13 controlled by PWREN_MIF */ ret = sec_reg_write(iodev, S2MPS16_REG_SELMIF, 0xFF); if (ret) { dev_err(&pdev->dev, "set selmif sel error\n"); goto err; } sec_reg_update(iodev, S2MPS16_REG_B4CTRL1, 0x00, 0x10); ret = sec_reg_write(iodev, 0x9B, 0x10); if (ret) { dev_err(&pdev->dev, "BUCK8, BUCK9 DVS setting failed\n"); goto err; } /* On sequence Config for PWREN_MIF */ sec_reg_write(iodev, 0x70, 0xB4); /* seq. Buck2, Buck1 */ sec_reg_write(iodev, 0x71, 0x2C); /* seq. Buck4, Buck3 */ sec_reg_write(iodev, 0x72, 0xD4); /* seq. Buck6, Buck5 */ sec_reg_write(iodev, 0x73, 0x11); /* seq. Buck8, Buck7 */ sec_reg_write(iodev, 0x74, 0xE0); /* seq. Buck10, Buck9 */ if (s2mps16->buck11_en) sec_reg_write(iodev, 0x75, 0x27); /* seq. BB, Buck11 */ else sec_reg_write(iodev, 0x75, 0x20); sec_reg_write(iodev, 0x76, 0x93); /* seq. LDO2, LDO1 */ sec_reg_write(iodev, 0x77, 0x60); /* Seq. LDO4, LDO3 */ sec_reg_write(iodev, 0x78, 0x87); /* seq. LDO6, LDO5 */ sec_reg_write(iodev, 0x79, pdata->ldo8_7_seq); /* Seq. LDO8, LDO7 */ sec_reg_write(iodev, 0x7A, pdata->ldo10_9_seq); /* Seq. LDO10, LDO9 */ if (s2mps16->buck11_en) sec_reg_write(iodev, 0x7B, 0x50); /* Seq. LDO12, LDO11 */ else sec_reg_write(iodev, 0x7B, 0x57); sec_reg_write(iodev, 0x7C, 0x75); /* Seq. LDO14, LDO13 */ sec_reg_write(iodev, 0x7D, 0x98); /* Seq. LDO16, LDO15 */ sec_reg_write(iodev, 0x7E, 0x00); /* Seq. LDO18, LDO17 */ sec_reg_write(iodev, 0x7F, 0x00); /* Seq. LDO20, LDO19 */ sec_reg_write(iodev, 0x80, 0x21); /* Seq. LDO22, LDO21 */ sec_reg_write(iodev, 0x81, 0x3F); /* Seq. LDO24, LDO23 */ sec_reg_write(iodev, 0x82, 0x00); /* Seq. LDO26, LDO25 */ sec_reg_write(iodev, 0x83, 0x40); /* Seq. B1~B8*/ sec_reg_write(iodev, 0x84, 0x40); /* Seq. B9~B11, BB, LDO1~4 */ sec_reg_write(iodev, 0x85, 0x00); /* Seq. LDO5~12 */ sec_reg_write(iodev, 0x86, 0x0E); /* Seq. LDO13~20 */ sec_reg_write(iodev, 0x87, 0x00); /* Seq. LDO26~21 */ return 0; err: for (i = 0; i < S2MPS16_REGULATOR_MAX; i++) regulator_unregister(s2mps16->rdev[i]); return ret; }
struct regulator_dev *rt5025_regulator_register(struct regulator_desc *regulator_desc, struct device *dev, struct regulator_init_data *init_data, void *driver_data) { #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 5, 0)) struct regulator_config config = { .dev = dev, .init_data = init_data, .driver_data = driver_data, .of_node = dev->of_node, }; return regulator_register(regulator_desc, &config); #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 0, 37)) return regulator_register(regulator_desc, dev, init_data, driver_data, dev->of_node); #else return regulator_register(regulator_desc, dev, init_data, driver_data); #endif /* LINUX_VERSION_CODE>=KERNEL_VERSION(3,5,0)) */ } static struct regulator_init_data *of_parse_dt(struct rt5025_regulator_info *ri, struct device *dev) { struct regulator_init_data *init_data = NULL; #ifdef CONFIG_OF struct device_node *np = dev->of_node; int rc; u32 tmp; #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 3, 0)) init_data = of_get_regulator_init_data(dev, dev->of_node); #else init_data = of_get_regulator_init_data(dev); #endif /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0)) */ rc = of_property_read_u32(np, "rt,ramp_sel", &tmp); if (rc) { dev_info(dev, "no ramp_sel property, use default value\n"); } else { if (tmp > RT5025_DCDCRAMP_MAX) tmp = RT5025_DCDCRAMP_MAX; rt5025_assign_bits(ri->i2c, ri->ramp_reg, ri->ramp_bit, tmp); } if (of_property_read_bool(np, "rt,allow_mode_mask")) { init_data->constraints.valid_modes_mask |= (REGULATOR_MODE_FAST|\ REGULATOR_MODE_NORMAL); init_data->constraints.valid_ops_mask |= REGULATOR_CHANGE_MODE; } #endif /* #ifdef CONFIG_OF */ return init_data; } static int rt5025_regulator_probe(struct platform_device *pdev) { struct rt5025_chip *chip = dev_get_drvdata(pdev->dev.parent); struct rt5025_platform_data *pdata = (pdev->dev.parent)->platform_data; struct rt5025_regulator_info *ri; struct rt5025_regulator_ramp *ramp; struct regulator_dev *rdev; struct regulator_init_data *init_data; bool use_dt = pdev->dev.of_node; ri = find_regulator_info(pdev->id); if (ri == NULL) { dev_err(&pdev->dev, "invalid regulator ID specified\n"); return -EINVAL; } ri->i2c = chip->i2c; if (use_dt) { init_data = of_parse_dt(ri, &pdev->dev); } else { init_data = pdata->regulator[pdev->id]; ramp = init_data->driver_data; if (ramp) rt5025_assign_bits(ri->i2c, ri->ramp_reg, ri->ramp_bit, ramp->ramp_sel); } if (!init_data) { dev_err(&pdev->dev, "no initializing data\n"); return -EINVAL; } rdev = rt5025_regulator_register(&ri->desc, &pdev->dev, init_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); /* dev_info(&pdev->dev, "driver successfully loaded\n");*/ return 0; } static int rt5025_regulator_remove(struct platform_device *pdev) { struct regulator_dev *rdev = platform_get_drvdata(pdev); platform_set_drvdata(pdev, NULL); regulator_unregister(rdev); dev_info(&pdev->dev, "%s\n", __func__); return 0; } static struct of_device_id rt_match_table[] = { { .compatible = "rt,rt5025-dcdc1",}, { .compatible = "rt,rt5025-dcdc2",},
static int __devexit pm8058_xo_buffer_remove(struct platform_device *pdev) { regulator_unregister(pm8058_xo_buffer[pdev->id].rdev); return 0; }
static __devinit int wm831x_isink_probe(struct platform_device *pdev) { struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent); struct wm831x_pdata *pdata = wm831x->dev->platform_data; struct wm831x_isink *isink; int id = pdev->id % ARRAY_SIZE(pdata->isink); struct resource *res; int ret, irq; dev_dbg(&pdev->dev, "Probing ISINK%d\n", id + 1); if (pdata == NULL || pdata->isink[id] == NULL) return -ENODEV; isink = kzalloc(sizeof(struct wm831x_isink), GFP_KERNEL); if (isink == NULL) { dev_err(&pdev->dev, "Unable to allocate private data\n"); return -ENOMEM; } res = platform_get_resource(pdev, IORESOURCE_IO, 0); if (res == NULL) { dev_err(&pdev->dev, "No I/O resource\n"); ret = -EINVAL; goto err; } isink->reg = res->start; /* For current parts this is correct; probably need to revisit * in future. */ snprintf(isink->name, sizeof(isink->name), "ISINK%d", id + 1); isink->desc.name = isink->name; isink->desc.id = id; isink->desc.ops = &wm831x_isink_ops; isink->desc.type = REGULATOR_CURRENT; isink->desc.owner = THIS_MODULE; isink->regulator = regulator_register(&isink->desc, &pdev->dev, pdata->isink[id], isink); if (IS_ERR(isink->regulator)) { ret = PTR_ERR(isink->regulator); dev_err(wm831x->dev, "Failed to register ISINK%d: %d\n", id + 1, ret); goto err; } irq = platform_get_irq(pdev, 0); ret = wm831x_request_irq(wm831x, irq, wm831x_isink_irq, IRQF_TRIGGER_RISING, isink->name, isink); if (ret != 0) { dev_err(&pdev->dev, "Failed to request ISINK IRQ %d: %d\n", irq, ret); goto err_regulator; } platform_set_drvdata(pdev, isink); return 0; err_regulator: regulator_unregister(isink->regulator); err: kfree(isink); return ret; }
static int reg_device_pm_probe(struct platform_device *pdev) { struct regulator_device_pm_config *config; struct regulator_device_pm_data *drvdata; struct regulator_dev *rdev; struct regulator_config cfg = { }; int i, ret; if (pdev->dev.of_node) { config = of_get_regulator_device_pm_config(&pdev->dev); if (IS_ERR(config)) return PTR_ERR(config); } else { config = pdev->dev.platform_data; } if (!config) return -ENOMEM; drvdata = devm_kzalloc(&pdev->dev, sizeof(struct regulator_device_pm_data), GFP_KERNEL); if (!drvdata) return -ENOMEM; drvdata->desc.name = kstrdup(config->supply_name, GFP_KERNEL); if (drvdata->desc.name == NULL) { dev_err(&pdev->dev, "Failed to allocate supply name\n"); return -ENOMEM; } drvdata->desc.type = REGULATOR_VOLTAGE; drvdata->desc.owner = THIS_MODULE; drvdata->desc.ops = &device_pm_voltage_ops; drvdata->desc.n_voltages = config->n_voltages; drvdata->desc.volt_table = config->voltages; drvdata->state_names = config->state_names; drvdata->current_state = 0; drvdata->is_enabled = false; for (i = 0; i < config->n_voltages; i++) { if (config->voltages[i] == 0) { drvdata->disabled_state = i; drvdata->current_state = i; break; } } cfg.dev = &pdev->dev; cfg.init_data = config->init_data; cfg.driver_data = drvdata; cfg.of_node = pdev->dev.of_node; rdev = regulator_register(&drvdata->desc, &cfg); if (IS_ERR(rdev)) { ret = PTR_ERR(rdev); dev_err(&pdev->dev, "Failed to register regulator: %d\n", ret); goto err; } drvdata->dev = rdev; platform_set_drvdata(pdev, drvdata); ret = device_state_pm_set_class(&rdev->dev, config->user_name); if (ret) { dev_err(&pdev->dev, "Failed to register %s to the class\n", config->user_name); goto err_set_class; } return 0; err_set_class: regulator_unregister(rdev); err: kfree(drvdata->desc.name); return ret; }
static __devinit int wm831x_boostp_probe(struct platform_device *pdev) { struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent); struct wm831x_pdata *pdata = wm831x->dev->platform_data; int id = pdev->id % ARRAY_SIZE(pdata->dcdc); struct wm831x_dcdc *dcdc; struct resource *res; int ret, irq; dev_dbg(&pdev->dev, "Probing DCDC%d\n", id + 1); if (pdata == NULL || pdata->dcdc[id] == NULL) return -ENODEV; dcdc = kzalloc(sizeof(struct wm831x_dcdc), GFP_KERNEL); if (dcdc == NULL) { dev_err(&pdev->dev, "Unable to allocate private data\n"); return -ENOMEM; } dcdc->wm831x = wm831x; res = platform_get_resource(pdev, IORESOURCE_IO, 0); if (res == NULL) { dev_err(&pdev->dev, "No I/O resource\n"); ret = -EINVAL; goto err; } dcdc->base = res->start; snprintf(dcdc->name, sizeof(dcdc->name), "DCDC%d", id + 1); dcdc->desc.name = dcdc->name; dcdc->desc.id = id; dcdc->desc.type = REGULATOR_VOLTAGE; dcdc->desc.ops = &wm831x_boostp_ops; dcdc->desc.owner = THIS_MODULE; dcdc->regulator = regulator_register(&dcdc->desc, &pdev->dev, pdata->dcdc[id], dcdc); if (IS_ERR(dcdc->regulator)) { ret = PTR_ERR(dcdc->regulator); dev_err(wm831x->dev, "Failed to register DCDC%d: %d\n", id + 1, ret); goto err; } irq = platform_get_irq_byname(pdev, "UV"); ret = wm831x_request_irq(wm831x, irq, wm831x_dcdc_uv_irq, IRQF_TRIGGER_RISING, dcdc->name, dcdc); if (ret != 0) { dev_err(&pdev->dev, "Failed to request UV IRQ %d: %d\n", irq, ret); goto err_regulator; } platform_set_drvdata(pdev, dcdc); return 0; err_regulator: regulator_unregister(dcdc->regulator); err: kfree(dcdc); return ret; }
static int tps_65023_probe(struct i2c_client *client, const struct i2c_device_id *id) { const struct tps_driver_data *drv_data = (void *)id->driver_data; const struct tps_info *info = drv_data->info; struct regulator_config config = { }; struct regulator_init_data *init_data; struct regulator_dev *rdev; struct tps_pmic *tps; int i; int error; if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA)) return -EIO; /** * init_data points to array of regulator_init structures * coming from the board-evm file. */ init_data = client->dev.platform_data; if (!init_data) return -EIO; tps = devm_kzalloc(&client->dev, sizeof(*tps), GFP_KERNEL); if (!tps) return -ENOMEM; tps->regmap = devm_regmap_init_i2c(client, &tps65023_regmap_config); if (IS_ERR(tps->regmap)) { error = PTR_ERR(tps->regmap); dev_err(&client->dev, "Failed to allocate register map: %d\n", error); return error; } /* common for all regulators */ tps->core_regulator = drv_data->core_regulator; for (i = 0; i < TPS65023_NUM_REGULATOR; i++, info++, init_data++) { /* Store regulator specific information */ tps->info[i] = info; tps->desc[i].name = info->name; tps->desc[i].id = i; tps->desc[i].n_voltages = info->table_len; tps->desc[i].volt_table = info->table; tps->desc[i].ops = (i > TPS65023_DCDC_3 ? &tps65023_ldo_ops : &tps65023_dcdc_ops); tps->desc[i].type = REGULATOR_VOLTAGE; tps->desc[i].owner = THIS_MODULE; tps->desc[i].enable_reg = TPS65023_REG_REG_CTRL; switch (i) { case TPS65023_LDO_1: tps->desc[i].vsel_reg = TPS65023_REG_LDO_CTRL; tps->desc[i].vsel_mask = 0x07; tps->desc[i].enable_mask = 1 << 1; break; case TPS65023_LDO_2: tps->desc[i].vsel_reg = TPS65023_REG_LDO_CTRL; tps->desc[i].vsel_mask = 0x70; tps->desc[i].enable_mask = 1 << 2; break; default: /* DCDCx */ tps->desc[i].enable_mask = 1 << (TPS65023_NUM_REGULATOR - i); tps->desc[i].vsel_reg = TPS65023_REG_DEF_CORE; tps->desc[i].vsel_mask = info->table_len - 1; tps->desc[i].apply_reg = TPS65023_REG_CON_CTRL2; tps->desc[i].apply_bit = TPS65023_REG_CTRL2_GO; } config.dev = &client->dev; config.init_data = init_data; config.driver_data = tps; config.regmap = tps->regmap; /* Register the regulators */ rdev = regulator_register(&tps->desc[i], &config); if (IS_ERR(rdev)) { dev_err(&client->dev, "failed to register %s\n", id->name); error = PTR_ERR(rdev); goto fail; } /* Save regulator for cleanup */ tps->rdev[i] = rdev; } i2c_set_clientdata(client, tps); /* Enable setting output voltage by I2C */ regmap_update_bits(tps->regmap, TPS65023_REG_CON_CTRL2, TPS65023_REG_CTRL2_CORE_ADJ, TPS65023_REG_CTRL2_CORE_ADJ); return 0; fail: while (--i >= 0) regulator_unregister(tps->rdev[i]); return error; }
static void devm_rdev_release(struct device *dev, void *res) { regulator_unregister(*(struct regulator_dev **)res); }
static int tps65217_regulator_probe(struct platform_device *pdev) { struct tps65217 *tps = dev_get_drvdata(pdev->dev.parent); struct tps65217_board *pdata = dev_get_platdata(tps->dev); struct regulator_init_data *reg_data; struct regulator_dev *rdev; struct regulator_config config = { }; int i, ret; if (tps->dev->of_node) pdata = tps65217_parse_dt(pdev); if (!pdata) { dev_err(&pdev->dev, "Platform data not found\n"); return -EINVAL; } if (tps65217_chip_id(tps) != TPS65217) { dev_err(&pdev->dev, "Invalid tps chip version\n"); return -ENODEV; } platform_set_drvdata(pdev, tps); for (i = 0; i < TPS65217_NUM_REGULATOR; i++) { reg_data = pdata->tps65217_init_data[i]; /* * Regulator API handles empty constraints but not NULL * constraints */ if (!reg_data) continue; /* Register the regulators */ config.dev = tps->dev; config.init_data = reg_data; config.driver_data = tps; config.regmap = tps->regmap; if (tps->dev->of_node) config.of_node = pdata->of_node[i]; rdev = regulator_register(®ulators[i], &config); if (IS_ERR(rdev)) { dev_err(tps->dev, "failed to register %s regulator\n", pdev->name); ret = PTR_ERR(rdev); goto err_unregister_regulator; } /* Save regulator for cleanup */ tps->rdev[i] = rdev; } return 0; err_unregister_regulator: while (--i >= 0) regulator_unregister(tps->rdev[i]); return ret; }
static __devinit int sm5703_pmic_probe(struct platform_device *pdev) { struct sm5703_mfd_chip *iodev = dev_get_drvdata(pdev->dev.parent); struct sm5703_mfd_platform_data *pdata = iodev->pdata; struct regulator_config config = { }; struct regulator_dev **rdev; struct sm5703_data *sm5703; struct i2c_client *i2c; int i, ret, size; dev_info(&pdev->dev, "%s\n", __func__); if (!pdata) { pr_info("[%s:%d] !pdata\n", __FILE__, __LINE__); dev_err(pdev->dev.parent, "No platform init data supplied.\n"); return -ENODEV; } if (iodev->dev->of_node) { ret = sm5703_pmic_dt_parse_pdata(pdev, pdata); if (ret) return ret; } sm5703 = devm_kzalloc(&pdev->dev, sizeof(struct sm5703_data), GFP_KERNEL); if (!sm5703) { pr_info("[%s:%d] if (!sm5703)\n", __FILE__, __LINE__); return -ENOMEM; } size = sizeof(struct regulator_dev *) * pdata->num_regulators; sm5703->rdev = devm_kzalloc(&pdev->dev, size, GFP_KERNEL); if (!sm5703->rdev) { pr_info("[%s:%d] if (!sm5703->rdev)\n", __FILE__, __LINE__); kfree(sm5703); return -ENOMEM; } rdev = sm5703->rdev; sm5703->dev = &pdev->dev; sm5703->iodev = iodev; sm5703->num_regulators = pdata->num_regulators; platform_set_drvdata(pdev, sm5703); i2c = sm5703->iodev->i2c_client; pr_info("[%s:%d] pdata->num_regulators:%d\n", __FILE__, __LINE__, pdata->num_regulators); for (i = 0; i < pdata->num_regulators; i++) { const struct voltage_map_desc *desc; int id = pdata->regulators[i].id; pr_info("[%s:%d] for in pdata->num_regulators:%d\n", __FILE__, __LINE__, pdata->num_regulators); desc = reg_voltage_map[id]; if (id == SM5703_SAFEOUT1 || id == SM5703_SAFEOUT2) regulators[id].n_voltages = ARRAY_SIZE(safeoutvolt); config.dev = sm5703->dev; config.init_data = pdata->regulators[i].initdata; config.driver_data = sm5703; config.of_node = pdata->regulators[i].reg_node; rdev[i] = regulator_register(®ulators[id], &config); if (IS_ERR(rdev[i])) { ret = PTR_ERR(rdev[i]); dev_err(sm5703->dev, "regulator init failed for %d\n", id); rdev[i] = NULL; goto err; } } return 0; err: pr_info("[%s:%d] err:\n", __FILE__, __LINE__); for (i = 0; i < sm5703->num_regulators; i++) if (rdev[i]) regulator_unregister(rdev[i]); kfree(sm5703); return ret; }
static int __devinit tps_65023_probe(struct i2c_client *client, const struct i2c_device_id *id) { const struct tps_info *info = (void *)id->driver_data; struct regulator_init_data *init_data; struct regulator_dev *rdev; struct tps_pmic *tps; int i; int error; if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA)) return -EIO; /** * init_data points to array of regulator_init structures * coming from the board-evm file. */ init_data = client->dev.platform_data; if (!init_data) return -EIO; tps = kzalloc(sizeof(*tps), GFP_KERNEL); if (!tps) return -ENOMEM; tps->regmap = regmap_init_i2c(client, &tps65023_regmap_config); if (IS_ERR(tps->regmap)) { error = PTR_ERR(tps->regmap); dev_err(&client->dev, "Failed to allocate register map: %d\n", error); goto fail_alloc; } /* common for all regulators */ tps->client = client; for (i = 0; i < TPS65023_NUM_REGULATOR; i++, info++, init_data++) { /* Store regulator specific information */ tps->info[i] = info; tps->desc[i].name = info->name; tps->desc[i].id = i; tps->desc[i].n_voltages = num_voltages[i]; tps->desc[i].ops = (i > TPS65023_DCDC_3 ? &tps65023_ldo_ops : &tps65023_dcdc_ops); tps->desc[i].type = REGULATOR_VOLTAGE; tps->desc[i].owner = THIS_MODULE; /* Register the regulators */ rdev = regulator_register(&tps->desc[i], &client->dev, init_data, tps); if (IS_ERR(rdev)) { dev_err(&client->dev, "failed to register %s\n", id->name); error = PTR_ERR(rdev); goto fail; } /* Save regulator for cleanup */ tps->rdev[i] = rdev; } i2c_set_clientdata(client, tps); return 0; fail: while (--i >= 0) regulator_unregister(tps->rdev[i]); regmap_exit(tps->regmap); fail_alloc: kfree(tps); return error; }
static int __devexit twlreg_remove(struct platform_device *pdev) { regulator_unregister(platform_get_drvdata(pdev)); return 0; }
static int __devinit rc5t583_regulator_probe(struct platform_device *pdev) { struct rc5t583 *rc5t583 = dev_get_drvdata(pdev->dev.parent); struct rc5t583_platform_data *pdata = dev_get_platdata(rc5t583->dev); struct regulator_init_data *reg_data; struct regulator_config config = { }; struct rc5t583_regulator *reg = NULL; struct rc5t583_regulator *regs; struct regulator_dev *rdev; struct rc5t583_regulator_info *ri; int ret; int id; if (!pdata) { dev_err(&pdev->dev, "No platform data, exiting...\n"); return -ENODEV; } regs = devm_kzalloc(&pdev->dev, RC5T583_REGULATOR_MAX * sizeof(struct rc5t583_regulator), GFP_KERNEL); if (!regs) { dev_err(&pdev->dev, "Memory allocation failed exiting..\n"); return -ENOMEM; } for (id = 0; id < RC5T583_REGULATOR_MAX; ++id) { reg_data = pdata->reg_init_data[id]; /* No need to register if there is no regulator data */ if (!reg_data) continue; reg = ®s[id]; ri = &rc5t583_reg_info[id]; reg->reg_info = ri; reg->mfd = rc5t583; reg->dev = &pdev->dev; if (ri->deepsleep_id == RC5T583_DS_NONE) goto skip_ext_pwr_config; ret = rc5t583_ext_power_req_config(rc5t583->dev, ri->deepsleep_id, pdata->regulator_ext_pwr_control[id], pdata->regulator_deepsleep_slot[id]); /* * Configuring external control is not a major issue, * just give warning. */ if (ret < 0) dev_warn(&pdev->dev, "Failed to configure ext control %d\n", id); skip_ext_pwr_config: config.dev = &pdev->dev; config.init_data = reg_data; config.driver_data = reg; config.regmap = rc5t583->regmap; rdev = regulator_register(&ri->desc, &config); if (IS_ERR(rdev)) { dev_err(&pdev->dev, "Failed to register regulator %s\n", ri->desc.name); ret = PTR_ERR(rdev); goto clean_exit; } reg->rdev = rdev; } platform_set_drvdata(pdev, regs); return 0; clean_exit: while (--id >= 0) regulator_unregister(regs[id].rdev); return ret; }