static int __devinit tps6586x_regulator_probe(struct platform_device *pdev)
{
struct tps6586x_regulator *ri = NULL;
struct regulator_dev *rdev;
int id = pdev->id;
int err;
dev_dbg(&pdev->dev, "Probing regulator %d\n", id);
ri = find_regulator_info(id);
if (ri == NULL) {
dev_err(&pdev->dev, "invalid regulator ID specified\n");
return -EINVAL;
}
err = tps6586x_regulator_preinit(pdev->dev.parent, ri);
if (err)
return err;
rdev = regulator_register(&ri->desc, &pdev->dev,
pdev->dev.platform_data, ri, NULL);
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 tps6586x_regulator_set_slew_rate(pdev);
}
static int __devinit da903x_regulator_probe(struct platform_device *pdev)
{
struct da903x_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;
}
/* Workaround for the weird LDO12 voltage setting */
if (ri->desc.id == DA9034_ID_LDO12)
ri->desc.ops = &da9034_regulator_ldo12_ops;
if (ri->desc.id == DA9030_ID_LDO14)
ri->desc.ops = &da9030_regulator_ldo14_ops;
if (ri->desc.id == DA9030_ID_LDO1 || ri->desc.id == DA9030_ID_LDO15)
ri->desc.ops = &da9030_regulator_ldo1_15_ops;
rdev = regulator_register(&ri->desc, pdev->dev.parent, 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 max8925_regulator_probe(struct platform_device *pdev)
{
struct max8925_chip *chip = dev_get_drvdata(pdev->dev.parent);
struct max8925_platform_data *pdata = chip->dev->platform_data;
struct max8925_regulator_info *ri;
struct regulator_dev *rdev;
ri = find_regulator_info(pdev->id);
if (ri == NULL) {
dev_err(&pdev->dev, "invalid regulator ID specified\n");
return -EINVAL;
}
ri->i2c = chip->i2c;
ri->chip = chip;
rdev = regulator_register(&ri->desc, &pdev->dev,
pdata->regulator[pdev->id], 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 axp_regulator_probe(struct platform_device *pdev)
{
struct axp_regulator_info *ri = NULL;
struct regulator_dev *rdev;
int ret;
ri = find_regulator_info(pdev->id);
if (ri == NULL) {
dev_err(&pdev->dev, "invalid regulator ID specified\n");
return -EINVAL;
}
if (ri->desc.id == AXP15_ID_LDO4 || ri->desc.id == AXP15_ID_LDO5 \
||ri->desc.id == AXP15_ID_DCDC2 \
||ri->desc.id == AXP15_ID_DCDC3 ||ri->desc.id == AXP15_ID_DCDC4 \
||ri->desc.id == AXP15_ID_LDO1 ||ri->desc.id == AXP15_ID_LDOIO0)
{
ri->desc.ops = &axp15_ops;
printk("Register AXP15_OPS sucess!\n");
}
if(ri->desc.id == AXP15_ID_LDO0)
{
ri->desc.ops = &axp15_ldo0_ops;
printk("Register AXP15_ldo0_OPS finish!\n");
}
if(ri->desc.id == AXP15_ID_LDO3 || ri->desc.id == AXP15_ID_LDO2)
{
ri->desc.ops = &axp15_aldo12_ops;
printk("Register AXP15_aldo12_OPS finish!\n");
}
if(ri->desc.id == AXP15_ID_DCDC1)
{
ri->desc.ops = &axp15_dcdc1_ops;
printk("Register AXP15_dcdc1_OPS finish!\n");
}
rdev = regulator_register(&ri->desc, &pdev->dev,
pdev->dev.platform_data, ri, NULL);
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);
if(ri->desc.id == AXP15_ID_DCDC1 ||ri->desc.id == AXP15_ID_DCDC2 \
||ri->desc.id == AXP15_ID_DCDC3 ||ri->desc.id == AXP15_ID_DCDC4){
ret = axp_regu_create_attrs(pdev);
if(ret){
return ret;
}
}
return 0;
}
static int __devinit tps6591x_regulator_probe(struct platform_device *pdev)
{
struct tps6591x_regulator *ri = NULL;
struct regulator_dev *rdev;
struct tps6591x_regulator_platform_data *tps_pdata;
int id = pdev->id;
int err;
dev_dbg(&pdev->dev, "Probing reulator %d\n", id);
ri = find_regulator_info(id);
if (ri == NULL) {
dev_err(&pdev->dev, "invalid regulator ID specified\n");
return -EINVAL;
}
tps_pdata = pdev->dev.platform_data;
ri->ectrl = tps_pdata->ectrl;
ri->config_flags = tps_pdata->flags;
ri->shutdown_state_off = tps_pdata->shutdown_state_off;
if (tps_pdata->slew_rate_uV_per_us)
ri->voltage_change_uv_per_us = tps_pdata->slew_rate_uV_per_us;
err = tps6591x_cache_regulator_register(pdev->dev.parent, ri);
if (err) {
dev_err(&pdev->dev, "Error in caching registers error %d\n",
err);
return err;
}
err = tps6591x_regulator_preinit(pdev->dev.parent, ri, tps_pdata);
if (err) {
dev_err(&pdev->dev, "Error in pre-initialization of regulator "
"error %d\n", err);
return err;
}
rdev = regulator_register(&ri->desc, &pdev->dev,
&tps_pdata->regulator, ri);
if (IS_ERR_OR_NULL(rdev)) {
dev_err(&pdev->dev, "failed to register regulator %s\n",
ri->desc.name);
return PTR_ERR(rdev);
}
ri->current_volt_uv = ri->desc.ops->get_voltage(rdev);
platform_set_drvdata(pdev, rdev);
return 0;
}
static int ricoh61x_regulator_probe(struct platform_device *pdev)
{
struct ricoh61x_regulator *ri = NULL;
struct regulator_dev *rdev;
struct ricoh619_regulator_platform_data *tps_pdata;
int id = pdev->id;
int err;
ri = find_regulator_info(id);
if (ri == NULL) {
dev_err(&pdev->dev, "invalid regulator ID specified\n");
return -EINVAL;
}
tps_pdata = pdev->dev.platform_data;
ri->dev = &pdev->dev;
ricoh61x_suspend_status = 0;
err = ricoh61x_cache_regulator_register(pdev->dev.parent, ri);
if (err) {
dev_err(&pdev->dev, "Fail in caching register\n");
return err;
}
err = ricoh61x_regulator_preinit(pdev->dev.parent, ri, tps_pdata);
if (err) {
dev_err(&pdev->dev, "Fail in pre-initialisation\n");
return err;
}
ricoh61x_regulator_config.dev = &pdev->dev;
ricoh61x_regulator_config.init_data = &tps_pdata->regulator;
ricoh61x_regulator_config.driver_data = ri;
rdev = regulator_register(&ri->desc, &ricoh61x_regulator_config);
if (IS_ERR_OR_NULL(rdev)) {
dev_err(&pdev->dev, "failed to register regulator %s\n",
ri->desc.name);
return PTR_ERR(rdev);
}
platform_set_drvdata(pdev, rdev);
if (rdev && tps_pdata->init_enable && ri->desc.ops->is_enabled(rdev)) {
rdev->use_count++;
}
return 0;
}
static int __devinit axp_regulator_probe(struct platform_device *pdev)
{
struct axp_regulator_info *ri = NULL;
struct regulator_dev *rdev;
int ret;
struct regulator_config config;
ri = find_regulator_info(pdev->id);
if (ri == NULL) {
dev_err(&pdev->dev, "invalid regulator ID specified\n");
return -EINVAL;
}
if (ri->desc.id == AXP20_ID_LDO1 || ri->desc.id == AXP20_ID_LDO2 \
|| ri->desc.id == AXP20_ID_LDO3 || ri->desc.id == AXP20_ID_BUCK2 \
||ri->desc.id == AXP20_ID_BUCK3)
ri->desc.ops = &axp20_ops;
if(ri->desc.id == AXP20_ID_LDO4)
ri->desc.ops = &axp20_ldo4_ops;
if(ri->desc.id == AXP20_ID_LDOIO0)
ri->desc.ops = &axp20_ldoio0_ops;
config.dev = &pdev->dev;
config.init_data = pdev->dev.platform_data;
config.driver_data = dev_get_drvdata(&pdev->dev);
config.regmap = NULL;
rdev = regulator_register(&ri->desc, &config);
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);
if(ri->desc.id == AXP20_ID_BUCK2 ||ri->desc.id == AXP20_ID_BUCK3) {
ret = axp_regu_create_attrs(pdev);
if(ret) {
return ret;
}
}
return 0;
}
static int ricoh619_regulator_probe(struct platform_device *pdev)
{
struct ricoh619_regulator *ri = NULL;
struct regulator_dev *rdev;
struct regulator_config config = { };
int err,id=0;
rdev = devm_kzalloc(&pdev->dev, RICOH619_NUM_REGULATOR *
sizeof(*rdev), GFP_KERNEL);
if (!rdev) {
dev_err(&pdev->dev, "Mmemory alloc failed\n");
return -ENOMEM;
}
for (id = 0; id < RICOH619_NUM_REGULATOR; ++id) {
ri = find_regulator_info(id);
if (!ri) {
dev_err(&pdev->dev, "invalid regulator ID specified\n");
err = -EINVAL;
}
ri->dev = &pdev->dev;
config.dev = &pdev->dev;
config.driver_data = ri;
config.of_node = ricoh619_regulator_matches[id].of_node;
err = ricoh619_regulator_dt_init(pdev, &config, id);
if (err < 0) {
dev_err(&pdev->dev, "failed to regulator dt init\n");
}
rdev = regulator_register(&ri->desc, &config);
if (IS_ERR_OR_NULL(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 axp_regulator_probe(struct platform_device *pdev)
{
struct axp_regulator_info *ri = NULL;
struct regulator_dev *rdev;
int ret;
ri = find_regulator_info(pdev->id);
if (ri == NULL) {
dev_err(&pdev->dev, "invalid regulator ID specified\n");
return -EINVAL;
}
if (ri->desc.id == AXP18_ID_LDO1 || ri->desc.id == AXP18_ID_LDO2 \
|| ri->desc.id == AXP18_ID_LDO3 || ri->desc.id == AXP18_ID_LDO4 \
|| ri->desc.id == AXP18_ID_LDO5 || ri->desc.id == AXP18_ID_BUCK1 \
|| ri->desc.id == AXP18_ID_BUCK2 || ri->desc.id == AXP18_ID_BUCK3 \
|| ri->desc.id == AXP18_ID_SW1 || ri->desc.id == AXP18_ID_SW2)
ri->desc.ops = &axp18_ops;
if(ri->desc.id == AXP18_ID_LDO5)
ri->desc.n_voltages = ARRAY_SIZE(axp18_ldo5_data);
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);
if(ri->desc.id == AXP18_ID_BUCK1 || ri->desc.id == AXP18_ID_BUCK2 \
||ri->desc.id == AXP18_ID_BUCK3) {
ret = axp_regu_create_attrs(pdev);
if(ret) {
return ret;
}
}
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 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;
pr_info("Richtek RT5033 regulator driver probing...\n");
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;
ri = find_regulator_info(pdev->id);
if (ri == NULL) {
dev_err(&pdev->dev, "invalid regulator ID specified\n");
return -EINVAL;
}
init_data = pdata->regulator[pdev->id];
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;
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:
regulator_unregister(rdev);
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;
}
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 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;
}
