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
 169static int lp3972_i2c_read(struct i2c_client *i2c, char reg, int count,
 170        u16 *dest)
 171{
 172        int ret;
 173
 174        if (count != 1)
 175                return -EIO;
 176        ret = i2c_smbus_read_byte_data(i2c, reg);
 177        if (ret < 0)
 178                return ret;
 179
 180        *dest = ret;
 181        return 0;
 182}
 183
 184static int lp3972_i2c_write(struct i2c_client *i2c, char reg, int count,
 185        const u16 *src)
 186{
 187        if (count != 1)
 188                return -EIO;
 189        return i2c_smbus_write_byte_data(i2c, reg, *src);
 190}
 191
 192static u8 lp3972_reg_read(struct lp3972 *lp3972, u8 reg)
 193{
 194        u16 val = 0;
 195
 196        mutex_lock(&lp3972->io_lock);
 197
 198        lp3972_i2c_read(lp3972->i2c, reg, 1, &val);
 199
 200        dev_dbg(lp3972->dev, "reg read 0x%02x -> 0x%02x\n", (int)reg,
 201                (unsigned)val & 0xff);
 202
 203        mutex_unlock(&lp3972->io_lock);
 204
 205        return val & 0xff;
 206}
 207
 208static int lp3972_set_bits(struct lp3972 *lp3972, u8 reg, u16 mask, u16 val)
 209{
 210        u16 tmp;
 211        int ret;
 212
 213        mutex_lock(&lp3972->io_lock);
 214
 215        ret = lp3972_i2c_read(lp3972->i2c, reg, 1, &tmp);
 216        tmp = (tmp & ~mask) | val;
 217        if (ret == 0) {
 218                ret = lp3972_i2c_write(lp3972->i2c, reg, 1, &tmp);
 219                dev_dbg(lp3972->dev, "reg write 0x%02x -> 0x%02x\n", (int)reg,
 220                        (unsigned)val & 0xff);
 221        }
 222        mutex_unlock(&lp3972->io_lock);
 223
 224        return ret;
 225}
 226
 227static int lp3972_ldo_is_enabled(struct regulator_dev *dev)
 228{
 229        struct lp3972 *lp3972 = rdev_get_drvdata(dev);
 230        int ldo = rdev_get_id(dev) - LP3972_LDO1;
 231        u16 mask = LP3972_LDO_OUTPUT_ENABLE_MASK(ldo);
 232        u16 val;
 233
 234        val = lp3972_reg_read(lp3972, LP3972_LDO_OUTPUT_ENABLE_REG(ldo));
 235        return !!(val & mask);
 236}
 237
 238static int lp3972_ldo_enable(struct regulator_dev *dev)
 239{
 240        struct lp3972 *lp3972 = rdev_get_drvdata(dev);
 241        int ldo = rdev_get_id(dev) - LP3972_LDO1;
 242        u16 mask = LP3972_LDO_OUTPUT_ENABLE_MASK(ldo);
 243
 244        return lp3972_set_bits(lp3972, LP3972_LDO_OUTPUT_ENABLE_REG(ldo),
 245                                mask, mask);
 246}
 247
 248static int lp3972_ldo_disable(struct regulator_dev *dev)
 249{
 250        struct lp3972 *lp3972 = rdev_get_drvdata(dev);
 251        int ldo = rdev_get_id(dev) - LP3972_LDO1;
 252        u16 mask = LP3972_LDO_OUTPUT_ENABLE_MASK(ldo);
 253
 254        return lp3972_set_bits(lp3972, LP3972_LDO_OUTPUT_ENABLE_REG(ldo),
 255                                mask, 0);
 256}
 257
 258static int lp3972_ldo_get_voltage_sel(struct regulator_dev *dev)
 259{
 260        struct lp3972 *lp3972 = rdev_get_drvdata(dev);
 261        int ldo = rdev_get_id(dev) - LP3972_LDO1;
 262        u16 mask = LP3972_LDO_VOL_MASK(ldo);
 263        u16 val, reg;
 264
 265        reg = lp3972_reg_read(lp3972, LP3972_LDO_VOL_CONTR_REG(ldo));
 266        val = (reg >> LP3972_LDO_VOL_CONTR_SHIFT(ldo)) & mask;
 267
 268        return val;
 269}
 270
 271static int lp3972_ldo_set_voltage_sel(struct regulator_dev *dev,
 272                                      unsigned int selector)
 273{
 274        struct lp3972 *lp3972 = rdev_get_drvdata(dev);
 275        int ldo = rdev_get_id(dev) - LP3972_LDO1;
 276        int shift, ret;
 277
 278        shift = LP3972_LDO_VOL_CONTR_SHIFT(ldo);
 279        ret = lp3972_set_bits(lp3972, LP3972_LDO_VOL_CONTR_REG(ldo),
 280                LP3972_LDO_VOL_MASK(ldo) << shift, selector << shift);
 281
 282        if (ret)
 283                return ret;
 284
 285        /*
 286         * LDO1 and LDO5 support voltage control by either target voltage1
 287         * or target voltage2 register.
 288         * We use target voltage1 register for LDO1 and LDO5 in this driver.
 289         * We need to update voltage change control register(0x20) to enable
 290         * LDO1 and LDO5 to change to their programmed target values.
 291         */
 292        switch (ldo) {
 293        case LP3972_LDO1:
 294        case LP3972_LDO5:
 295                shift = LP3972_LDO_VOL_CHANGE_SHIFT(ldo);
 296                ret = lp3972_set_bits(lp3972, LP3972_VOL_CHANGE_REG,
 297                        LP3972_VOL_CHANGE_FLAG_MASK << shift,
 298                        LP3972_VOL_CHANGE_FLAG_GO << shift);
 299                if (ret)
 300                        return ret;
 301
 302                ret = lp3972_set_bits(lp3972, LP3972_VOL_CHANGE_REG,
 303                        LP3972_VOL_CHANGE_FLAG_MASK << shift, 0);
 304                break;
 305        }
 306
 307        return ret;
 308}
 309
 310static struct regulator_ops lp3972_ldo_ops = {
 311        .list_voltage = regulator_list_voltage_table,
 312        .map_voltage = regulator_map_voltage_ascend,
 313        .is_enabled = lp3972_ldo_is_enabled,
 314        .enable = lp3972_ldo_enable,
 315        .disable = lp3972_ldo_disable,
 316        .get_voltage_sel = lp3972_ldo_get_voltage_sel,
 317        .set_voltage_sel = lp3972_ldo_set_voltage_sel,
 318};
 319
 320static int lp3972_dcdc_is_enabled(struct regulator_dev *dev)
 321{
 322        struct lp3972 *lp3972 = rdev_get_drvdata(dev);
 323        int buck = rdev_get_id(dev) - LP3972_DCDC1;
 324        u16 mask = 1 << (buck * 2);
 325        u16 val;
 326
 327        val = lp3972_reg_read(lp3972, LP3972_BUCK_VOL_ENABLE_REG(buck));
 328        return !!(val & mask);
 329}
 330
 331static int lp3972_dcdc_enable(struct regulator_dev *dev)
 332{
 333        struct lp3972 *lp3972 = rdev_get_drvdata(dev);
 334        int buck = rdev_get_id(dev) - LP3972_DCDC1;
 335        u16 mask = 1 << (buck * 2);
 336        u16 val;
 337
 338        val = lp3972_set_bits(lp3972, LP3972_BUCK_VOL_ENABLE_REG(buck),
 339                                mask, mask);
 340        return val;
 341}
 342
 343static int lp3972_dcdc_disable(struct regulator_dev *dev)
 344{
 345        struct lp3972 *lp3972 = rdev_get_drvdata(dev);
 346        int buck = rdev_get_id(dev) - LP3972_DCDC1;
 347        u16 mask = 1 << (buck * 2);
 348        u16 val;
 349
 350        val = lp3972_set_bits(lp3972, LP3972_BUCK_VOL_ENABLE_REG(buck),
 351                                mask, 0);
 352        return val;
 353}
 354
 355static int lp3972_dcdc_get_voltage_sel(struct regulator_dev *dev)
 356{
 357        struct lp3972 *lp3972 = rdev_get_drvdata(dev);
 358        int buck = rdev_get_id(dev) - LP3972_DCDC1;
 359        u16 reg;
 360
 361        reg = lp3972_reg_read(lp3972, LP3972_BUCK_VOL1_REG(buck));
 362        reg &= LP3972_BUCK_VOL_MASK;
 363
 364        return reg;
 365}
 366
 367static int lp3972_dcdc_set_voltage_sel(struct regulator_dev *dev,
 368                                       unsigned int selector)
 369{
 370        struct lp3972 *lp3972 = rdev_get_drvdata(dev);
 371        int buck = rdev_get_id(dev) - LP3972_DCDC1;
 372        int ret;
 373
 374        ret = lp3972_set_bits(lp3972, LP3972_BUCK_VOL1_REG(buck),
 375                                LP3972_BUCK_VOL_MASK, selector);
 376        if (ret)
 377                return ret;
 378
 379        if (buck != 0)
 380                return ret;
 381
 382        ret = lp3972_set_bits(lp3972, LP3972_VOL_CHANGE_REG,
 383                LP3972_VOL_CHANGE_FLAG_MASK, LP3972_VOL_CHANGE_FLAG_GO);
 384        if (ret)
 385                return ret;
 386
 387        return lp3972_set_bits(lp3972, LP3972_VOL_CHANGE_REG,
 388                                LP3972_VOL_CHANGE_FLAG_MASK, 0);
 389}
 390
 391static struct regulator_ops lp3972_dcdc_ops = {
 392        .list_voltage = regulator_list_voltage_table,
 393        .map_voltage = regulator_map_voltage_ascend,
 394        .is_enabled = lp3972_dcdc_is_enabled,
 395        .enable = lp3972_dcdc_enable,
 396        .disable = lp3972_dcdc_disable,
 397        .get_voltage_sel = lp3972_dcdc_get_voltage_sel,
 398        .set_voltage_sel = lp3972_dcdc_set_voltage_sel,
 399};
 400
 401static const struct regulator_desc regulators[] = {
 402        {
 403                .name = "LDO1",
 404                .id = LP3972_LDO1,
 405                .ops = &lp3972_ldo_ops,
 406                .n_voltages = ARRAY_SIZE(ldo1_voltage_map),
 407                .volt_table = ldo1_voltage_map,
 408                .type = REGULATOR_VOLTAGE,
 409                .owner = THIS_MODULE,
 410        },
 411        {
 412                .name = "LDO2",
 413                .id = LP3972_LDO2,
 414                .ops = &lp3972_ldo_ops,
 415                .n_voltages = ARRAY_SIZE(ldo23_voltage_map),
 416                .volt_table = ldo23_voltage_map,
 417                .type = REGULATOR_VOLTAGE,
 418                .owner = THIS_MODULE,
 419        },
 420        {
 421                .name = "LDO3",
 422                .id = LP3972_LDO3,
 423                .ops = &lp3972_ldo_ops,
 424                .n_voltages = ARRAY_SIZE(ldo23_voltage_map),
 425                .volt_table = ldo23_voltage_map,
 426                .type = REGULATOR_VOLTAGE,
 427                .owner = THIS_MODULE,
 428        },
 429        {
 430                .name = "LDO4",
 431                .id = LP3972_LDO4,
 432                .ops = &lp3972_ldo_ops,
 433                .n_voltages = ARRAY_SIZE(ldo4_voltage_map),
 434                .volt_table = ldo4_voltage_map,
 435                .type = REGULATOR_VOLTAGE,
 436                .owner = THIS_MODULE,
 437        },
 438        {
 439                .name = "LDO5",
 440                .id = LP3972_LDO5,
 441                .ops = &lp3972_ldo_ops,
 442                .n_voltages = ARRAY_SIZE(ldo5_voltage_map),
 443                .volt_table = ldo5_voltage_map,
 444                .type = REGULATOR_VOLTAGE,
 445                .owner = THIS_MODULE,
 446        },
 447        {
 448                .name = "DCDC1",
 449                .id = LP3972_DCDC1,
 450                .ops = &lp3972_dcdc_ops,
 451                .n_voltages = ARRAY_SIZE(buck1_voltage_map),
 452                .volt_table = buck1_voltage_map,
 453                .type = REGULATOR_VOLTAGE,
 454                .owner = THIS_MODULE,
 455        },
 456        {
 457                .name = "DCDC2",
 458                .id = LP3972_DCDC2,
 459                .ops = &lp3972_dcdc_ops,
 460                .n_voltages = ARRAY_SIZE(buck23_voltage_map),
 461                .volt_table = buck23_voltage_map,
 462                .type = REGULATOR_VOLTAGE,
 463                .owner = THIS_MODULE,
 464        },
 465        {
 466                .name = "DCDC3",
 467                .id = LP3972_DCDC3,
 468                .ops = &lp3972_dcdc_ops,
 469                .n_voltages = ARRAY_SIZE(buck23_voltage_map),
 470                .volt_table = buck23_voltage_map,
 471                .type = REGULATOR_VOLTAGE,
 472                .owner = THIS_MODULE,
 473        },
 474};
 475
 476static int setup_regulators(struct lp3972 *lp3972,
 477        struct lp3972_platform_data *pdata)
 478{
 479        int i, err;
 480
 481        lp3972->num_regulators = pdata->num_regulators;
 482        lp3972->rdev = kcalloc(pdata->num_regulators,
 483                                sizeof(struct regulator_dev *), GFP_KERNEL);
 484        if (!lp3972->rdev) {
 485                err = -ENOMEM;
 486                goto err_nomem;
 487        }
 488
 489        /* Instantiate the regulators */
 490        for (i = 0; i < pdata->num_regulators; i++) {
 491                struct lp3972_regulator_subdev *reg = &pdata->regulators[i];
 492                struct regulator_config config = { };
 493
 494                config.dev = lp3972->dev;
 495                config.init_data = reg->initdata;
 496                config.driver_data = lp3972;
 497
 498                lp3972->rdev[i] = regulator_register(&regulators[reg->id],
 499                                                     &config);
 500                if (IS_ERR(lp3972->rdev[i])) {
 501                        err = PTR_ERR(lp3972->rdev[i]);
 502                        dev_err(lp3972->dev, "regulator init failed: %d\n",
 503                                err);
 504                        goto error;
 505                }
 506        }
 507
 508        return 0;
 509error:
 510        while (--i >= 0)
 511                regulator_unregister(lp3972->rdev[i]);
 512        kfree(lp3972->rdev);
 513        lp3972->rdev = NULL;
 514err_nomem:
 515        return err;
 516}
 517
 518static int lp3972_i2c_probe(struct i2c_client *i2c,
 519                            const struct i2c_device_id *id)
 520{
 521        struct lp3972 *lp3972;
 522        struct lp3972_platform_data *pdata = i2c->dev.platform_data;
 523        int ret;
 524        u16 val;
 525
 526        if (!pdata) {
 527                dev_dbg(&i2c->dev, "No platform init data supplied\n");
 528                return -ENODEV;
 529        }
 530
 531        lp3972 = kzalloc(sizeof(struct lp3972), GFP_KERNEL);
 532        if (!lp3972)
 533                return -ENOMEM;
 534
 535        lp3972->i2c = i2c;
 536        lp3972->dev = &i2c->dev;
 537
 538        mutex_init(&lp3972->io_lock);
 539
 540        /* Detect LP3972 */
 541        ret = lp3972_i2c_read(i2c, LP3972_SYS_CONTROL1_REG, 1, &val);
 542        if (ret == 0 &&
 543                (val & SYS_CONTROL1_INIT_MASK) != SYS_CONTROL1_INIT_VAL) {
 544                ret = -ENODEV;
 545                dev_err(&i2c->dev, "chip reported: val = 0x%x\n", val);
 546        }
 547        if (ret < 0) {
 548                dev_err(&i2c->dev, "failed to detect device. ret = %d\n", ret);
 549                goto err_detect;
 550        }
 551
 552        ret = setup_regulators(lp3972, pdata);
 553        if (ret < 0)
 554                goto err_detect;
 555
 556        i2c_set_clientdata(i2c, lp3972);
 557        return 0;
 558
 559err_detect:
 560        kfree(lp3972);
 561        return ret;
 562}
 563
 564static int lp3972_i2c_remove(struct i2c_client *i2c)
 565{
 566        struct lp3972 *lp3972 = i2c_get_clientdata(i2c);
 567        int i;
 568
 569        for (i = 0; i < lp3972->num_regulators; i++)
 570                regulator_unregister(lp3972->rdev[i]);
 571        kfree(lp3972->rdev);
 572        kfree(lp3972);
 573
 574        return 0;
 575}
 576
 577static const struct i2c_device_id lp3972_i2c_id[] = {
 578        { "lp3972", 0 },
 579        { }
 580};
 581MODULE_DEVICE_TABLE(i2c, lp3972_i2c_id);
 582
 583static struct i2c_driver lp3972_i2c_driver = {
 584        .driver = {
 585                .name = "lp3972",
 586                .owner = THIS_MODULE,
 587        },
 588        .probe    = lp3972_i2c_probe,
 589        .remove   = lp3972_i2c_remove,
 590        .id_table = lp3972_i2c_id,
 591};
 592
 593static int __init lp3972_module_init(void)
 594{
 595        return i2c_add_driver(&lp3972_i2c_driver);
 596}
 597subsys_initcall(lp3972_module_init);
 598
 599static void __exit lp3972_module_exit(void)
 600{
 601        i2c_del_driver(&lp3972_i2c_driver);
 602}
 603module_exit(lp3972_module_exit);
 604
 605MODULE_LICENSE("GPL");
 606MODULE_AUTHOR("Axel Lin <axel.lin@gmail.com>");
 607MODULE_DESCRIPTION("LP3972 PMIC driver");
 608
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.