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_ro_regulator_ops = {
  78         .list_voltage = regulator_list_voltage_table,
  79         .map_voltage = regulator_map_voltage_ascend,
  80         .get_voltage_sel = regulator_get_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_sys_regulator_ops = {
  88 };
  89
  90 static const unsigned int tps6586x_ldo0_voltages[] = {
  91         1200000, 1500000, 1800000, 2500000, 2700000, 2850000, 3100000, 3300000,
  92 };
  93
  94 static const unsigned int tps6586x_ldo4_voltages[] = {
  95         1700000, 1725000, 1750000, 1775000, 1800000, 1825000, 1850000, 1875000,
  96         1900000, 1925000, 1950000, 1975000, 2000000, 2025000, 2050000, 2075000,
  97         2100000, 2125000, 2150000, 2175000, 2200000, 2225000, 2250000, 2275000,
  98         2300000, 2325000, 2350000, 2375000, 2400000, 2425000, 2450000, 2475000,
  99 };
 100
 101 #define tps658623_sm2_voltages tps6586x_ldo4_voltages
 102
 103 static const unsigned int tps6586x_ldo_voltages[] = {
 104         1250000, 1500000, 1800000, 2500000, 2700000, 2850000, 3100000, 3300000,
 105 };
 106
 107 static const unsigned int tps6586x_sm2_voltages[] = {
 108         3000000, 3050000, 3100000, 3150000, 3200000, 3250000, 3300000, 3350000,
 109         3400000, 3450000, 3500000, 3550000, 3600000, 3650000, 3700000, 3750000,
 110         3800000, 3850000, 3900000, 3950000, 4000000, 4050000, 4100000, 4150000,
 111         4200000, 4250000, 4300000, 4350000, 4400000, 4450000, 4500000, 4550000,
 112 };
 113
 114 static int tps658640_sm2_voltages[] = {
 115         2150000, 2200000, 2250000, 2300000, 2350000, 2400000, 2450000, 2500000,
 116         2550000, 2600000, 2650000, 2700000, 2750000, 2800000, 2850000, 2900000,
 117         2950000, 3000000, 3050000, 3100000, 3150000, 3200000, 3250000, 3300000,
 118         3350000, 3400000, 3450000, 3500000, 3550000, 3600000, 3650000, 3700000,
 119 };
 120
 121 static const unsigned int tps658643_sm2_voltages[] = {
 122         1025000, 1050000, 1075000, 1100000, 1125000, 1150000, 1175000, 1200000,
 123         1225000, 1250000, 1275000, 1300000, 1325000, 1350000, 1375000, 1400000,
 124         1425000, 1450000, 1475000, 1500000, 1525000, 1550000, 1575000, 1600000,
 125         1625000, 1650000, 1675000, 1700000, 1725000, 1750000, 1775000, 1800000,
 126 };
 127
 128 static const unsigned int tps6586x_dvm_voltages[] = {
 129          725000,  750000,  775000,  800000,  825000,  850000,  875000,  900000,
 130          925000,  950000,  975000, 1000000, 1025000, 1050000, 1075000, 1100000,
 131         1125000, 1150000, 1175000, 1200000, 1225000, 1250000, 1275000, 1300000,
 132         1325000, 1350000, 1375000, 1400000, 1425000, 1450000, 1475000, 1500000,
 133 };
 134
 135 static int tps658640_rtc_voltages[] = {
 136         2500000, 2850000, 3100000, 3300000,
 137 };
 138
 139 #define TPS6586X_REGULATOR(_id, _ops, _pin_name, vdata, vreg, shift, nbits, \
 140                            ereg0, ebit0, ereg1, ebit1, goreg, gobit)    \
 141         .desc   = {                                                     \
 142                 .supply_name = _pin_name,                               \
 143                 .name   = "REG-" #_id,                                  \
 144                 .ops    = &tps6586x_## _ops ## _regulator_ops,          \
 145                 .type   = REGULATOR_VOLTAGE,                            \
 146                 .id     = TPS6586X_ID_##_id,                            \
 147                 .n_voltages = ARRAY_SIZE(vdata##_voltages),             \
 148                 .volt_table = vdata##_voltages,                         \
 149                 .owner  = THIS_MODULE,                                  \
 150                 .enable_reg = TPS6586X_SUPPLY##ereg0,                   \
 151                 .enable_mask = 1 << (ebit0),                            \
 152                 .vsel_reg = TPS6586X_##vreg,                            \
 153                 .vsel_mask = ((1 << (nbits)) - 1) << (shift),           \
 154                 .apply_reg = (goreg),                           \
 155                 .apply_bit = (gobit),                           \
 156         },                                                              \
 157         .enable_reg[0]  = TPS6586X_SUPPLY##ereg0,                       \
 158         .enable_bit[0]  = (ebit0),                                      \
 159         .enable_reg[1]  = TPS6586X_SUPPLY##ereg1,                       \
 160         .enable_bit[1]  = (ebit1),
 161
 162 #define TPS6586X_LDO(_id, _pname, vdata, vreg, shift, nbits,            \
 163                      ereg0, ebit0, ereg1, ebit1)                        \
 164 {                                                                       \
 165         TPS6586X_REGULATOR(_id, rw, _pname, vdata, vreg, shift, nbits,  \
 166                            ereg0, ebit0, ereg1, ebit1, 0, 0)            \
 167 }
 168
 169 #define TPS6586X_FIXED_LDO(_id, _pname, vdata, vreg, shift, nbits,      \
 170                           ereg0, ebit0, ereg1, ebit1)                   \
 171 {                                                                       \
 172         TPS6586X_REGULATOR(_id, ro, _pname, vdata, vreg, shift, nbits,  \
 173                            ereg0, ebit0, ereg1, ebit1, 0, 0)            \
 174 }
 175
 176 #define TPS6586X_DVM(_id, _pname, vdata, vreg, shift, nbits,            \
 177                      ereg0, ebit0, ereg1, ebit1, goreg, gobit)          \
 178 {                                                                       \
 179         TPS6586X_REGULATOR(_id, rw, _pname, vdata, vreg, shift, nbits,  \
 180                            ereg0, ebit0, ereg1, ebit1, goreg, gobit)    \
 181 }
 182
 183 #define TPS6586X_SYS_REGULATOR()                                        \
 184 {                                                                       \
 185         .desc   = {                                                     \
 186                 .supply_name = "sys",                                   \
 187                 .name   = "REG-SYS",                                    \
 188                 .ops    = &tps6586x_sys_regulator_ops,                  \
 189                 .type   = REGULATOR_VOLTAGE,                            \
 190                 .id     = TPS6586X_ID_SYS,                              \
 191                 .owner  = THIS_MODULE,                                  \
 192         },                                                              \
 193 }
 194
 195 static struct tps6586x_regulator tps6586x_regulator[] = {
 196         TPS6586X_SYS_REGULATOR(),
 197         TPS6586X_LDO(LDO_0, "vinldo01", tps6586x_ldo0, SUPPLYV1, 5, 3, ENC, 0,
 198                                         END, 0),
 199         TPS6586X_LDO(LDO_3, "vinldo23", tps6586x_ldo, SUPPLYV4, 0, 3, ENC, 2,
 200                                         END, 2),
 201         TPS6586X_LDO(LDO_5, "REG-SYS", tps6586x_ldo, SUPPLYV6, 0, 3, ENE, 6,
 202                                         ENE, 6),
 203         TPS6586X_LDO(LDO_6, "vinldo678", tps6586x_ldo, SUPPLYV3, 0, 3, ENC, 4,
 204                                         END, 4),
 205         TPS6586X_LDO(LDO_7, "vinldo678", tps6586x_ldo, SUPPLYV3, 3, 3, ENC, 5,
 206                                         END, 5),
 207         TPS6586X_LDO(LDO_8, "vinldo678", tps6586x_ldo, SUPPLYV2, 5, 3, ENC, 6,
 208                                         END, 6),
 209         TPS6586X_LDO(LDO_9, "vinldo9", tps6586x_ldo, SUPPLYV6, 3, 3, ENE, 7,
 210                                         ENE, 7),
 211         TPS6586X_LDO(LDO_RTC, "REG-SYS", tps6586x_ldo, SUPPLYV4, 3, 3, V4, 7,
 212                                         V4, 7),
 213         TPS6586X_LDO(LDO_1, "vinldo01", tps6586x_dvm, SUPPLYV1, 0, 5, ENC, 1,
 214                                         END, 1),
 215         TPS6586X_LDO(SM_2, "vin-sm2", tps6586x_sm2, SUPPLYV2, 0, 5, ENC, 7,
 216                                         END, 7),
 217
 218         TPS6586X_DVM(LDO_2, "vinldo23", tps6586x_dvm, LDO2BV1, 0, 5, ENA, 3,
 219                                         ENB, 3, TPS6586X_VCC2, BIT(6)),
 220         TPS6586X_DVM(LDO_4, "vinldo4", tps6586x_ldo4, LDO4V1, 0, 5, ENC, 3,
 221                                         END, 3, TPS6586X_VCC1, BIT(6)),
 222         TPS6586X_DVM(SM_0, "vin-sm0", tps6586x_dvm, SM0V1, 0, 5, ENA, 1,
 223                                         ENB, 1, TPS6586X_VCC1, BIT(2)),
 224         TPS6586X_DVM(SM_1, "vin-sm1", tps6586x_dvm, SM1V1, 0, 5, ENA, 0,
 225                                         ENB, 0, TPS6586X_VCC1, BIT(0)),
 226 };
 227
 228 static struct tps6586x_regulator tps658623_regulator[] = {
 229         TPS6586X_LDO(SM_2, "vin-sm2", tps658623_sm2, SUPPLYV2, 0, 5, ENC, 7,
 230                                         END, 7),
 231 };
 232
 233 static struct tps6586x_regulator tps658640_regulator[] = {
 234         TPS6586X_LDO(LDO_3, "vinldo23", tps6586x_ldo0, SUPPLYV4, 0, 3,
 235                                         ENC, 2, END, 2),
 236         TPS6586X_LDO(LDO_5, "REG-SYS", tps6586x_ldo0, SUPPLYV6, 0, 3,
 237                                         ENE, 6, ENE, 6),
 238         TPS6586X_LDO(LDO_6, "vinldo678", tps6586x_ldo0, SUPPLYV3, 0, 3,
 239                                         ENC, 4, END, 4),
 240         TPS6586X_LDO(LDO_7, "vinldo678", tps6586x_ldo0, SUPPLYV3, 3, 3,
 241                                         ENC, 5, END, 5),
 242         TPS6586X_LDO(LDO_8, "vinldo678", tps6586x_ldo0, SUPPLYV2, 5, 3,
 243                                         ENC, 6, END, 6),
 244         TPS6586X_LDO(LDO_9, "vinldo9", tps6586x_ldo0, SUPPLYV6, 3, 3,
 245                                         ENE, 7, ENE, 7),
 246         TPS6586X_LDO(SM_2, "vin-sm2", tps658640_sm2, SUPPLYV2, 0, 5,
 247                                         ENC, 7, END, 7),
 248
 249         TPS6586X_FIXED_LDO(LDO_RTC, "REG-SYS", tps658640_rtc, SUPPLYV4, 3, 2,
 250                                         V4, 7, V4, 7),
 251 };
 252
 253 static struct tps6586x_regulator tps658643_regulator[] = {
 254         TPS6586X_LDO(SM_2, "vin-sm2", tps658643_sm2, SUPPLYV2, 0, 5, ENC, 7,
 255                                         END, 7),
 256 };
 257
 258 /*
 259  * TPS6586X has 2 enable bits that are OR'ed to determine the actual
 260  * regulator state. Clearing one of this bits allows switching
 261  * regulator on and of with single register write.
 262  */
 263 static inline int tps6586x_regulator_preinit(struct device *parent,
 264                                              struct tps6586x_regulator *ri)
 265 {
 266         uint8_t val1, val2;
 267         int ret;
 268
 269         if (ri->enable_reg[0] == ri->enable_reg[1] &&
 270             ri->enable_bit[0] == ri->enable_bit[1])
 271                         return 0;
 272
 273         ret = tps6586x_read(parent, ri->enable_reg[0], &val1);
 274         if (ret)
 275                 return ret;
 276
 277         ret = tps6586x_read(parent, ri->enable_reg[1], &val2);
 278         if (ret)
 279                 return ret;
 280
 281         if (!(val2 & (1 << ri->enable_bit[1])))
 282                 return 0;
 283
 284         /*
 285          * The regulator is on, but it's enabled with the bit we don't
 286          * want to use, so we switch the enable bits
 287          */
 288         if (!(val1 & (1 << ri->enable_bit[0]))) {
 289                 ret = tps6586x_set_bits(parent, ri->enable_reg[0],
 290                                         1 << ri->enable_bit[0]);
 291                 if (ret)
 292                         return ret;
 293         }
 294
 295         return tps6586x_clr_bits(parent, ri->enable_reg[1],
 296                                  1 << ri->enable_bit[1]);
 297 }
 298
 299 static int tps6586x_regulator_set_slew_rate(struct platform_device *pdev,
 300                         int id, struct regulator_init_data *p)
 301 {
 302         struct device *parent = pdev->dev.parent;
 303         struct tps6586x_settings *setting = p->driver_data;
 304         uint8_t reg;
 305
 306         if (setting == NULL)
 307                 return 0;
 308
 309         if (!(setting->slew_rate & TPS6586X_SLEW_RATE_SET))
 310                 return 0;
 311
 312         /* only SM0 and SM1 can have the slew rate settings */
 313         switch (id) {
 314         case TPS6586X_ID_SM_0:
 315                 reg = TPS6586X_SM0SL;
 316                 break;
 317         case TPS6586X_ID_SM_1:
 318                 reg = TPS6586X_SM1SL;
 319                 break;
 320         default:
 321                 dev_err(&pdev->dev, "Only SM0/SM1 can set slew rate\n");
 322                 return -EINVAL;
 323         }
 324
 325         return tps6586x_write(parent, reg,
 326                         setting->slew_rate & TPS6586X_SLEW_RATE_MASK);
 327 }
 328
 329 static struct tps6586x_regulator *find_regulator_info(int id, int version)
 330 {
 331         struct tps6586x_regulator *ri;
 332         struct tps6586x_regulator *table = NULL;
 333         int num;
 334         int i;
 335
 336         switch (version) {
 337         case TPS658623:
 338                 table = tps658623_regulator;
 339                 num = ARRAY_SIZE(tps658623_regulator);
 340                 break;
 341         case TPS658640:
 342         case TPS658640v2:
 343                 table = tps658640_regulator;
 344                 num = ARRAY_SIZE(tps658640_regulator);
 345                 break;
 346         case TPS658643:
 347                 table = tps658643_regulator;
 348                 num = ARRAY_SIZE(tps658643_regulator);
 349                 break;
 350         }
 351
 352         /* Search version specific table first */
 353         if (table) {
 354                 for (i = 0; i < num; i++) {
 355                         ri = &table[i];
 356                         if (ri->desc.id == id)
 357                                 return ri;
 358                 }
 359         }
 360
 361         for (i = 0; i < ARRAY_SIZE(tps6586x_regulator); i++) {
 362                 ri = &tps6586x_regulator[i];
 363                 if (ri->desc.id == id)
 364                         return ri;
 365         }
 366         return NULL;
 367 }
 368
 369 #ifdef CONFIG_OF
 370 static struct of_regulator_match tps6586x_matches[] = {
 371         { .name = "sys",     .driver_data = (void *)TPS6586X_ID_SYS     },
 372         { .name = "sm0",     .driver_data = (void *)TPS6586X_ID_SM_0    },
 373         { .name = "sm1",     .driver_data = (void *)TPS6586X_ID_SM_1    },
 374         { .name = "sm2",     .driver_data = (void *)TPS6586X_ID_SM_2    },
 375         { .name = "ldo0",    .driver_data = (void *)TPS6586X_ID_LDO_0   },
 376         { .name = "ldo1",    .driver_data = (void *)TPS6586X_ID_LDO_1   },
 377         { .name = "ldo2",    .driver_data = (void *)TPS6586X_ID_LDO_2   },
 378         { .name = "ldo3",    .driver_data = (void *)TPS6586X_ID_LDO_3   },
 379         { .name = "ldo4",    .driver_data = (void *)TPS6586X_ID_LDO_4   },
 380         { .name = "ldo5",    .driver_data = (void *)TPS6586X_ID_LDO_5   },
 381         { .name = "ldo6",    .driver_data = (void *)TPS6586X_ID_LDO_6   },
 382         { .name = "ldo7",    .driver_data = (void *)TPS6586X_ID_LDO_7   },
 383         { .name = "ldo8",    .driver_data = (void *)TPS6586X_ID_LDO_8   },
 384         { .name = "ldo9",    .driver_data = (void *)TPS6586X_ID_LDO_9   },
 385         { .name = "ldo_rtc", .driver_data = (void *)TPS6586X_ID_LDO_RTC },
 386 };
 387
 388 static struct tps6586x_platform_data *tps6586x_parse_regulator_dt(
 389                 struct platform_device *pdev,
 390                 struct of_regulator_match **tps6586x_reg_matches)
 391 {
 392         const unsigned int num = ARRAY_SIZE(tps6586x_matches);
 393         struct device_node *np = pdev->dev.parent->of_node;
 394         struct device_node *regs;
 395         const char *sys_rail = NULL;
 396         unsigned int i;
 397         struct tps6586x_platform_data *pdata;
 398         int err;
 399
 400         regs = of_get_child_by_name(np, "regulators");
 401         if (!regs) {
 402                 dev_err(&pdev->dev, "regulator node not found\n");
 403                 return NULL;
 404         }
 405
 406         err = of_regulator_match(&pdev->dev, regs, tps6586x_matches, num);
 407         of_node_put(regs);
 408         if (err < 0) {
 409                 dev_err(&pdev->dev, "Regulator match failed, e %d\n", err);
 410                 return NULL;
 411         }
 412
 413         pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
 414         if (!pdata)
 415                 return NULL;
 416
 417         for (i = 0; i < num; i++) {
 418                 int id;
 419                 if (!tps6586x_matches[i].init_data)
 420                         continue;
 421
 422                 pdata->reg_init_data[i] = tps6586x_matches[i].init_data;
 423                 id = (int)tps6586x_matches[i].driver_data;
 424                 if (id == TPS6586X_ID_SYS)
 425                         sys_rail = pdata->reg_init_data[i]->constraints.name;
 426
 427                 if ((id == TPS6586X_ID_LDO_5) || (id == TPS6586X_ID_LDO_RTC))
 428                         pdata->reg_init_data[i]->supply_regulator = sys_rail;
 429         }
 430         *tps6586x_reg_matches = tps6586x_matches;
 431         return pdata;
 432 }
 433 #else
 434 static struct tps6586x_platform_data *tps6586x_parse_regulator_dt(
 435                 struct platform_device *pdev,
 436                 struct of_regulator_match **tps6586x_reg_matches)
 437 {
 438         *tps6586x_reg_matches = NULL;
 439         return NULL;
 440 }
 441 #endif
 442
 443 static int tps6586x_regulator_probe(struct platform_device *pdev)
 444 {
 445         struct tps6586x_regulator *ri = NULL;
 446         struct regulator_config config = { };
 447         struct regulator_dev *rdev;
 448         struct regulator_init_data *reg_data;
 449         struct tps6586x_platform_data *pdata;
 450         struct of_regulator_match *tps6586x_reg_matches = NULL;
 451         int version;
 452         int id;
 453         int err;
 454
 455         dev_dbg(&pdev->dev, "Probing regulator\n");
 456
 457         pdata = dev_get_platdata(pdev->dev.parent);
 458         if ((!pdata) && (pdev->dev.parent->of_node))
 459                 pdata = tps6586x_parse_regulator_dt(pdev,
 460                                         &tps6586x_reg_matches);
 461
 462         if (!pdata) {
 463                 dev_err(&pdev->dev, "Platform data not available, exiting\n");
 464                 return -ENODEV;
 465         }
 466
 467         version = tps6586x_get_version(pdev->dev.parent);
 468
 469         for (id = 0; id < TPS6586X_ID_MAX_REGULATOR; ++id) {
 470                 reg_data = pdata->reg_init_data[id];
 471
 472                 ri = find_regulator_info(id, version);
 473
 474                 if (!ri) {
 475                         dev_err(&pdev->dev, "invalid regulator ID specified\n");
 476                         return -EINVAL;
 477                 }
 478
 479                 err = tps6586x_regulator_preinit(pdev->dev.parent, ri);
 480                 if (err) {
 481                         dev_err(&pdev->dev,
 482                                 "regulator %d preinit failed, e %d\n", id, err);
 483                         return err;
 484                 }
 485
 486                 config.dev = pdev->dev.parent;
 487                 config.init_data = reg_data;
 488                 config.driver_data = ri;
 489
 490                 if (tps6586x_reg_matches)
 491                         config.of_node = tps6586x_reg_matches[id].of_node;
 492
 493                 rdev = devm_regulator_register(&pdev->dev, &ri->desc, &config);
 494                 if (IS_ERR(rdev)) {
 495                         dev_err(&pdev->dev, "failed to register regulator %s\n",
 496                                         ri->desc.name);
 497                         return PTR_ERR(rdev);
 498                 }
 499
 500                 if (reg_data) {
 501                         err = tps6586x_regulator_set_slew_rate(pdev, id,
 502                                         reg_data);
 503                         if (err < 0) {
 504                                 dev_err(&pdev->dev,
 505                                         "Slew rate config failed, e %d\n", err);
 506                                 return err;
 507                         }
 508                 }
 509         }
 510
 511         platform_set_drvdata(pdev, rdev);
 512         return 0;
 513 }
 514
 515 static struct platform_driver tps6586x_regulator_driver = {
 516         .driver = {
 517                 .name   = "tps6586x-regulator",
 518                 .owner  = THIS_MODULE,
 519         },
 520         .probe          = tps6586x_regulator_probe,
 521 };
 522
 523 static int __init tps6586x_regulator_init(void)
 524 {
 525         return platform_driver_register(&tps6586x_regulator_driver);
 526 }
 527 subsys_initcall(tps6586x_regulator_init);
 528
 529 static void __exit tps6586x_regulator_exit(void)
 530 {
 531         platform_driver_unregister(&tps6586x_regulator_driver);
 532 }
 533 module_exit(tps6586x_regulator_exit);
 534
 535 MODULE_LICENSE("GPL");
 536 MODULE_AUTHOR("Mike Rapoport <mike@compulab.co.il>");
 537 MODULE_DESCRIPTION("Regulator Driver for TI TPS6586X PMIC");
 538 MODULE_ALIAS("platform:tps6586x-regulator");