drivers/regulator/tps6586x-regulator.c

   1 /*
   2  * Regulator driver for TI TPS6586x
   3  *
   4  * Copyright (C) 2010 Compulab Ltd.
   5  * Author: Mike Rapoport <mike@compulab.co.il>
   6  *
   7  * Based on da903x
   8  * Copyright (C) 2006-2008 Marvell International Ltd.
   9  * Copyright (C) 2008 Compulab Ltd.
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License version 2 as
  13  * published by the Free Software Foundation.
  14  */
  15
  16 #include <linux/kernel.h>
  17 #include <linux/module.h>
  18 #include <linux/init.h>
  19 #include <linux/err.h>
  20 #include <linux/of.h>
  21 #include <linux/slab.h>
  22 #include <linux/platform_device.h>
  23 #include <linux/regulator/driver.h>
  24 #include <linux/regulator/machine.h>
  25 #include <linux/regulator/of_regulator.h>
  26 #include <linux/mfd/tps6586x.h>
  27
  28 /* supply control and voltage setting  */
  29 #define TPS6586X_SUPPLYENA      0x10
  30 #define TPS6586X_SUPPLYENB      0x11
  31 #define TPS6586X_SUPPLYENC      0x12
  32 #define TPS6586X_SUPPLYEND      0x13
  33 #define TPS6586X_SUPPLYENE      0x14
  34 #define TPS6586X_VCC1           0x20
  35 #define TPS6586X_VCC2           0x21
  36 #define TPS6586X_SM1V1          0x23
  37 #define TPS6586X_SM1V2          0x24
  38 #define TPS6586X_SM1SL          0x25
  39 #define TPS6586X_SM0V1          0x26
  40 #define TPS6586X_SM0V2          0x27
  41 #define TPS6586X_SM0SL          0x28
  42 #define TPS6586X_LDO2AV1        0x29
  43 #define TPS6586X_LDO2AV2        0x2A
  44 #define TPS6586X_LDO2BV1        0x2F
  45 #define TPS6586X_LDO2BV2        0x30
  46 #define TPS6586X_LDO4V1         0x32
  47 #define TPS6586X_LDO4V2         0x33
  48
  49 /* converter settings  */
  50 #define TPS6586X_SUPPLYV1       0x41
  51 #define TPS6586X_SUPPLYV2       0x42
  52 #define TPS6586X_SUPPLYV3       0x43
  53 #define TPS6586X_SUPPLYV4       0x44
  54 #define TPS6586X_SUPPLYV5       0x45
  55 #define TPS6586X_SUPPLYV6       0x46
  56 #define TPS6586X_SMODE1         0x47
  57 #define TPS6586X_SMODE2         0x48
  58
  59 struct tps6586x_regulator {
  60         struct regulator_desc desc;
  61
  62         int enable_bit[2];
  63         int enable_reg[2];
  64 };
  65
  66 static struct regulator_ops tps6586x_rw_regulator_ops = {
  67         .list_voltage = regulator_list_voltage_table,
  68         .map_voltage = regulator_map_voltage_ascend,
  69         .get_voltage_sel = regulator_get_voltage_sel_regmap,
  70         .set_voltage_sel = regulator_set_voltage_sel_regmap,
  71
  72         .is_enabled = regulator_is_enabled_regmap,
  73         .enable = regulator_enable_regmap,
  74         .disable = regulator_disable_regmap,
  75 };
  76
  77 static struct regulator_ops tps6586x_rw_linear_regulator_ops = {
  78         .list_voltage = regulator_list_voltage_linear,
  79         .get_voltage_sel = regulator_get_voltage_sel_regmap,
  80         .set_voltage_sel = regulator_set_voltage_sel_regmap,
  81
  82         .is_enabled = regulator_is_enabled_regmap,
  83         .enable = regulator_enable_regmap,
  84         .disable = regulator_disable_regmap,
  85 };
  86
  87 static struct regulator_ops tps6586x_ro_regulator_ops = {
  88         .list_voltage = regulator_list_voltage_table,
  89         .map_voltage = regulator_map_voltage_ascend,
  90         .get_voltage_sel = regulator_get_voltage_sel_regmap,
  91
  92         .is_enabled = regulator_is_enabled_regmap,
  93         .enable = regulator_enable_regmap,
  94         .disable = regulator_disable_regmap,
  95 };
  96
  97 static struct regulator_ops tps6586x_sys_regulator_ops = {
  98 };
  99
 100 static const unsigned int tps6586x_ldo0_voltages[] = {
 101         1200000, 1500000, 1800000, 2500000, 2700000, 2850000, 3100000, 3300000,
 102 };
 103
 104 static const unsigned int tps6586x_ldo_voltages[] = {
 105         1250000, 1500000, 1800000, 2500000, 2700000, 2850000, 3100000, 3300000,
 106 };
 107
 108 static const unsigned int tps658640_rtc_voltages[] = {
 109         2500000, 2850000, 3100000, 3300000,
 110 };
 111
 112 #define TPS6586X_REGULATOR(_id, _ops, _pin_name, vdata, vreg, shift, nbits, \
 113                            ereg0, ebit0, ereg1, ebit1, goreg, gobit)    \
 114         .desc   = {                                                     \
 115                 .supply_name = _pin_name,                               \
 116                 .name   = "REG-" #_id,                                  \
 117                 .ops    = &tps6586x_## _ops ## _regulator_ops,          \
 118                 .type   = REGULATOR_VOLTAGE,                            \
 119                 .id     = TPS6586X_ID_##_id,                            \
 120                 .n_voltages = ARRAY_SIZE(vdata##_voltages),             \
 121                 .volt_table = vdata##_voltages,                         \
 122                 .owner  = THIS_MODULE,                                  \
 123                 .enable_reg = TPS6586X_SUPPLY##ereg0,                   \
 124                 .enable_mask = 1 << (ebit0),                            \
 125                 .vsel_reg = TPS6586X_##vreg,                            \
 126                 .vsel_mask = ((1 << (nbits)) - 1) << (shift),           \
 127                 .apply_reg = (goreg),                           \
 128                 .apply_bit = (gobit),                           \
 129         },                                                              \
 130         .enable_reg[0]  = TPS6586X_SUPPLY##ereg0,                       \
 131         .enable_bit[0]  = (ebit0),                                      \
 132         .enable_reg[1]  = TPS6586X_SUPPLY##ereg1,                       \
 133         .enable_bit[1]  = (ebit1),
 134
 135 #define TPS6586X_REGULATOR_LINEAR(_id, _ops, _pin_name, n_volt, min_uv, \
 136                                   uv_step, vreg, shift, nbits, ereg0,   \
 137                                   ebit0, ereg1, ebit1, goreg, gobit)    \
 138         .desc   = {                                                     \
 139                 .supply_name = _pin_name,                               \
 140                 .name   = "REG-" #_id,                                  \
 141                 .ops    = &tps6586x_## _ops ## _regulator_ops,          \
 142                 .type   = REGULATOR_VOLTAGE,                            \
 143                 .id     = TPS6586X_ID_##_id,                            \
 144                 .n_voltages = n_volt,                                   \
 145                 .min_uV = min_uv,                                       \
 146                 .uV_step = uv_step,                                     \
 147                 .owner  = THIS_MODULE,                                  \
 148                 .enable_reg = TPS6586X_SUPPLY##ereg0,                   \
 149                 .enable_mask = 1 << (ebit0),                            \
 150                 .vsel_reg = TPS6586X_##vreg,                            \
 151                 .vsel_mask = ((1 << (nbits)) - 1) << (shift),           \
 152                 .apply_reg = (goreg),                           \
 153                 .apply_bit = (gobit),                           \
 154         },                                                              \
 155         .enable_reg[0]  = TPS6586X_SUPPLY##ereg0,                       \
 156         .enable_bit[0]  = (ebit0),                                      \
 157         .enable_reg[1]  = TPS6586X_SUPPLY##ereg1,                       \
 158         .enable_bit[1]  = (ebit1),
 159
 160 #define TPS6586X_LDO(_id, _pname, vdata, vreg, shift, nbits,            \
 161                      ereg0, ebit0, ereg1, ebit1)                        \
 162 {                                                                       \
 163         TPS6586X_REGULATOR(_id, rw, _pname, vdata, vreg, shift, nbits,  \
 164                            ereg0, ebit0, ereg1, ebit1, 0, 0)            \
 165 }
 166
 167 #define TPS6586X_LDO_LINEAR(_id, _pname, n_volt, min_uv, uv_step, vreg, \
 168                             shift, nbits, ereg0, ebit0, ereg1, ebit1)   \
 169 {                                                                       \
 170         TPS6586X_REGULATOR_LINEAR(_id, rw_linear, _pname, n_volt,       \
 171                                   min_uv, uv_step, vreg, shift, nbits,  \
 172                                   ereg0, ebit0, ereg1, ebit1, 0, 0)     \
 173 }
 174
 175 #define TPS6586X_FIXED_LDO(_id, _pname, vdata, vreg, shift, nbits,      \
 176                           ereg0, ebit0, ereg1, ebit1)                   \
 177 {                                                                       \
 178         TPS6586X_REGULATOR(_id, ro, _pname, vdata, vreg, shift, nbits,  \
 179                            ereg0, ebit0, ereg1, ebit1, 0, 0)            \
 180 }
 181
 182 #define TPS6586X_DVM(_id, _pname, n_volt, min_uv, uv_step, vreg, shift, \
 183                      nbits, ereg0, ebit0, ereg1, ebit1, goreg, gobit)   \
 184 {                                                                       \
 185         TPS6586X_REGULATOR_LINEAR(_id, rw_linear, _pname, n_volt,       \
 186                                   min_uv, uv_step, vreg, shift, nbits,  \
 187                                   ereg0, ebit0, ereg1, ebit1, goreg,    \
 188                                   gobit)                                \
 189 }
 190
 191 #define TPS6586X_SYS_REGULATOR()                                        \
 192 {                                                                       \
 193         .desc   = {                                                     \
 194                 .supply_name = "sys",                                   \
 195                 .name   = "REG-SYS",                                    \
 196                 .ops    = &tps6586x_sys_regulator_ops,                  \
 197                 .type   = REGULATOR_VOLTAGE,                            \
 198                 .id     = TPS6586X_ID_SYS,                              \
 199                 .owner  = THIS_MODULE,                                  \
 200         },                                                              \
 201 }
 202
 203 static struct tps6586x_regulator tps6586x_regulator[] = {
 204         TPS6586X_SYS_REGULATOR(),
 205         TPS6586X_LDO(LDO_0, "vinldo01", tps6586x_ldo0, SUPPLYV1, 5, 3, ENC, 0,
 206                                         END, 0),
 207         TPS6586X_LDO(LDO_3, "vinldo23", tps6586x_ldo, SUPPLYV4, 0, 3, ENC, 2,
 208                                         END, 2),
 209         TPS6586X_LDO(LDO_5, "REG-SYS", tps6586x_ldo, SUPPLYV6, 0, 3, ENE, 6,
 210                                         ENE, 6),
 211         TPS6586X_LDO(LDO_6, "vinldo678", tps6586x_ldo, SUPPLYV3, 0, 3, ENC, 4,
 212                                         END, 4),
 213         TPS6586X_LDO(LDO_7, "vinldo678", tps6586x_ldo, SUPPLYV3, 3, 3, ENC, 5,
 214                                         END, 5),
 215         TPS6586X_LDO(LDO_8, "vinldo678", tps6586x_ldo, SUPPLYV2, 5, 3, ENC, 6,
 216                                         END, 6),
 217         TPS6586X_LDO(LDO_9, "vinldo9", tps6586x_ldo, SUPPLYV6, 3, 3, ENE, 7,
 218                                         ENE, 7),
 219         TPS6586X_LDO(LDO_RTC, "REG-SYS", tps6586x_ldo, SUPPLYV4, 3, 3, V4, 7,
 220                                         V4, 7),
 221         TPS6586X_LDO_LINEAR(LDO_1, "vinldo01", 32, 725000, 25000, SUPPLYV1,
 222                             0, 5, ENC, 1, END, 1),
 223         TPS6586X_LDO_LINEAR(SM_2, "vin-sm2", 32, 3000000, 50000, SUPPLYV2,
 224                             0, 5, ENC, 7, END, 7),
 225         TPS6586X_DVM(LDO_2, "vinldo23", 32, 725000, 25000, LDO2BV1, 0, 5,
 226                      ENA, 3, ENB, 3, TPS6586X_VCC2, BIT(6)),
 227         TPS6586X_DVM(LDO_4, "vinldo4", 32, 1700000, 25000, LDO4V1, 0, 5,
 228                      ENC, 3, END, 3, TPS6586X_VCC1, BIT(6)),
 229         TPS6586X_DVM(SM_0, "vin-sm0", 32, 725000, 25000, SM0V1, 0, 5,
 230                      ENA, 1, ENB, 1, TPS6586X_VCC1, BIT(2)),
 231         TPS6586X_DVM(SM_1, "vin-sm1", 32, 725000, 25000, SM1V1, 0, 5,
 232                      ENA, 0, ENB, 0, TPS6586X_VCC1, BIT(0)),
 233 };
 234
 235 static struct tps6586x_regulator tps658623_regulator[] = {
 236         TPS6586X_LDO_LINEAR(SM_2, "vin-sm2", 32, 1700000, 25000, SUPPLYV2,
 237                             0, 5, ENC, 7, END, 7),
 238 };
 239
 240 static struct tps6586x_regulator tps658640_regulator[] = {
 241         TPS6586X_LDO(LDO_3, "vinldo23", tps6586x_ldo0, SUPPLYV4, 0, 3,
 242                                         ENC, 2, END, 2),
 243         TPS6586X_LDO(LDO_5, "REG-SYS", tps6586x_ldo0, SUPPLYV6, 0, 3,
 244                                         ENE, 6, ENE, 6),
 245         TPS6586X_LDO(LDO_6, "vinldo678", tps6586x_ldo0, SUPPLYV3, 0, 3,
 246                                         ENC, 4, END, 4),
 247         TPS6586X_LDO(LDO_7, "vinldo678", tps6586x_ldo0, SUPPLYV3, 3, 3,
 248                                         ENC, 5, END, 5),
 249         TPS6586X_LDO(LDO_8, "vinldo678", tps6586x_ldo0, SUPPLYV2, 5, 3,
 250                                         ENC, 6, END, 6),
 251         TPS6586X_LDO(LDO_9, "vinldo9", tps6586x_ldo0, SUPPLYV6, 3, 3,
 252                                         ENE, 7, ENE, 7),
 253         TPS6586X_LDO_LINEAR(SM_2, "vin-sm2", 32, 2150000, 50000, SUPPLYV2,
 254                             0, 5, ENC, 7, END, 7),
 255
 256         TPS6586X_FIXED_LDO(LDO_RTC, "REG-SYS", tps658640_rtc, SUPPLYV4, 3, 2,
 257                                         V4, 7, V4, 7),
 258 };
 259
 260 static struct tps6586x_regulator tps658643_regulator[] = {
 261         TPS6586X_LDO_LINEAR(SM_2, "vin-sm2", 32, 1025000, 25000, SUPPLYV2,
 262                             0, 5, ENC, 7, END, 7),
 263 };
 264
 265 /*
 266  * TPS6586X has 2 enable bits that are OR'ed to determine the actual
 267  * regulator state. Clearing one of this bits allows switching
 268  * regulator on and of with single register write.
 269  */
 270 static inline int tps6586x_regulator_preinit(struct device *parent,
 271                                              struct tps6586x_regulator *ri)
 272 {
 273         uint8_t val1, val2;
 274         int ret;
 275
 276         if (ri->enable_reg[0] == ri->enable_reg[1] &&
 277             ri->enable_bit[0] == ri->enable_bit[1])
 278                         return 0;
 279
 280         ret = tps6586x_read(parent, ri->enable_reg[0], &val1);
 281         if (ret)
 282                 return ret;
 283
 284         ret = tps6586x_read(parent, ri->enable_reg[1], &val2);
 285         if (ret)
 286                 return ret;
 287
 288         if (!(val2 & (1 << ri->enable_bit[1])))
 289                 return 0;
 290
 291         /*
 292          * The regulator is on, but it's enabled with the bit we don't
 293          * want to use, so we switch the enable bits
 294          */
 295         if (!(val1 & (1 << ri->enable_bit[0]))) {
 296                 ret = tps6586x_set_bits(parent, ri->enable_reg[0],
 297                                         1 << ri->enable_bit[0]);
 298                 if (ret)
 299                         return ret;
 300         }
 301
 302         return tps6586x_clr_bits(parent, ri->enable_reg[1],
 303                                  1 << ri->enable_bit[1]);
 304 }
 305
 306 static int tps6586x_regulator_set_slew_rate(struct platform_device *pdev,
 307                         int id, struct regulator_init_data *p)
 308 {
 309         struct device *parent = pdev->dev.parent;
 310         struct tps6586x_settings *setting = p->driver_data;
 311         uint8_t reg;
 312
 313         if (setting == NULL)
 314                 return 0;
 315
 316         if (!(setting->slew_rate & TPS6586X_SLEW_RATE_SET))
 317                 return 0;
 318
 319         /* only SM0 and SM1 can have the slew rate settings */
 320         switch (id) {
 321         case TPS6586X_ID_SM_0:
 322                 reg = TPS6586X_SM0SL;
 323                 break;
 324         case TPS6586X_ID_SM_1:
 325                 reg = TPS6586X_SM1SL;
 326                 break;
 327         default:
 328                 dev_err(&pdev->dev, "Only SM0/SM1 can set slew rate\n");
 329                 return -EINVAL;
 330         }
 331
 332         return tps6586x_write(parent, reg,
 333                         setting->slew_rate & TPS6586X_SLEW_RATE_MASK);
 334 }
 335
 336 static struct tps6586x_regulator *find_regulator_info(int id, int version)
 337 {
 338         struct tps6586x_regulator *ri;
 339         struct tps6586x_regulator *table = NULL;
 340         int num;
 341         int i;
 342
 343         switch (version) {
 344         case TPS658623:
 345                 table = tps658623_regulator;
 346                 num = ARRAY_SIZE(tps658623_regulator);
 347                 break;
 348         case TPS658640:
 349         case TPS658640v2:
 350                 table = tps658640_regulator;
 351                 num = ARRAY_SIZE(tps658640_regulator);
 352                 break;
 353         case TPS658643:
 354                 table = tps658643_regulator;
 355                 num = ARRAY_SIZE(tps658643_regulator);
 356                 break;
 357         }
 358
 359         /* Search version specific table first */
 360         if (table) {
 361                 for (i = 0; i < num; i++) {
 362                         ri = &table[i];
 363                         if (ri->desc.id == id)
 364                                 return ri;
 365                 }
 366         }
 367
 368         for (i = 0; i < ARRAY_SIZE(tps6586x_regulator); i++) {
 369                 ri = &tps6586x_regulator[i];
 370                 if (ri->desc.id == id)
 371                         return ri;
 372         }
 373         return NULL;
 374 }
 375
 376 #ifdef CONFIG_OF
 377 static struct of_regulator_match tps6586x_matches[] = {
 378         { .name = "sys",     .driver_data = (void *)TPS6586X_ID_SYS     },
 379         { .name = "sm0",     .driver_data = (void *)TPS6586X_ID_SM_0    },
 380         { .name = "sm1",     .driver_data = (void *)TPS6586X_ID_SM_1    },
 381         { .name = "sm2",     .driver_data = (void *)TPS6586X_ID_SM_2    },
 382         { .name = "ldo0",    .driver_data = (void *)TPS6586X_ID_LDO_0   },
 383         { .name = "ldo1",    .driver_data = (void *)TPS6586X_ID_LDO_1   },
 384         { .name = "ldo2",    .driver_data = (void *)TPS6586X_ID_LDO_2   },
 385         { .name = "ldo3",    .driver_data = (void *)TPS6586X_ID_LDO_3   },
 386         { .name = "ldo4",    .driver_data = (void *)TPS6586X_ID_LDO_4   },
 387         { .name = "ldo5",    .driver_data = (void *)TPS6586X_ID_LDO_5   },
 388         { .name = "ldo6",    .driver_data = (void *)TPS6586X_ID_LDO_6   },
 389         { .name = "ldo7",    .driver_data = (void *)TPS6586X_ID_LDO_7   },
 390         { .name = "ldo8",    .driver_data = (void *)TPS6586X_ID_LDO_8   },
 391         { .name = "ldo9",    .driver_data = (void *)TPS6586X_ID_LDO_9   },
 392         { .name = "ldo_rtc", .driver_data = (void *)TPS6586X_ID_LDO_RTC },
 393 };
 394
 395 static struct tps6586x_platform_data *tps6586x_parse_regulator_dt(
 396                 struct platform_device *pdev,
 397                 struct of_regulator_match **tps6586x_reg_matches)
 398 {
 399         const unsigned int num = ARRAY_SIZE(tps6586x_matches);
 400         struct device_node *np = pdev->dev.parent->of_node;
 401         struct device_node *regs;
 402         const char *sys_rail = NULL;
 403         unsigned int i;
 404         struct tps6586x_platform_data *pdata;
 405         int err;
 406
 407         regs = of_get_child_by_name(np, "regulators");
 408         if (!regs) {
 409                 dev_err(&pdev->dev, "regulator node not found\n");
 410                 return NULL;
 411         }
 412
 413         err = of_regulator_match(&pdev->dev, regs, tps6586x_matches, num);
 414         of_node_put(regs);
 415         if (err < 0) {
 416                 dev_err(&pdev->dev, "Regulator match failed, e %d\n", err);
 417                 return NULL;
 418         }
 419
 420         pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
 421         if (!pdata)
 422                 return NULL;
 423
 424         for (i = 0; i < num; i++) {
 425                 uintptr_t id;
 426                 if (!tps6586x_matches[i].init_data)
 427                         continue;
 428
 429                 pdata->reg_init_data[i] = tps6586x_matches[i].init_data;
 430                 id = (uintptr_t)tps6586x_matches[i].driver_data;
 431                 if (id == TPS6586X_ID_SYS)
 432                         sys_rail = pdata->reg_init_data[i]->constraints.name;
 433
 434                 if ((id == TPS6586X_ID_LDO_5) || (id == TPS6586X_ID_LDO_RTC))
 435                         pdata->reg_init_data[i]->supply_regulator = sys_rail;
 436         }
 437         *tps6586x_reg_matches = tps6586x_matches;
 438         return pdata;
 439 }
 440 #else
 441 static struct tps6586x_platform_data *tps6586x_parse_regulator_dt(
 442                 struct platform_device *pdev,
 443                 struct of_regulator_match **tps6586x_reg_matches)
 444 {
 445         *tps6586x_reg_matches = NULL;
 446         return NULL;
 447 }
 448 #endif
 449
 450 static int tps6586x_regulator_probe(struct platform_device *pdev)
 451 {
 452         struct tps6586x_regulator *ri = NULL;
 453         struct regulator_config config = { };
 454         struct regulator_dev *rdev;
 455         struct regulator_init_data *reg_data;
 456         struct tps6586x_platform_data *pdata;
 457         struct of_regulator_match *tps6586x_reg_matches = NULL;
 458         int version;
 459         int id;
 460         int err;
 461
 462         dev_dbg(&pdev->dev, "Probing regulator\n");
 463
 464         pdata = dev_get_platdata(pdev->dev.parent);
 465         if ((!pdata) && (pdev->dev.parent->of_node))
 466                 pdata = tps6586x_parse_regulator_dt(pdev,
 467                                         &tps6586x_reg_matches);
 468
 469         if (!pdata) {
 470                 dev_err(&pdev->dev, "Platform data not available, exiting\n");
 471                 return -ENODEV;
 472         }
 473
 474         version = tps6586x_get_version(pdev->dev.parent);
 475
 476         for (id = 0; id < TPS6586X_ID_MAX_REGULATOR; ++id) {
 477                 reg_data = pdata->reg_init_data[id];
 478
 479                 ri = find_regulator_info(id, version);
 480
 481                 if (!ri) {
 482                         dev_err(&pdev->dev, "invalid regulator ID specified\n");
 483                         return -EINVAL;
 484                 }
 485
 486                 err = tps6586x_regulator_preinit(pdev->dev.parent, ri);
 487                 if (err) {
 488                         dev_err(&pdev->dev,
 489                                 "regulator %d preinit failed, e %d\n", id, err);
 490                         return err;
 491                 }
 492
 493                 config.dev = pdev->dev.parent;
 494                 config.init_data = reg_data;
 495                 config.driver_data = ri;
 496
 497                 if (tps6586x_reg_matches)
 498                         config.of_node = tps6586x_reg_matches[id].of_node;
 499
 500                 rdev = devm_regulator_register(&pdev->dev, &ri->desc, &config);
 501                 if (IS_ERR(rdev)) {
 502                         dev_err(&pdev->dev, "failed to register regulator %s\n",
 503                                         ri->desc.name);
 504                         return PTR_ERR(rdev);
 505                 }
 506
 507                 if (reg_data) {
 508                         err = tps6586x_regulator_set_slew_rate(pdev, id,
 509                                         reg_data);
 510                         if (err < 0) {
 511                                 dev_err(&pdev->dev,
 512                                         "Slew rate config failed, e %d\n", err);
 513                                 return err;
 514                         }
 515                 }
 516         }
 517
 518         platform_set_drvdata(pdev, rdev);
 519         return 0;
 520 }
 521
 522 static struct platform_driver tps6586x_regulator_driver = {
 523         .driver = {
 524                 .name   = "tps6586x-regulator",
 525         },
 526         .probe          = tps6586x_regulator_probe,
 527 };
 528
 529 static int __init tps6586x_regulator_init(void)
 530 {
 531         return platform_driver_register(&tps6586x_regulator_driver);
 532 }
 533 subsys_initcall(tps6586x_regulator_init);
 534
 535 static void __exit tps6586x_regulator_exit(void)
 536 {
 537         platform_driver_unregister(&tps6586x_regulator_driver);
 538 }
 539 module_exit(tps6586x_regulator_exit);
 540
 541 MODULE_LICENSE("GPL");
 542 MODULE_AUTHOR("Mike Rapoport <mike@compulab.co.il>");
 543 MODULE_DESCRIPTION("Regulator Driver for TI TPS6586X PMIC");
 544 MODULE_ALIAS("platform:tps6586x-regulator");