drivers/regulator/lp3972.c

   1 /*
   2  * Regulator driver for National Semiconductors LP3972 PMIC chip
   3  *
   4  * Based on lp3971.c
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 as
   8  * published by the Free Software Foundation.
   9  *
  10  */
  11
  12 #include <linux/bug.h>
  13 #include <linux/err.h>
  14 #include <linux/i2c.h>
  15 #include <linux/module.h>
  16 #include <linux/kernel.h>
  17 #include <linux/regulator/driver.h>
  18 #include <linux/regulator/lp3972.h>
  19 #include <linux/slab.h>
  20
  21 struct lp3972 {
  22         struct device *dev;
  23         struct mutex io_lock;
  24         struct i2c_client *i2c;
  25         int num_regulators;
  26         struct regulator_dev **rdev;
  27 };
  28
  29 /* LP3972 Control Registers */
  30 #define LP3972_SCR_REG          0x07
  31 #define LP3972_OVER1_REG        0x10
  32 #define LP3972_OVSR1_REG        0x11
  33 #define LP3972_OVER2_REG        0x12
  34 #define LP3972_OVSR2_REG        0x13
  35 #define LP3972_VCC1_REG         0x20
  36 #define LP3972_ADTV1_REG        0x23
  37 #define LP3972_ADTV2_REG        0x24
  38 #define LP3972_AVRC_REG         0x25
  39 #define LP3972_CDTC1_REG        0x26
  40 #define LP3972_CDTC2_REG        0x27
  41 #define LP3972_SDTV1_REG        0x29
  42 #define LP3972_SDTV2_REG        0x2A
  43 #define LP3972_MDTV1_REG        0x32
  44 #define LP3972_MDTV2_REG        0x33
  45 #define LP3972_L2VCR_REG        0x39
  46 #define LP3972_L34VCR_REG       0x3A
  47 #define LP3972_SCR1_REG         0x80
  48 #define LP3972_SCR2_REG         0x81
  49 #define LP3972_OEN3_REG         0x82
  50 #define LP3972_OSR3_REG         0x83
  51 #define LP3972_LOER4_REG        0x84
  52 #define LP3972_B2TV_REG         0x85
  53 #define LP3972_B3TV_REG         0x86
  54 #define LP3972_B32RC_REG        0x87
  55 #define LP3972_ISRA_REG         0x88
  56 #define LP3972_BCCR_REG         0x89
  57 #define LP3972_II1RR_REG        0x8E
  58 #define LP3972_II2RR_REG        0x8F
  59
  60 #define LP3972_SYS_CONTROL1_REG         LP3972_SCR1_REG
  61 /* System control register 1 initial value,
  62  * bits 5, 6 and 7 are EPROM programmable */
  63 #define SYS_CONTROL1_INIT_VAL           0x02
  64 #define SYS_CONTROL1_INIT_MASK          0x1F
  65
  66 #define LP3972_VOL_CHANGE_REG           LP3972_VCC1_REG
  67 #define LP3972_VOL_CHANGE_FLAG_GO       0x01
  68 #define LP3972_VOL_CHANGE_FLAG_MASK     0x03
  69
  70 /* LDO output enable mask */
  71 #define LP3972_OEN3_L1EN        BIT(0)
  72 #define LP3972_OVER2_LDO2_EN    BIT(2)
  73 #define LP3972_OVER2_LDO3_EN    BIT(3)
  74 #define LP3972_OVER2_LDO4_EN    BIT(4)
  75 #define LP3972_OVER1_S_EN       BIT(2)
  76
  77 static const unsigned int ldo1_voltage_map[] = {
  78         1700000, 1725000, 1750000, 1775000, 1800000, 1825000, 1850000, 1875000,
  79         1900000, 1925000, 1950000, 1975000, 2000000,
  80 };
  81
  82 static const unsigned int ldo23_voltage_map[] = {
  83         1800000, 1900000, 2000000, 2100000, 2200000, 2300000, 2400000, 2500000,
  84         2600000, 2700000, 2800000, 2900000, 3000000, 3100000, 3200000, 3300000,
  85 };
  86
  87 static const unsigned int ldo4_voltage_map[] = {
  88         1000000, 1050000, 1100000, 1150000, 1200000, 1250000, 1300000, 1350000,
  89         1400000, 1500000, 1800000, 1900000, 2500000, 2800000, 3000000, 3300000,
  90 };
  91
  92 static const unsigned int ldo5_voltage_map[] = {
  93               0,       0,       0,       0,       0,  850000,  875000,  900000,
  94          925000,  950000,  975000, 1000000, 1025000, 1050000, 1075000, 1100000,
  95         1125000, 1150000, 1175000, 1200000, 1225000, 1250000, 1275000, 1300000,
  96         1325000, 1350000, 1375000, 1400000, 1425000, 1450000, 1475000, 1500000,
  97 };
  98
  99 static const unsigned int buck1_voltage_map[] = {
 100          725000,  750000,  775000,  800000,  825000,  850000,  875000,  900000,
 101          925000,  950000,  975000, 1000000, 1025000, 1050000, 1075000, 1100000,
 102         1125000, 1150000, 1175000, 1200000, 1225000, 1250000, 1275000, 1300000,
 103         1325000, 1350000, 1375000, 1400000, 1425000, 1450000, 1475000, 1500000,
 104 };
 105
 106 static const unsigned int buck23_voltage_map[] = {
 107               0,  800000,  850000,  900000,  950000, 1000000, 1050000, 1100000,
 108         1150000, 1200000, 1250000, 1300000, 1350000, 1400000, 1450000, 1500000,
 109         1550000, 1600000, 1650000, 1700000, 1800000, 1900000, 2500000, 2800000,
 110         3000000, 3300000,
 111 };
 112
 113 static const int ldo_output_enable_mask[] = {
 114         LP3972_OEN3_L1EN,
 115         LP3972_OVER2_LDO2_EN,
 116         LP3972_OVER2_LDO3_EN,
 117         LP3972_OVER2_LDO4_EN,
 118         LP3972_OVER1_S_EN,
 119 };
 120
 121 static const int ldo_output_enable_addr[] = {
 122         LP3972_OEN3_REG,
 123         LP3972_OVER2_REG,
 124         LP3972_OVER2_REG,
 125         LP3972_OVER2_REG,
 126         LP3972_OVER1_REG,
 127 };
 128
 129 static const int ldo_vol_ctl_addr[] = {
 130         LP3972_MDTV1_REG,
 131         LP3972_L2VCR_REG,
 132         LP3972_L34VCR_REG,
 133         LP3972_L34VCR_REG,
 134         LP3972_SDTV1_REG,
 135 };
 136
 137 static const int buck_vol_enable_addr[] = {
 138         LP3972_OVER1_REG,
 139         LP3972_OEN3_REG,
 140         LP3972_OEN3_REG,
 141 };
 142
 143 static const int buck_base_addr[] = {
 144         LP3972_ADTV1_REG,
 145         LP3972_B2TV_REG,
 146         LP3972_B3TV_REG,
 147 };
 148
 149 #define LP3972_LDO_OUTPUT_ENABLE_MASK(x) (ldo_output_enable_mask[x])
 150 #define LP3972_LDO_OUTPUT_ENABLE_REG(x) (ldo_output_enable_addr[x])
 151
 152 /*      LDO voltage control registers shift:
 153         LP3972_LDO1 -> 0, LP3972_LDO2 -> 4
 154         LP3972_LDO3 -> 0, LP3972_LDO4 -> 4
 155         LP3972_LDO5 -> 0
 156 */
 157 #define LP3972_LDO_VOL_CONTR_SHIFT(x) (((x) & 1) << 2)
 158 #define LP3972_LDO_VOL_CONTR_REG(x) (ldo_vol_ctl_addr[x])
 159 #define LP3972_LDO_VOL_CHANGE_SHIFT(x) ((x) ? 4 : 6)
 160
 161 #define LP3972_LDO_VOL_MASK(x) (((x) % 4) ? 0x0f : 0x1f)
 162 #define LP3972_LDO_VOL_MIN_IDX(x) (((x) == 4) ? 0x05 : 0x00)
 163 #define LP3972_LDO_VOL_MAX_IDX(x) ((x) ? (((x) == 4) ? 0x1f : 0x0f) : 0x0c)
 164
 165 #define LP3972_BUCK_VOL_ENABLE_REG(x) (buck_vol_enable_addr[x])
 166 #define LP3972_BUCK_VOL1_REG(x) (buck_base_addr[x])
 167 #define LP3972_BUCK_VOL_MASK 0x1f
 168 #define LP3972_BUCK_VOL_MIN_IDX(x) ((x) ? 0x01 : 0x00)
 169 #define LP3972_BUCK_VOL_MAX_IDX(x) ((x) ? 0x19 : 0x1f)
 170
 171 static int lp3972_i2c_read(struct i2c_client *i2c, char reg, int count,
 172         u16 *dest)
 173 {
 174         int ret;
 175
 176         if (count != 1)
 177                 return -EIO;
 178         ret = i2c_smbus_read_byte_data(i2c, reg);
 179         if (ret < 0)
 180                 return ret;
 181
 182         *dest = ret;
 183         return 0;
 184 }
 185
 186 static int lp3972_i2c_write(struct i2c_client *i2c, char reg, int count,
 187         const u16 *src)
 188 {
 189         if (count != 1)
 190                 return -EIO;
 191         return i2c_smbus_write_byte_data(i2c, reg, *src);
 192 }
 193
 194 static u8 lp3972_reg_read(struct lp3972 *lp3972, u8 reg)
 195 {
 196         u16 val = 0;
 197
 198         mutex_lock(&lp3972->io_lock);
 199
 200         lp3972_i2c_read(lp3972->i2c, reg, 1, &val);
 201
 202         dev_dbg(lp3972->dev, "reg read 0x%02x -> 0x%02x\n", (int)reg,
 203                 (unsigned)val & 0xff);
 204
 205         mutex_unlock(&lp3972->io_lock);
 206
 207         return val & 0xff;
 208 }
 209
 210 static int lp3972_set_bits(struct lp3972 *lp3972, u8 reg, u16 mask, u16 val)
 211 {
 212         u16 tmp;
 213         int ret;
 214
 215         mutex_lock(&lp3972->io_lock);
 216
 217         ret = lp3972_i2c_read(lp3972->i2c, reg, 1, &tmp);
 218         tmp = (tmp & ~mask) | val;
 219         if (ret == 0) {
 220                 ret = lp3972_i2c_write(lp3972->i2c, reg, 1, &tmp);
 221                 dev_dbg(lp3972->dev, "reg write 0x%02x -> 0x%02x\n", (int)reg,
 222                         (unsigned)val & 0xff);
 223         }
 224         mutex_unlock(&lp3972->io_lock);
 225
 226         return ret;
 227 }
 228
 229 static int lp3972_ldo_is_enabled(struct regulator_dev *dev)
 230 {
 231         struct lp3972 *lp3972 = rdev_get_drvdata(dev);
 232         int ldo = rdev_get_id(dev) - LP3972_LDO1;
 233         u16 mask = LP3972_LDO_OUTPUT_ENABLE_MASK(ldo);
 234         u16 val;
 235
 236         val = lp3972_reg_read(lp3972, LP3972_LDO_OUTPUT_ENABLE_REG(ldo));
 237         return !!(val & mask);
 238 }
 239
 240 static int lp3972_ldo_enable(struct regulator_dev *dev)
 241 {
 242         struct lp3972 *lp3972 = rdev_get_drvdata(dev);
 243         int ldo = rdev_get_id(dev) - LP3972_LDO1;
 244         u16 mask = LP3972_LDO_OUTPUT_ENABLE_MASK(ldo);
 245
 246         return lp3972_set_bits(lp3972, LP3972_LDO_OUTPUT_ENABLE_REG(ldo),
 247                                 mask, mask);
 248 }
 249
 250 static int lp3972_ldo_disable(struct regulator_dev *dev)
 251 {
 252         struct lp3972 *lp3972 = rdev_get_drvdata(dev);
 253         int ldo = rdev_get_id(dev) - LP3972_LDO1;
 254         u16 mask = LP3972_LDO_OUTPUT_ENABLE_MASK(ldo);
 255
 256         return lp3972_set_bits(lp3972, LP3972_LDO_OUTPUT_ENABLE_REG(ldo),
 257                                 mask, 0);
 258 }
 259
 260 static int lp3972_ldo_get_voltage(struct regulator_dev *dev)
 261 {
 262         struct lp3972 *lp3972 = rdev_get_drvdata(dev);
 263         int ldo = rdev_get_id(dev) - LP3972_LDO1;
 264         u16 mask = LP3972_LDO_VOL_MASK(ldo);
 265         u16 val, reg;
 266
 267         reg = lp3972_reg_read(lp3972, LP3972_LDO_VOL_CONTR_REG(ldo));
 268         val = (reg >> LP3972_LDO_VOL_CONTR_SHIFT(ldo)) & mask;
 269
 270         return dev->desc->volt_table[val];
 271 }
 272
 273 static int lp3972_ldo_set_voltage_sel(struct regulator_dev *dev,
 274                                       unsigned int selector)
 275 {
 276         struct lp3972 *lp3972 = rdev_get_drvdata(dev);
 277         int ldo = rdev_get_id(dev) - LP3972_LDO1;
 278         int shift, ret;
 279
 280         shift = LP3972_LDO_VOL_CONTR_SHIFT(ldo);
 281         ret = lp3972_set_bits(lp3972, LP3972_LDO_VOL_CONTR_REG(ldo),
 282                 LP3972_LDO_VOL_MASK(ldo) << shift, selector << shift);
 283
 284         if (ret)
 285                 return ret;
 286
 287         /*
 288          * LDO1 and LDO5 support voltage control by either target voltage1
 289          * or target voltage2 register.
 290          * We use target voltage1 register for LDO1 and LDO5 in this driver.
 291          * We need to update voltage change control register(0x20) to enable
 292          * LDO1 and LDO5 to change to their programmed target values.
 293          */
 294         switch (ldo) {
 295         case LP3972_LDO1:
 296         case LP3972_LDO5:
 297                 shift = LP3972_LDO_VOL_CHANGE_SHIFT(ldo);
 298                 ret = lp3972_set_bits(lp3972, LP3972_VOL_CHANGE_REG,
 299                         LP3972_VOL_CHANGE_FLAG_MASK << shift,
 300                         LP3972_VOL_CHANGE_FLAG_GO << shift);
 301                 if (ret)
 302                         return ret;
 303
 304                 ret = lp3972_set_bits(lp3972, LP3972_VOL_CHANGE_REG,
 305                         LP3972_VOL_CHANGE_FLAG_MASK << shift, 0);
 306                 break;
 307         }
 308
 309         return ret;
 310 }
 311
 312 static struct regulator_ops lp3972_ldo_ops = {
 313         .list_voltage = regulator_list_voltage_table,
 314         .is_enabled = lp3972_ldo_is_enabled,
 315         .enable = lp3972_ldo_enable,
 316         .disable = lp3972_ldo_disable,
 317         .get_voltage = lp3972_ldo_get_voltage,
 318         .set_voltage_sel = lp3972_ldo_set_voltage_sel,
 319 };
 320
 321 static int lp3972_dcdc_is_enabled(struct regulator_dev *dev)
 322 {
 323         struct lp3972 *lp3972 = rdev_get_drvdata(dev);
 324         int buck = rdev_get_id(dev) - LP3972_DCDC1;
 325         u16 mask = 1 << (buck * 2);
 326         u16 val;
 327
 328         val = lp3972_reg_read(lp3972, LP3972_BUCK_VOL_ENABLE_REG(buck));
 329         return !!(val & mask);
 330 }
 331
 332 static int lp3972_dcdc_enable(struct regulator_dev *dev)
 333 {
 334         struct lp3972 *lp3972 = rdev_get_drvdata(dev);
 335         int buck = rdev_get_id(dev) - LP3972_DCDC1;
 336         u16 mask = 1 << (buck * 2);
 337         u16 val;
 338
 339         val = lp3972_set_bits(lp3972, LP3972_BUCK_VOL_ENABLE_REG(buck),
 340                                 mask, mask);
 341         return val;
 342 }
 343
 344 static int lp3972_dcdc_disable(struct regulator_dev *dev)
 345 {
 346         struct lp3972 *lp3972 = rdev_get_drvdata(dev);
 347         int buck = rdev_get_id(dev) - LP3972_DCDC1;
 348         u16 mask = 1 << (buck * 2);
 349         u16 val;
 350
 351         val = lp3972_set_bits(lp3972, LP3972_BUCK_VOL_ENABLE_REG(buck),
 352                                 mask, 0);
 353         return val;
 354 }
 355
 356 static int lp3972_dcdc_get_voltage(struct regulator_dev *dev)
 357 {
 358         struct lp3972 *lp3972 = rdev_get_drvdata(dev);
 359         int buck = rdev_get_id(dev) - LP3972_DCDC1;
 360         u16 reg;
 361         int val;
 362
 363         reg = lp3972_reg_read(lp3972, LP3972_BUCK_VOL1_REG(buck));
 364         reg &= LP3972_BUCK_VOL_MASK;
 365         if (reg <= LP3972_BUCK_VOL_MAX_IDX(buck))
 366                 val = dev->desc->volt_table[reg];
 367         else {
 368                 val = 0;
 369                 dev_warn(&dev->dev, "chip reported incorrect voltage value."
 370                                     " reg = %d\n", reg);
 371         }
 372
 373         return val;
 374 }
 375
 376 static int lp3972_dcdc_set_voltage_sel(struct regulator_dev *dev,
 377                                        unsigned int selector)
 378 {
 379         struct lp3972 *lp3972 = rdev_get_drvdata(dev);
 380         int buck = rdev_get_id(dev) - LP3972_DCDC1;
 381         int ret;
 382
 383         ret = lp3972_set_bits(lp3972, LP3972_BUCK_VOL1_REG(buck),
 384                                 LP3972_BUCK_VOL_MASK, selector);
 385         if (ret)
 386                 return ret;
 387
 388         if (buck != 0)
 389                 return ret;
 390
 391         ret = lp3972_set_bits(lp3972, LP3972_VOL_CHANGE_REG,
 392                 LP3972_VOL_CHANGE_FLAG_MASK, LP3972_VOL_CHANGE_FLAG_GO);
 393         if (ret)
 394                 return ret;
 395
 396         return lp3972_set_bits(lp3972, LP3972_VOL_CHANGE_REG,
 397                                 LP3972_VOL_CHANGE_FLAG_MASK, 0);
 398 }
 399
 400 static struct regulator_ops lp3972_dcdc_ops = {
 401         .list_voltage = regulator_list_voltage_table,
 402         .is_enabled = lp3972_dcdc_is_enabled,
 403         .enable = lp3972_dcdc_enable,
 404         .disable = lp3972_dcdc_disable,
 405         .get_voltage = lp3972_dcdc_get_voltage,
 406         .set_voltage_sel = lp3972_dcdc_set_voltage_sel,
 407 };
 408
 409 static const struct regulator_desc regulators[] = {
 410         {
 411                 .name = "LDO1",
 412                 .id = LP3972_LDO1,
 413                 .ops = &lp3972_ldo_ops,
 414                 .n_voltages = ARRAY_SIZE(ldo1_voltage_map),
 415                 .volt_table = ldo1_voltage_map,
 416                 .type = REGULATOR_VOLTAGE,
 417                 .owner = THIS_MODULE,
 418         },
 419         {
 420                 .name = "LDO2",
 421                 .id = LP3972_LDO2,
 422                 .ops = &lp3972_ldo_ops,
 423                 .n_voltages = ARRAY_SIZE(ldo23_voltage_map),
 424                 .volt_table = ldo23_voltage_map,
 425                 .type = REGULATOR_VOLTAGE,
 426                 .owner = THIS_MODULE,
 427         },
 428         {
 429                 .name = "LDO3",
 430                 .id = LP3972_LDO3,
 431                 .ops = &lp3972_ldo_ops,
 432                 .n_voltages = ARRAY_SIZE(ldo23_voltage_map),
 433                 .volt_table = ldo23_voltage_map,
 434                 .type = REGULATOR_VOLTAGE,
 435                 .owner = THIS_MODULE,
 436         },
 437         {
 438                 .name = "LDO4",
 439                 .id = LP3972_LDO4,
 440                 .ops = &lp3972_ldo_ops,
 441                 .n_voltages = ARRAY_SIZE(ldo4_voltage_map),
 442                 .volt_table = ldo4_voltage_map,
 443                 .type = REGULATOR_VOLTAGE,
 444                 .owner = THIS_MODULE,
 445         },
 446         {
 447                 .name = "LDO5",
 448                 .id = LP3972_LDO5,
 449                 .ops = &lp3972_ldo_ops,
 450                 .n_voltages = ARRAY_SIZE(ldo5_voltage_map),
 451                 .volt_table = ldo5_voltage_map,
 452                 .type = REGULATOR_VOLTAGE,
 453                 .owner = THIS_MODULE,
 454         },
 455         {
 456                 .name = "DCDC1",
 457                 .id = LP3972_DCDC1,
 458                 .ops = &lp3972_dcdc_ops,
 459                 .n_voltages = ARRAY_SIZE(buck1_voltage_map),
 460                 .volt_table = buck1_voltage_map,
 461                 .type = REGULATOR_VOLTAGE,
 462                 .owner = THIS_MODULE,
 463         },
 464         {
 465                 .name = "DCDC2",
 466                 .id = LP3972_DCDC2,
 467                 .ops = &lp3972_dcdc_ops,
 468                 .n_voltages = ARRAY_SIZE(buck23_voltage_map),
 469                 .volt_table = buck23_voltage_map,
 470                 .type = REGULATOR_VOLTAGE,
 471                 .owner = THIS_MODULE,
 472         },
 473         {
 474                 .name = "DCDC3",
 475                 .id = LP3972_DCDC3,
 476                 .ops = &lp3972_dcdc_ops,
 477                 .n_voltages = ARRAY_SIZE(buck23_voltage_map),
 478                 .volt_table = buck23_voltage_map,
 479                 .type = REGULATOR_VOLTAGE,
 480                 .owner = THIS_MODULE,
 481         },
 482 };
 483
 484 static int setup_regulators(struct lp3972 *lp3972,
 485         struct lp3972_platform_data *pdata)
 486 {
 487         int i, err;
 488
 489         lp3972->num_regulators = pdata->num_regulators;
 490         lp3972->rdev = kcalloc(pdata->num_regulators,
 491                                 sizeof(struct regulator_dev *), GFP_KERNEL);
 492         if (!lp3972->rdev) {
 493                 err = -ENOMEM;
 494                 goto err_nomem;
 495         }
 496
 497         /* Instantiate the regulators */
 498         for (i = 0; i < pdata->num_regulators; i++) {
 499                 struct lp3972_regulator_subdev *reg = &pdata->regulators[i];
 500                 struct regulator_config config = { };
 501
 502                 config.dev = lp3972->dev;
 503                 config.init_data = reg->initdata;
 504                 config.driver_data = lp3972;
 505
 506                 lp3972->rdev[i] = regulator_register(&regulators[reg->id],
 507                                                      &config);
 508                 if (IS_ERR(lp3972->rdev[i])) {
 509                         err = PTR_ERR(lp3972->rdev[i]);
 510                         dev_err(lp3972->dev, "regulator init failed: %d\n",
 511                                 err);
 512                         goto error;
 513                 }
 514         }
 515
 516         return 0;
 517 error:
 518         while (--i >= 0)
 519                 regulator_unregister(lp3972->rdev[i]);
 520         kfree(lp3972->rdev);
 521         lp3972->rdev = NULL;
 522 err_nomem:
 523         return err;
 524 }
 525
 526 static int lp3972_i2c_probe(struct i2c_client *i2c,
 527                             const struct i2c_device_id *id)
 528 {
 529         struct lp3972 *lp3972;
 530         struct lp3972_platform_data *pdata = i2c->dev.platform_data;
 531         int ret;
 532         u16 val;
 533
 534         if (!pdata) {
 535                 dev_dbg(&i2c->dev, "No platform init data supplied\n");
 536                 return -ENODEV;
 537         }
 538
 539         lp3972 = kzalloc(sizeof(struct lp3972), GFP_KERNEL);
 540         if (!lp3972)
 541                 return -ENOMEM;
 542
 543         lp3972->i2c = i2c;
 544         lp3972->dev = &i2c->dev;
 545
 546         mutex_init(&lp3972->io_lock);
 547
 548         /* Detect LP3972 */
 549         ret = lp3972_i2c_read(i2c, LP3972_SYS_CONTROL1_REG, 1, &val);
 550         if (ret == 0 &&
 551                 (val & SYS_CONTROL1_INIT_MASK) != SYS_CONTROL1_INIT_VAL) {
 552                 ret = -ENODEV;
 553                 dev_err(&i2c->dev, "chip reported: val = 0x%x\n", val);
 554         }
 555         if (ret < 0) {
 556                 dev_err(&i2c->dev, "failed to detect device. ret = %d\n", ret);
 557                 goto err_detect;
 558         }
 559
 560         ret = setup_regulators(lp3972, pdata);
 561         if (ret < 0)
 562                 goto err_detect;
 563
 564         i2c_set_clientdata(i2c, lp3972);
 565         return 0;
 566
 567 err_detect:
 568         kfree(lp3972);
 569         return ret;
 570 }
 571
 572 static int lp3972_i2c_remove(struct i2c_client *i2c)
 573 {
 574         struct lp3972 *lp3972 = i2c_get_clientdata(i2c);
 575         int i;
 576
 577         for (i = 0; i < lp3972->num_regulators; i++)
 578                 regulator_unregister(lp3972->rdev[i]);
 579         kfree(lp3972->rdev);
 580         kfree(lp3972);
 581
 582         return 0;
 583 }
 584
 585 static const struct i2c_device_id lp3972_i2c_id[] = {
 586         { "lp3972", 0 },
 587         { }
 588 };
 589 MODULE_DEVICE_TABLE(i2c, lp3972_i2c_id);
 590
 591 static struct i2c_driver lp3972_i2c_driver = {
 592         .driver = {
 593                 .name = "lp3972",
 594                 .owner = THIS_MODULE,
 595         },
 596         .probe    = lp3972_i2c_probe,
 597         .remove   = lp3972_i2c_remove,
 598         .id_table = lp3972_i2c_id,
 599 };
 600
 601 static int __init lp3972_module_init(void)
 602 {
 603         return i2c_add_driver(&lp3972_i2c_driver);
 604 }
 605 subsys_initcall(lp3972_module_init);
 606
 607 static void __exit lp3972_module_exit(void)
 608 {
 609         i2c_del_driver(&lp3972_i2c_driver);
 610 }
 611 module_exit(lp3972_module_exit);
 612
 613 MODULE_LICENSE("GPL");
 614 MODULE_AUTHOR("Axel Lin <axel.lin@gmail.com>");
 615 MODULE_DESCRIPTION("LP3972 PMIC driver");