linux/drivers/regulator/lp3972.c
<<
>>
Prefs
   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
  21struct 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
  77static const unsigned int ldo1_voltage_map[] = {
  78        1700000, 1725000, 1750000, 1775000, 1800000, 1825000, 1850000, 1875000,
  79        1900000, 1925000, 1950000, 1975000, 2000000,
  80};
  81
  82static 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
  87static 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
  92static 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
  99static 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
 106static 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
 113static 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
 121static 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
 129static 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
 137static const int buck_vol_enable_addr[] = {
 138        LP3972_OVER1_REG,
 139        LP3972_OEN3_REG,
 140        LP3972_OEN3_REG,
 141};
 142
 143static 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
 171static 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
 186static 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
 194static 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
 210static 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
 229static 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
 240static 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
 250static 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
 260static 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
 273static 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
 312static 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
 321static 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
 332static 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
 344static 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
 356static 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
 376static 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
 400static 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
 409static 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
 484static 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;
 517error:
 518        while (--i >= 0)
 519                regulator_unregister(lp3972->rdev[i]);
 520        kfree(lp3972->rdev);
 521        lp3972->rdev = NULL;
 522err_nomem:
 523        return err;
 524}
 525
 526static 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
 567err_detect:
 568        kfree(lp3972);
 569        return ret;
 570}
 571
 572static 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
 585static const struct i2c_device_id lp3972_i2c_id[] = {
 586        { "lp3972", 0 },
 587        { }
 588};
 589MODULE_DEVICE_TABLE(i2c, lp3972_i2c_id);
 590
 591static 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
 601static int __init lp3972_module_init(void)
 602{
 603        return i2c_add_driver(&lp3972_i2c_driver);
 604}
 605subsys_initcall(lp3972_module_init);
 606
 607static void __exit lp3972_module_exit(void)
 608{
 609        i2c_del_driver(&lp3972_i2c_driver);
 610}
 611module_exit(lp3972_module_exit);
 612
 613MODULE_LICENSE("GPL");
 614MODULE_AUTHOR("Axel Lin <axel.lin@gmail.com>");
 615MODULE_DESCRIPTION("LP3972 PMIC driver");
 616
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.