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 return 1000 * LP3972_LDO_VOL_VALUE_MAP(ldo)[index]; 249 } 250 251 static int lp3972_ldo_is_enabled(struct regulator_dev *dev) 252 { 253 struct lp3972 *lp3972 = rdev_get_drvdata(dev); 254 int ldo = rdev_get_id(dev) - LP3972_LDO1; 255 u16 mask = LP3972_LDO_OUTPUT_ENABLE_MASK(ldo); 256 u16 val; 257 258 val = lp3972_reg_read(lp3972, LP3972_LDO_OUTPUT_ENABLE_REG(ldo)); 259 return !!(val & mask); 260 } 261 262 static int lp3972_ldo_enable(struct regulator_dev *dev) 263 { 264 struct lp3972 *lp3972 = rdev_get_drvdata(dev); 265 int ldo = rdev_get_id(dev) - LP3972_LDO1; 266 u16 mask = LP3972_LDO_OUTPUT_ENABLE_MASK(ldo); 267 268 return lp3972_set_bits(lp3972, LP3972_LDO_OUTPUT_ENABLE_REG(ldo), 269 mask, mask); 270 } 271 272 static int lp3972_ldo_disable(struct regulator_dev *dev) 273 { 274 struct lp3972 *lp3972 = rdev_get_drvdata(dev); 275 int ldo = rdev_get_id(dev) - LP3972_LDO1; 276 u16 mask = LP3972_LDO_OUTPUT_ENABLE_MASK(ldo); 277 278 return lp3972_set_bits(lp3972, LP3972_LDO_OUTPUT_ENABLE_REG(ldo), 279 mask, 0); 280 } 281 282 static int lp3972_ldo_get_voltage(struct regulator_dev *dev) 283 { 284 struct lp3972 *lp3972 = rdev_get_drvdata(dev); 285 int ldo = rdev_get_id(dev) - LP3972_LDO1; 286 u16 mask = LP3972_LDO_VOL_MASK(ldo); 287 u16 val, reg; 288 289 reg = lp3972_reg_read(lp3972, LP3972_LDO_VOL_CONTR_REG(ldo)); 290 val = (reg >> LP3972_LDO_VOL_CONTR_SHIFT(ldo)) & mask; 291 292 return 1000 * LP3972_LDO_VOL_VALUE_MAP(ldo)[val]; 293 } 294 295 static int lp3972_ldo_set_voltage(struct regulator_dev *dev, 296 int min_uV, int max_uV, 297 unsigned int *selector) 298 { 299 struct lp3972 *lp3972 = rdev_get_drvdata(dev); 300 int ldo = rdev_get_id(dev) - LP3972_LDO1; 301 int min_vol = min_uV / 1000, max_vol = max_uV / 1000; 302 const int *vol_map = LP3972_LDO_VOL_VALUE_MAP(ldo); 303 u16 val; 304 int shift, ret; 305 306 if (min_vol < vol_map[LP3972_LDO_VOL_MIN_IDX(ldo)] || 307 min_vol > vol_map[LP3972_LDO_VOL_MAX_IDX(ldo)]) 308 return -EINVAL; 309 310 for (val = LP3972_LDO_VOL_MIN_IDX(ldo); 311 val <= LP3972_LDO_VOL_MAX_IDX(ldo); val++) 312 if (vol_map[val] >= min_vol) 313 break; 314 315 if (val > LP3972_LDO_VOL_MAX_IDX(ldo) || vol_map[val] > max_vol) 316 return -EINVAL; 317 318 *selector = val; 319 320 shift = LP3972_LDO_VOL_CONTR_SHIFT(ldo); 321 ret = lp3972_set_bits(lp3972, LP3972_LDO_VOL_CONTR_REG(ldo), 322 LP3972_LDO_VOL_MASK(ldo) << shift, val << shift); 323 324 if (ret) 325 return ret; 326 327 /* 328 * LDO1 and LDO5 support voltage control by either target voltage1 329 * or target voltage2 register. 330 * We use target voltage1 register for LDO1 and LDO5 in this driver. 331 * We need to update voltage change control register(0x20) to enable 332 * LDO1 and LDO5 to change to their programmed target values. 333 */ 334 switch (ldo) { 335 case LP3972_LDO1: 336 case LP3972_LDO5: 337 shift = LP3972_LDO_VOL_CHANGE_SHIFT(ldo); 338 ret = lp3972_set_bits(lp3972, LP3972_VOL_CHANGE_REG, 339 LP3972_VOL_CHANGE_FLAG_MASK << shift, 340 LP3972_VOL_CHANGE_FLAG_GO << shift); 341 if (ret) 342 return ret; 343 344 ret = lp3972_set_bits(lp3972, LP3972_VOL_CHANGE_REG, 345 LP3972_VOL_CHANGE_FLAG_MASK << shift, 0); 346 break; 347 } 348 349 return ret; 350 } 351 352 static struct regulator_ops lp3972_ldo_ops = { 353 .list_voltage = lp3972_ldo_list_voltage, 354 .is_enabled = lp3972_ldo_is_enabled, 355 .enable = lp3972_ldo_enable, 356 .disable = lp3972_ldo_disable, 357 .get_voltage = lp3972_ldo_get_voltage, 358 .set_voltage = lp3972_ldo_set_voltage, 359 }; 360 361 static int lp3972_dcdc_list_voltage(struct regulator_dev *dev, unsigned index) 362 { 363 int buck = rdev_get_id(dev) - LP3972_DCDC1; 364 return 1000 * buck_voltage_map[buck][index]; 365 } 366 367 static int lp3972_dcdc_is_enabled(struct regulator_dev *dev) 368 { 369 struct lp3972 *lp3972 = rdev_get_drvdata(dev); 370 int buck = rdev_get_id(dev) - LP3972_DCDC1; 371 u16 mask = 1 << (buck * 2); 372 u16 val; 373 374 val = lp3972_reg_read(lp3972, LP3972_BUCK_VOL_ENABLE_REG(buck)); 375 return !!(val & mask); 376 } 377 378 static int lp3972_dcdc_enable(struct regulator_dev *dev) 379 { 380 struct lp3972 *lp3972 = rdev_get_drvdata(dev); 381 int buck = rdev_get_id(dev) - LP3972_DCDC1; 382 u16 mask = 1 << (buck * 2); 383 u16 val; 384 385 val = lp3972_set_bits(lp3972, LP3972_BUCK_VOL_ENABLE_REG(buck), 386 mask, mask); 387 return val; 388 } 389 390 static int lp3972_dcdc_disable(struct regulator_dev *dev) 391 { 392 struct lp3972 *lp3972 = rdev_get_drvdata(dev); 393 int buck = rdev_get_id(dev) - LP3972_DCDC1; 394 u16 mask = 1 << (buck * 2); 395 u16 val; 396 397 val = lp3972_set_bits(lp3972, LP3972_BUCK_VOL_ENABLE_REG(buck), 398 mask, 0); 399 return val; 400 } 401 402 static int lp3972_dcdc_get_voltage(struct regulator_dev *dev) 403 { 404 struct lp3972 *lp3972 = rdev_get_drvdata(dev); 405 int buck = rdev_get_id(dev) - LP3972_DCDC1; 406 u16 reg; 407 int val; 408 409 reg = lp3972_reg_read(lp3972, LP3972_BUCK_VOL1_REG(buck)); 410 reg &= LP3972_BUCK_VOL_MASK; 411 if (reg <= LP3972_BUCK_VOL_MAX_IDX(buck)) 412 val = 1000 * buck_voltage_map[buck][reg]; 413 else { 414 val = 0; 415 dev_warn(&dev->dev, "chip reported incorrect voltage value." 416 " reg = %d\n", reg); 417 } 418 419 return val; 420 } 421 422 static int lp3972_dcdc_set_voltage(struct regulator_dev *dev, 423 int min_uV, int max_uV, 424 unsigned int *selector) 425 { 426 struct lp3972 *lp3972 = rdev_get_drvdata(dev); 427 int buck = rdev_get_id(dev) - LP3972_DCDC1; 428 int min_vol = min_uV / 1000, max_vol = max_uV / 1000; 429 const int *vol_map = buck_voltage_map[buck]; 430 u16 val; 431 int ret; 432 433 if (min_vol < vol_map[LP3972_BUCK_VOL_MIN_IDX(buck)] || 434 min_vol > vol_map[LP3972_BUCK_VOL_MAX_IDX(buck)]) 435 return -EINVAL; 436 437 for (val = LP3972_BUCK_VOL_MIN_IDX(buck); 438 val <= LP3972_BUCK_VOL_MAX_IDX(buck); val++) 439 if (vol_map[val] >= min_vol) 440 break; 441 442 if (val > LP3972_BUCK_VOL_MAX_IDX(buck) || 443 vol_map[val] > max_vol) 444 return -EINVAL; 445 446 *selector = val; 447 448 ret = lp3972_set_bits(lp3972, LP3972_BUCK_VOL1_REG(buck), 449 LP3972_BUCK_VOL_MASK, val); 450 if (ret) 451 return ret; 452 453 if (buck != 0) 454 return ret; 455 456 ret = lp3972_set_bits(lp3972, LP3972_VOL_CHANGE_REG, 457 LP3972_VOL_CHANGE_FLAG_MASK, LP3972_VOL_CHANGE_FLAG_GO); 458 if (ret) 459 return ret; 460 461 return lp3972_set_bits(lp3972, LP3972_VOL_CHANGE_REG, 462 LP3972_VOL_CHANGE_FLAG_MASK, 0); 463 } 464 465 static struct regulator_ops lp3972_dcdc_ops = { 466 .list_voltage = lp3972_dcdc_list_voltage, 467 .is_enabled = lp3972_dcdc_is_enabled, 468 .enable = lp3972_dcdc_enable, 469 .disable = lp3972_dcdc_disable, 470 .get_voltage = lp3972_dcdc_get_voltage, 471 .set_voltage = lp3972_dcdc_set_voltage, 472 }; 473 474 static const struct regulator_desc regulators[] = { 475 { 476 .name = "LDO1", 477 .id = LP3972_LDO1, 478 .ops = &lp3972_ldo_ops, 479 .n_voltages = ARRAY_SIZE(ldo1_voltage_map), 480 .type = REGULATOR_VOLTAGE, 481 .owner = THIS_MODULE, 482 }, 483 { 484 .name = "LDO2", 485 .id = LP3972_LDO2, 486 .ops = &lp3972_ldo_ops, 487 .n_voltages = ARRAY_SIZE(ldo23_voltage_map), 488 .type = REGULATOR_VOLTAGE, 489 .owner = THIS_MODULE, 490 }, 491 { 492 .name = "LDO3", 493 .id = LP3972_LDO3, 494 .ops = &lp3972_ldo_ops, 495 .n_voltages = ARRAY_SIZE(ldo23_voltage_map), 496 .type = REGULATOR_VOLTAGE, 497 .owner = THIS_MODULE, 498 }, 499 { 500 .name = "LDO4", 501 .id = LP3972_LDO4, 502 .ops = &lp3972_ldo_ops, 503 .n_voltages = ARRAY_SIZE(ldo4_voltage_map), 504 .type = REGULATOR_VOLTAGE, 505 .owner = THIS_MODULE, 506 }, 507 { 508 .name = "LDO5", 509 .id = LP3972_LDO5, 510 .ops = &lp3972_ldo_ops, 511 .n_voltages = ARRAY_SIZE(ldo5_voltage_map), 512 .type = REGULATOR_VOLTAGE, 513 .owner = THIS_MODULE, 514 }, 515 { 516 .name = "DCDC1", 517 .id = LP3972_DCDC1, 518 .ops = &lp3972_dcdc_ops, 519 .n_voltages = ARRAY_SIZE(buck1_voltage_map), 520 .type = REGULATOR_VOLTAGE, 521 .owner = THIS_MODULE, 522 }, 523 { 524 .name = "DCDC2", 525 .id = LP3972_DCDC2, 526 .ops = &lp3972_dcdc_ops, 527 .n_voltages = ARRAY_SIZE(buck23_voltage_map), 528 .type = REGULATOR_VOLTAGE, 529 .owner = THIS_MODULE, 530 }, 531 { 532 .name = "DCDC3", 533 .id = LP3972_DCDC3, 534 .ops = &lp3972_dcdc_ops, 535 .n_voltages = ARRAY_SIZE(buck23_voltage_map), 536 .type = REGULATOR_VOLTAGE, 537 .owner = THIS_MODULE, 538 }, 539 }; 540 541 static int __devinit setup_regulators(struct lp3972 *lp3972, 542 struct lp3972_platform_data *pdata) 543 { 544 int i, err; 545 546 lp3972->num_regulators = pdata->num_regulators; 547 lp3972->rdev = kcalloc(pdata->num_regulators, 548 sizeof(struct regulator_dev *), GFP_KERNEL); 549 if (!lp3972->rdev) { 550 err = -ENOMEM; 551 goto err_nomem; 552 } 553 554 /* Instantiate the regulators */ 555 for (i = 0; i < pdata->num_regulators; i++) { 556 struct lp3972_regulator_subdev *reg = &pdata->regulators[i]; 557 lp3972->rdev[i] = regulator_register(®ulators[reg->id], 558 lp3972->dev, reg->initdata, lp3972, NULL); 559 560 if (IS_ERR(lp3972->rdev[i])) { 561 err = PTR_ERR(lp3972->rdev[i]); 562 dev_err(lp3972->dev, "regulator init failed: %d\n", 563 err); 564 goto error; 565 } 566 } 567 568 return 0; 569 error: 570 while (--i >= 0) 571 regulator_unregister(lp3972->rdev[i]); 572 kfree(lp3972->rdev); 573 lp3972->rdev = NULL; 574 err_nomem: 575 return err; 576 } 577 578 static int __devinit lp3972_i2c_probe(struct i2c_client *i2c, 579 const struct i2c_device_id *id) 580 { 581 struct lp3972 *lp3972; 582 struct lp3972_platform_data *pdata = i2c->dev.platform_data; 583 int ret; 584 u16 val; 585 586 if (!pdata) { 587 dev_dbg(&i2c->dev, "No platform init data supplied\n"); 588 return -ENODEV; 589 } 590 591 lp3972 = kzalloc(sizeof(struct lp3972), GFP_KERNEL); 592 if (!lp3972) 593 return -ENOMEM; 594 595 lp3972->i2c = i2c; 596 lp3972->dev = &i2c->dev; 597 598 mutex_init(&lp3972->io_lock); 599 600 /* Detect LP3972 */ 601 ret = lp3972_i2c_read(i2c, LP3972_SYS_CONTROL1_REG, 1, &val); 602 if (ret == 0 && 603 (val & SYS_CONTROL1_INIT_MASK) != SYS_CONTROL1_INIT_VAL) { 604 ret = -ENODEV; 605 dev_err(&i2c->dev, "chip reported: val = 0x%x\n", val); 606 } 607 if (ret < 0) { 608 dev_err(&i2c->dev, "failed to detect device. ret = %d\n", ret); 609 goto err_detect; 610 } 611 612 ret = setup_regulators(lp3972, pdata); 613 if (ret < 0) 614 goto err_detect; 615 616 i2c_set_clientdata(i2c, lp3972); 617 return 0; 618 619 err_detect: 620 kfree(lp3972); 621 return ret; 622 } 623 624 static int __devexit lp3972_i2c_remove(struct i2c_client *i2c) 625 { 626 struct lp3972 *lp3972 = i2c_get_clientdata(i2c); 627 int i; 628 629 for (i = 0; i < lp3972->num_regulators; i++) 630 regulator_unregister(lp3972->rdev[i]); 631 kfree(lp3972->rdev); 632 kfree(lp3972); 633 634 return 0; 635 } 636 637 static const struct i2c_device_id lp3972_i2c_id[] = { 638 { "lp3972", 0 }, 639 { } 640 }; 641 MODULE_DEVICE_TABLE(i2c, lp3972_i2c_id); 642 643 static struct i2c_driver lp3972_i2c_driver = { 644 .driver = { 645 .name = "lp3972", 646 .owner = THIS_MODULE, 647 }, 648 .probe = lp3972_i2c_probe, 649 .remove = __devexit_p(lp3972_i2c_remove), 650 .id_table = lp3972_i2c_id, 651 }; 652 653 static int __init lp3972_module_init(void) 654 { 655 return i2c_add_driver(&lp3972_i2c_driver); 656 } 657 subsys_initcall(lp3972_module_init); 658 659 static void __exit lp3972_module_exit(void) 660 { 661 i2c_del_driver(&lp3972_i2c_driver); 662 } 663 module_exit(lp3972_module_exit); 664 665 MODULE_LICENSE("GPL"); 666 MODULE_AUTHOR("Axel Lin <axel.lin@gmail.com>"); 667 MODULE_DESCRIPTION("LP3972 PMIC driver"); 668