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 int ldo1_voltage_map[] = { 78 1700, 1725, 1750, 1775, 1800, 1825, 1850, 1875, 79 1900, 1925, 1950, 1975, 2000, 80 }; 81 82 static const int ldo23_voltage_map[] = { 83 1800, 1900, 2000, 2100, 2200, 2300, 2400, 2500, 84 2600, 2700, 2800, 2900, 3000, 3100, 3200, 3300, 85 }; 86 87 static const int ldo4_voltage_map[] = { 88 1000, 1050, 1100, 1150, 1200, 1250, 1300, 1350, 89 1400, 1500, 1800, 1900, 2500, 2800, 3000, 3300, 90 }; 91 92 static const int ldo5_voltage_map[] = { 93 0, 0, 0, 0, 0, 850, 875, 900, 94 925, 950, 975, 1000, 1025, 1050, 1075, 1100, 95 1125, 1150, 1175, 1200, 1225, 1250, 1275, 1300, 96 1325, 1350, 1375, 1400, 1425, 1450, 1475, 1500, 97 }; 98 99 static const int buck1_voltage_map[] = { 100 725, 750, 775, 800, 825, 850, 875, 900, 101 925, 950, 975, 1000, 1025, 1050, 1075, 1100, 102 1125, 1150, 1175, 1200, 1225, 1250, 1275, 1300, 103 1325, 1350, 1375, 1400, 1425, 1450, 1475, 1500, 104 }; 105 106 static const int buck23_voltage_map[] = { 107 0, 800, 850, 900, 950, 1000, 1050, 1100, 108 1150, 1200, 1250, 1300, 1350, 1400, 1450, 1500, 109 1550, 1600, 1650, 1700, 1800, 1900, 2500, 2800, 110 3000, 3300, 111 }; 112 113 static const int *ldo_voltage_map[] = { 114 ldo1_voltage_map, 115 ldo23_voltage_map, 116 ldo23_voltage_map, 117 ldo4_voltage_map, 118 ldo5_voltage_map, 119 }; 120 121 static const int *buck_voltage_map[] = { 122 buck1_voltage_map, 123 buck23_voltage_map, 124 buck23_voltage_map, 125 }; 126 127 static const int ldo_output_enable_mask[] = { 128 LP3972_OEN3_L1EN, 129 LP3972_OVER2_LDO2_EN, 130 LP3972_OVER2_LDO3_EN, 131 LP3972_OVER2_LDO4_EN, 132 LP3972_OVER1_S_EN, 133 }; 134 135 static const int ldo_output_enable_addr[] = { 136 LP3972_OEN3_REG, 137 LP3972_OVER2_REG, 138 LP3972_OVER2_REG, 139 LP3972_OVER2_REG, 140 LP3972_OVER1_REG, 141 }; 142 143 static const int ldo_vol_ctl_addr[] = { 144 LP3972_MDTV1_REG, 145 LP3972_L2VCR_REG, 146 LP3972_L34VCR_REG, 147 LP3972_L34VCR_REG, 148 LP3972_SDTV1_REG, 149 }; 150 151 static const int buck_vol_enable_addr[] = { 152 LP3972_OVER1_REG, 153 LP3972_OEN3_REG, 154 LP3972_OEN3_REG, 155 }; 156 157 static const int buck_base_addr[] = { 158 LP3972_ADTV1_REG, 159 LP3972_B2TV_REG, 160 LP3972_B3TV_REG, 161 }; 162 163 #define LP3972_LDO_VOL_VALUE_MAP(x) (ldo_voltage_map[x]) 164 #define LP3972_LDO_OUTPUT_ENABLE_MASK(x) (ldo_output_enable_mask[x]) 165 #define LP3972_LDO_OUTPUT_ENABLE_REG(x) (ldo_output_enable_addr[x]) 166 167 /* LDO voltage control registers shift: 168 LP3972_LDO1 -> 0, LP3972_LDO2 -> 4 169 LP3972_LDO3 -> 0, LP3972_LDO4 -> 4 170 LP3972_LDO5 -> 0 171 */ 172 #define LP3972_LDO_VOL_CONTR_SHIFT(x) (((x) & 1) << 2) 173 #define LP3972_LDO_VOL_CONTR_REG(x) (ldo_vol_ctl_addr[x]) 174 #define LP3972_LDO_VOL_CHANGE_SHIFT(x) ((x) ? 4 : 6) 175 176 #define LP3972_LDO_VOL_MASK(x) (((x) % 4) ? 0x0f : 0x1f) 177 #define LP3972_LDO_VOL_MIN_IDX(x) (((x) == 4) ? 0x05 : 0x00) 178 #define LP3972_LDO_VOL_MAX_IDX(x) ((x) ? (((x) == 4) ? 0x1f : 0x0f) : 0x0c) 179 180 #define LP3972_BUCK_VOL_VALUE_MAP(x) (buck_voltage_map[x]) 181 #define LP3972_BUCK_VOL_ENABLE_REG(x) (buck_vol_enable_addr[x]) 182 #define LP3972_BUCK_VOL1_REG(x) (buck_base_addr[x]) 183 #define LP3972_BUCK_VOL_MASK 0x1f 184 #define LP3972_BUCK_VOL_MIN_IDX(x) ((x) ? 0x01 : 0x00) 185 #define LP3972_BUCK_VOL_MAX_IDX(x) ((x) ? 0x19 : 0x1f) 186 187 static int lp3972_i2c_read(struct i2c_client *i2c, char reg, int count, 188 u16 *dest) 189 { 190 int ret; 191 192 if (count != 1) 193 return -EIO; 194 ret = i2c_smbus_read_byte_data(i2c, reg); 195 if (ret < 0) 196 return ret; 197 198 *dest = ret; 199 return 0; 200 } 201 202 static int lp3972_i2c_write(struct i2c_client *i2c, char reg, int count, 203 const u16 *src) 204 { 205 if (count != 1) 206 return -EIO; 207 return i2c_smbus_write_byte_data(i2c, reg, *src); 208 } 209 210 static u8 lp3972_reg_read(struct lp3972 *lp3972, u8 reg) 211 { 212 u16 val = 0; 213 214 mutex_lock(&lp3972->io_lock); 215 216 lp3972_i2c_read(lp3972->i2c, reg, 1, &val); 217 218 dev_dbg(lp3972->dev, "reg read 0x%02x -> 0x%02x\n", (int)reg, 219 (unsigned)val & 0xff); 220 221 mutex_unlock(&lp3972->io_lock); 222 223 return val & 0xff; 224 } 225 226 static int lp3972_set_bits(struct lp3972 *lp3972, u8 reg, u16 mask, u16 val) 227 { 228 u16 tmp; 229 int ret; 230 231 mutex_lock(&lp3972->io_lock); 232 233 ret = lp3972_i2c_read(lp3972->i2c, reg, 1, &tmp); 234 tmp = (tmp & ~mask) | val; 235 if (ret == 0) { 236 ret = lp3972_i2c_write(lp3972->i2c, reg, 1, &tmp); 237 dev_dbg(lp3972->dev, "reg write 0x%02x -> 0x%02x\n", (int)reg, 238 (unsigned)val & 0xff); 239 } 240 mutex_unlock(&lp3972->io_lock); 241 242 return ret; 243 } 244 245 static int lp3972_ldo_list_voltage(struct regulator_dev *dev, unsigned index) 246 { 247 int ldo = rdev_get_id(dev) - LP3972_LDO1; 248 249 if (index < LP3972_LDO_VOL_MIN_IDX(ldo) || 250 index > LP3972_LDO_VOL_MAX_IDX(ldo)) 251 return -EINVAL; 252 253 return 1000 * LP3972_LDO_VOL_VALUE_MAP(ldo)[index]; 254 } 255 256 static int lp3972_ldo_is_enabled(struct regulator_dev *dev) 257 { 258 struct lp3972 *lp3972 = rdev_get_drvdata(dev); 259 int ldo = rdev_get_id(dev) - LP3972_LDO1; 260 u16 mask = LP3972_LDO_OUTPUT_ENABLE_MASK(ldo); 261 u16 val; 262 263 val = lp3972_reg_read(lp3972, LP3972_LDO_OUTPUT_ENABLE_REG(ldo)); 264 return !!(val & mask); 265 } 266 267 static int lp3972_ldo_enable(struct regulator_dev *dev) 268 { 269 struct lp3972 *lp3972 = rdev_get_drvdata(dev); 270 int ldo = rdev_get_id(dev) - LP3972_LDO1; 271 u16 mask = LP3972_LDO_OUTPUT_ENABLE_MASK(ldo); 272 273 return lp3972_set_bits(lp3972, LP3972_LDO_OUTPUT_ENABLE_REG(ldo), 274 mask, mask); 275 } 276 277 static int lp3972_ldo_disable(struct regulator_dev *dev) 278 { 279 struct lp3972 *lp3972 = rdev_get_drvdata(dev); 280 int ldo = rdev_get_id(dev) - LP3972_LDO1; 281 u16 mask = LP3972_LDO_OUTPUT_ENABLE_MASK(ldo); 282 283 return lp3972_set_bits(lp3972, LP3972_LDO_OUTPUT_ENABLE_REG(ldo), 284 mask, 0); 285 } 286 287 static int lp3972_ldo_get_voltage(struct regulator_dev *dev) 288 { 289 struct lp3972 *lp3972 = rdev_get_drvdata(dev); 290 int ldo = rdev_get_id(dev) - LP3972_LDO1; 291 u16 mask = LP3972_LDO_VOL_MASK(ldo); 292 u16 val, reg; 293 294 reg = lp3972_reg_read(lp3972, LP3972_LDO_VOL_CONTR_REG(ldo)); 295 val = (reg >> LP3972_LDO_VOL_CONTR_SHIFT(ldo)) & mask; 296 297 return 1000 * LP3972_LDO_VOL_VALUE_MAP(ldo)[val]; 298 } 299 300 static int lp3972_ldo_set_voltage_sel(struct regulator_dev *dev, 301 unsigned int selector) 302 { 303 struct lp3972 *lp3972 = rdev_get_drvdata(dev); 304 int ldo = rdev_get_id(dev) - LP3972_LDO1; 305 int shift, ret; 306 307 shift = LP3972_LDO_VOL_CONTR_SHIFT(ldo); 308 ret = lp3972_set_bits(lp3972, LP3972_LDO_VOL_CONTR_REG(ldo), 309 LP3972_LDO_VOL_MASK(ldo) << shift, selector << shift); 310 311 if (ret) 312 return ret; 313 314 /* 315 * LDO1 and LDO5 support voltage control by either target voltage1 316 * or target voltage2 register. 317 * We use target voltage1 register for LDO1 and LDO5 in this driver. 318 * We need to update voltage change control register(0x20) to enable 319 * LDO1 and LDO5 to change to their programmed target values. 320 */ 321 switch (ldo) { 322 case LP3972_LDO1: 323 case LP3972_LDO5: 324 shift = LP3972_LDO_VOL_CHANGE_SHIFT(ldo); 325 ret = lp3972_set_bits(lp3972, LP3972_VOL_CHANGE_REG, 326 LP3972_VOL_CHANGE_FLAG_MASK << shift, 327 LP3972_VOL_CHANGE_FLAG_GO << shift); 328 if (ret) 329 return ret; 330 331 ret = lp3972_set_bits(lp3972, LP3972_VOL_CHANGE_REG, 332 LP3972_VOL_CHANGE_FLAG_MASK << shift, 0); 333 break; 334 } 335 336 return ret; 337 } 338 339 static struct regulator_ops lp3972_ldo_ops = { 340 .list_voltage = lp3972_ldo_list_voltage, 341 .is_enabled = lp3972_ldo_is_enabled, 342 .enable = lp3972_ldo_enable, 343 .disable = lp3972_ldo_disable, 344 .get_voltage = lp3972_ldo_get_voltage, 345 .set_voltage_sel = lp3972_ldo_set_voltage_sel, 346 }; 347 348 static int lp3972_dcdc_list_voltage(struct regulator_dev *dev, unsigned index) 349 { 350 int buck = rdev_get_id(dev) - LP3972_DCDC1; 351 352 if (index < LP3972_BUCK_VOL_MIN_IDX(buck) || 353 index > LP3972_BUCK_VOL_MAX_IDX(buck)) 354 return -EINVAL; 355 356 return 1000 * buck_voltage_map[buck][index]; 357 } 358 359 static int lp3972_dcdc_is_enabled(struct regulator_dev *dev) 360 { 361 struct lp3972 *lp3972 = rdev_get_drvdata(dev); 362 int buck = rdev_get_id(dev) - LP3972_DCDC1; 363 u16 mask = 1 << (buck * 2); 364 u16 val; 365 366 val = lp3972_reg_read(lp3972, LP3972_BUCK_VOL_ENABLE_REG(buck)); 367 return !!(val & mask); 368 } 369 370 static int lp3972_dcdc_enable(struct regulator_dev *dev) 371 { 372 struct lp3972 *lp3972 = rdev_get_drvdata(dev); 373 int buck = rdev_get_id(dev) - LP3972_DCDC1; 374 u16 mask = 1 << (buck * 2); 375 u16 val; 376 377 val = lp3972_set_bits(lp3972, LP3972_BUCK_VOL_ENABLE_REG(buck), 378 mask, mask); 379 return val; 380 } 381 382 static int lp3972_dcdc_disable(struct regulator_dev *dev) 383 { 384 struct lp3972 *lp3972 = rdev_get_drvdata(dev); 385 int buck = rdev_get_id(dev) - LP3972_DCDC1; 386 u16 mask = 1 << (buck * 2); 387 u16 val; 388 389 val = lp3972_set_bits(lp3972, LP3972_BUCK_VOL_ENABLE_REG(buck), 390 mask, 0); 391 return val; 392 } 393 394 static int lp3972_dcdc_get_voltage(struct regulator_dev *dev) 395 { 396 struct lp3972 *lp3972 = rdev_get_drvdata(dev); 397 int buck = rdev_get_id(dev) - LP3972_DCDC1; 398 u16 reg; 399 int val; 400 401 reg = lp3972_reg_read(lp3972, LP3972_BUCK_VOL1_REG(buck)); 402 reg &= LP3972_BUCK_VOL_MASK; 403 if (reg <= LP3972_BUCK_VOL_MAX_IDX(buck)) 404 val = 1000 * buck_voltage_map[buck][reg]; 405 else { 406 val = 0; 407 dev_warn(&dev->dev, "chip reported incorrect voltage value." 408 " reg = %d\n", reg); 409 } 410 411 return val; 412 } 413 414 static int lp3972_dcdc_set_voltage_sel(struct regulator_dev *dev, 415 unsigned int selector) 416 { 417 struct lp3972 *lp3972 = rdev_get_drvdata(dev); 418 int buck = rdev_get_id(dev) - LP3972_DCDC1; 419 int ret; 420 421 ret = lp3972_set_bits(lp3972, LP3972_BUCK_VOL1_REG(buck), 422 LP3972_BUCK_VOL_MASK, selector); 423 if (ret) 424 return ret; 425 426 if (buck != 0) 427 return ret; 428 429 ret = lp3972_set_bits(lp3972, LP3972_VOL_CHANGE_REG, 430 LP3972_VOL_CHANGE_FLAG_MASK, LP3972_VOL_CHANGE_FLAG_GO); 431 if (ret) 432 return ret; 433 434 return lp3972_set_bits(lp3972, LP3972_VOL_CHANGE_REG, 435 LP3972_VOL_CHANGE_FLAG_MASK, 0); 436 } 437 438 static struct regulator_ops lp3972_dcdc_ops = { 439 .list_voltage = lp3972_dcdc_list_voltage, 440 .is_enabled = lp3972_dcdc_is_enabled, 441 .enable = lp3972_dcdc_enable, 442 .disable = lp3972_dcdc_disable, 443 .get_voltage = lp3972_dcdc_get_voltage, 444 .set_voltage_sel = lp3972_dcdc_set_voltage_sel, 445 }; 446 447 static const struct regulator_desc regulators[] = { 448 { 449 .name = "LDO1", 450 .id = LP3972_LDO1, 451 .ops = &lp3972_ldo_ops, 452 .n_voltages = ARRAY_SIZE(ldo1_voltage_map), 453 .type = REGULATOR_VOLTAGE, 454 .owner = THIS_MODULE, 455 }, 456 { 457 .name = "LDO2", 458 .id = LP3972_LDO2, 459 .ops = &lp3972_ldo_ops, 460 .n_voltages = ARRAY_SIZE(ldo23_voltage_map), 461 .type = REGULATOR_VOLTAGE, 462 .owner = THIS_MODULE, 463 }, 464 { 465 .name = "LDO3", 466 .id = LP3972_LDO3, 467 .ops = &lp3972_ldo_ops, 468 .n_voltages = ARRAY_SIZE(ldo23_voltage_map), 469 .type = REGULATOR_VOLTAGE, 470 .owner = THIS_MODULE, 471 }, 472 { 473 .name = "LDO4", 474 .id = LP3972_LDO4, 475 .ops = &lp3972_ldo_ops, 476 .n_voltages = ARRAY_SIZE(ldo4_voltage_map), 477 .type = REGULATOR_VOLTAGE, 478 .owner = THIS_MODULE, 479 }, 480 { 481 .name = "LDO5", 482 .id = LP3972_LDO5, 483 .ops = &lp3972_ldo_ops, 484 .n_voltages = ARRAY_SIZE(ldo5_voltage_map), 485 .type = REGULATOR_VOLTAGE, 486 .owner = THIS_MODULE, 487 }, 488 { 489 .name = "DCDC1", 490 .id = LP3972_DCDC1, 491 .ops = &lp3972_dcdc_ops, 492 .n_voltages = ARRAY_SIZE(buck1_voltage_map), 493 .type = REGULATOR_VOLTAGE, 494 .owner = THIS_MODULE, 495 }, 496 { 497 .name = "DCDC2", 498 .id = LP3972_DCDC2, 499 .ops = &lp3972_dcdc_ops, 500 .n_voltages = ARRAY_SIZE(buck23_voltage_map), 501 .type = REGULATOR_VOLTAGE, 502 .owner = THIS_MODULE, 503 }, 504 { 505 .name = "DCDC3", 506 .id = LP3972_DCDC3, 507 .ops = &lp3972_dcdc_ops, 508 .n_voltages = ARRAY_SIZE(buck23_voltage_map), 509 .type = REGULATOR_VOLTAGE, 510 .owner = THIS_MODULE, 511 }, 512 }; 513 514 static int __devinit setup_regulators(struct lp3972 *lp3972, 515 struct lp3972_platform_data *pdata) 516 { 517 int i, err; 518 519 lp3972->num_regulators = pdata->num_regulators; 520 lp3972->rdev = kcalloc(pdata->num_regulators, 521 sizeof(struct regulator_dev *), GFP_KERNEL); 522 if (!lp3972->rdev) { 523 err = -ENOMEM; 524 goto err_nomem; 525 } 526 527 /* Instantiate the regulators */ 528 for (i = 0; i < pdata->num_regulators; i++) { 529 struct lp3972_regulator_subdev *reg = &pdata->regulators[i]; 530 struct regulator_config config = { }; 531 532 config.dev = lp3972->dev; 533 config.init_data = reg->initdata; 534 config.driver_data = lp3972; 535 536 lp3972->rdev[i] = regulator_register(®ulators[reg->id], 537 &config); 538 if (IS_ERR(lp3972->rdev[i])) { 539 err = PTR_ERR(lp3972->rdev[i]); 540 dev_err(lp3972->dev, "regulator init failed: %d\n", 541 err); 542 goto error; 543 } 544 } 545 546 return 0; 547 error: 548 while (--i >= 0) 549 regulator_unregister(lp3972->rdev[i]); 550 kfree(lp3972->rdev); 551 lp3972->rdev = NULL; 552 err_nomem: 553 return err; 554 } 555 556 static int __devinit lp3972_i2c_probe(struct i2c_client *i2c, 557 const struct i2c_device_id *id) 558 { 559 struct lp3972 *lp3972; 560 struct lp3972_platform_data *pdata = i2c->dev.platform_data; 561 int ret; 562 u16 val; 563 564 if (!pdata) { 565 dev_dbg(&i2c->dev, "No platform init data supplied\n"); 566 return -ENODEV; 567 } 568 569 lp3972 = kzalloc(sizeof(struct lp3972), GFP_KERNEL); 570 if (!lp3972) 571 return -ENOMEM; 572 573 lp3972->i2c = i2c; 574 lp3972->dev = &i2c->dev; 575 576 mutex_init(&lp3972->io_lock); 577 578 /* Detect LP3972 */ 579 ret = lp3972_i2c_read(i2c, LP3972_SYS_CONTROL1_REG, 1, &val); 580 if (ret == 0 && 581 (val & SYS_CONTROL1_INIT_MASK) != SYS_CONTROL1_INIT_VAL) { 582 ret = -ENODEV; 583 dev_err(&i2c->dev, "chip reported: val = 0x%x\n", val); 584 } 585 if (ret < 0) { 586 dev_err(&i2c->dev, "failed to detect device. ret = %d\n", ret); 587 goto err_detect; 588 } 589 590 ret = setup_regulators(lp3972, pdata); 591 if (ret < 0) 592 goto err_detect; 593 594 i2c_set_clientdata(i2c, lp3972); 595 return 0; 596 597 err_detect: 598 kfree(lp3972); 599 return ret; 600 } 601 602 static int __devexit lp3972_i2c_remove(struct i2c_client *i2c) 603 { 604 struct lp3972 *lp3972 = i2c_get_clientdata(i2c); 605 int i; 606 607 for (i = 0; i < lp3972->num_regulators; i++) 608 regulator_unregister(lp3972->rdev[i]); 609 kfree(lp3972->rdev); 610 kfree(lp3972); 611 612 return 0; 613 } 614 615 static const struct i2c_device_id lp3972_i2c_id[] = { 616 { "lp3972", 0 }, 617 { } 618 }; 619 MODULE_DEVICE_TABLE(i2c, lp3972_i2c_id); 620 621 static struct i2c_driver lp3972_i2c_driver = { 622 .driver = { 623 .name = "lp3972", 624 .owner = THIS_MODULE, 625 }, 626 .probe = lp3972_i2c_probe, 627 .remove = __devexit_p(lp3972_i2c_remove), 628 .id_table = lp3972_i2c_id, 629 }; 630 631 static int __init lp3972_module_init(void) 632 { 633 return i2c_add_driver(&lp3972_i2c_driver); 634 } 635 subsys_initcall(lp3972_module_init); 636 637 static void __exit lp3972_module_exit(void) 638 { 639 i2c_del_driver(&lp3972_i2c_driver); 640 } 641 module_exit(lp3972_module_exit); 642 643 MODULE_LICENSE("GPL"); 644 MODULE_AUTHOR("Axel Lin <axel.lin@gmail.com>"); 645 MODULE_DESCRIPTION("LP3972 PMIC driver"); 646