1 /* 2 * Regulator driver for TPS6524x PMIC 3 * 4 * Copyright (C) 2010 Texas Instruments 5 * 6 * This program is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU General Public License as 8 * published by the Free Software Foundation version 2. 9 * 10 * This program is distributed "as is" WITHOUT ANY WARRANTY of any kind, 11 * whether express or implied; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 13 * General Public License for more details. 14 */ 15 16 #include <linux/kernel.h> 17 #include <linux/module.h> 18 #include <linux/err.h> 19 #include <linux/errno.h> 20 #include <linux/slab.h> 21 #include <linux/spi/spi.h> 22 #include <linux/regulator/driver.h> 23 #include <linux/regulator/machine.h> 24 25 #define REG_LDO_SET 0x0 26 #define LDO_ILIM_MASK 1 /* 0 = 400-800, 1 = 900-1500 */ 27 #define LDO_VSEL_MASK 0x0f 28 #define LDO2_ILIM_SHIFT 12 29 #define LDO2_VSEL_SHIFT 4 30 #define LDO1_ILIM_SHIFT 8 31 #define LDO1_VSEL_SHIFT 0 32 33 #define REG_BLOCK_EN 0x1 34 #define BLOCK_MASK 1 35 #define BLOCK_LDO1_SHIFT 0 36 #define BLOCK_LDO2_SHIFT 1 37 #define BLOCK_LCD_SHIFT 2 38 #define BLOCK_USB_SHIFT 3 39 40 #define REG_DCDC_SET 0x2 41 #define DCDC_VDCDC_MASK 0x1f 42 #define DCDC_VDCDC1_SHIFT 0 43 #define DCDC_VDCDC2_SHIFT 5 44 #define DCDC_VDCDC3_SHIFT 10 45 46 #define REG_DCDC_EN 0x3 47 #define DCDCDCDC_EN_MASK 0x1 48 #define DCDCDCDC1_EN_SHIFT 0 49 #define DCDCDCDC1_PG_MSK BIT(1) 50 #define DCDCDCDC2_EN_SHIFT 2 51 #define DCDCDCDC2_PG_MSK BIT(3) 52 #define DCDCDCDC3_EN_SHIFT 4 53 #define DCDCDCDC3_PG_MSK BIT(5) 54 55 #define REG_USB 0x4 56 #define USB_ILIM_SHIFT 0 57 #define USB_ILIM_MASK 0x3 58 #define USB_TSD_SHIFT 2 59 #define USB_TSD_MASK 0x3 60 #define USB_TWARN_SHIFT 4 61 #define USB_TWARN_MASK 0x3 62 #define USB_IWARN_SD BIT(6) 63 #define USB_FAST_LOOP BIT(7) 64 65 #define REG_ALARM 0x5 66 #define ALARM_LDO1 BIT(0) 67 #define ALARM_DCDC1 BIT(1) 68 #define ALARM_DCDC2 BIT(2) 69 #define ALARM_DCDC3 BIT(3) 70 #define ALARM_LDO2 BIT(4) 71 #define ALARM_USB_WARN BIT(5) 72 #define ALARM_USB_ALARM BIT(6) 73 #define ALARM_LCD BIT(9) 74 #define ALARM_TEMP_WARM BIT(10) 75 #define ALARM_TEMP_HOT BIT(11) 76 #define ALARM_NRST BIT(14) 77 #define ALARM_POWERUP BIT(15) 78 79 #define REG_INT_ENABLE 0x6 80 #define INT_LDO1 BIT(0) 81 #define INT_DCDC1 BIT(1) 82 #define INT_DCDC2 BIT(2) 83 #define INT_DCDC3 BIT(3) 84 #define INT_LDO2 BIT(4) 85 #define INT_USB_WARN BIT(5) 86 #define INT_USB_ALARM BIT(6) 87 #define INT_LCD BIT(9) 88 #define INT_TEMP_WARM BIT(10) 89 #define INT_TEMP_HOT BIT(11) 90 #define INT_GLOBAL_EN BIT(15) 91 92 #define REG_INT_STATUS 0x7 93 #define STATUS_LDO1 BIT(0) 94 #define STATUS_DCDC1 BIT(1) 95 #define STATUS_DCDC2 BIT(2) 96 #define STATUS_DCDC3 BIT(3) 97 #define STATUS_LDO2 BIT(4) 98 #define STATUS_USB_WARN BIT(5) 99 #define STATUS_USB_ALARM BIT(6) 100 #define STATUS_LCD BIT(9) 101 #define STATUS_TEMP_WARM BIT(10) 102 #define STATUS_TEMP_HOT BIT(11) 103 104 #define REG_SOFTWARE_RESET 0xb 105 #define REG_WRITE_ENABLE 0xd 106 #define REG_REV_ID 0xf 107 108 #define N_DCDC 3 109 #define N_LDO 2 110 #define N_SWITCH 2 111 #define N_REGULATORS (N_DCDC + N_LDO + N_SWITCH) 112 113 #define FIXED_ILIMSEL BIT(0) 114 #define FIXED_VOLTAGE BIT(1) 115 116 #define CMD_READ(reg) ((reg) << 6) 117 #define CMD_WRITE(reg) (BIT(5) | (reg) << 6) 118 #define STAT_CLK BIT(3) 119 #define STAT_WRITE BIT(2) 120 #define STAT_INVALID BIT(1) 121 #define STAT_WP BIT(0) 122 123 struct field { 124 int reg; 125 int shift; 126 int mask; 127 }; 128 129 struct supply_info { 130 const char *name; 131 int n_voltages; 132 const int *voltages; 133 int fixed_voltage; 134 int n_ilimsels; 135 const int *ilimsels; 136 int fixed_ilimsel; 137 int flags; 138 struct field enable, voltage, ilimsel; 139 }; 140 141 struct tps6524x { 142 struct device *dev; 143 struct spi_device *spi; 144 struct mutex lock; 145 struct regulator_desc desc[N_REGULATORS]; 146 struct regulator_dev *rdev[N_REGULATORS]; 147 }; 148 149 static int __read_reg(struct tps6524x *hw, int reg) 150 { 151 int error = 0; 152 u16 cmd = CMD_READ(reg), in; 153 u8 status; 154 struct spi_message m; 155 struct spi_transfer t[3]; 156 157 spi_message_init(&m); 158 memset(t, 0, sizeof(t)); 159 160 t[0].tx_buf = &cmd; 161 t[0].len = 2; 162 t[0].bits_per_word = 12; 163 spi_message_add_tail(&t[0], &m); 164 165 t[1].rx_buf = ∈ 166 t[1].len = 2; 167 t[1].bits_per_word = 16; 168 spi_message_add_tail(&t[1], &m); 169 170 t[2].rx_buf = &status; 171 t[2].len = 1; 172 t[2].bits_per_word = 4; 173 spi_message_add_tail(&t[2], &m); 174 175 error = spi_sync(hw->spi, &m); 176 if (error < 0) 177 return error; 178 179 dev_dbg(hw->dev, "read reg %d, data %x, status %x\n", 180 reg, in, status); 181 182 if (!(status & STAT_CLK) || (status & STAT_WRITE)) 183 return -EIO; 184 185 if (status & STAT_INVALID) 186 return -EINVAL; 187 188 return in; 189 } 190 191 static int read_reg(struct tps6524x *hw, int reg) 192 { 193 int ret; 194 195 mutex_lock(&hw->lock); 196 ret = __read_reg(hw, reg); 197 mutex_unlock(&hw->lock); 198 199 return ret; 200 } 201 202 static int __write_reg(struct tps6524x *hw, int reg, int val) 203 { 204 int error = 0; 205 u16 cmd = CMD_WRITE(reg), out = val; 206 u8 status; 207 struct spi_message m; 208 struct spi_transfer t[3]; 209 210 spi_message_init(&m); 211 memset(t, 0, sizeof(t)); 212 213 t[0].tx_buf = &cmd; 214 t[0].len = 2; 215 t[0].bits_per_word = 12; 216 spi_message_add_tail(&t[0], &m); 217 218 t[1].tx_buf = &out; 219 t[1].len = 2; 220 t[1].bits_per_word = 16; 221 spi_message_add_tail(&t[1], &m); 222 223 t[2].rx_buf = &status; 224 t[2].len = 1; 225 t[2].bits_per_word = 4; 226 spi_message_add_tail(&t[2], &m); 227 228 error = spi_sync(hw->spi, &m); 229 if (error < 0) 230 return error; 231 232 dev_dbg(hw->dev, "wrote reg %d, data %x, status %x\n", 233 reg, out, status); 234 235 if (!(status & STAT_CLK) || !(status & STAT_WRITE)) 236 return -EIO; 237 238 if (status & (STAT_INVALID | STAT_WP)) 239 return -EINVAL; 240 241 return error; 242 } 243 244 static int __rmw_reg(struct tps6524x *hw, int reg, int mask, int val) 245 { 246 int ret; 247 248 ret = __read_reg(hw, reg); 249 if (ret < 0) 250 return ret; 251 252 ret &= ~mask; 253 ret |= val; 254 255 ret = __write_reg(hw, reg, ret); 256 257 return (ret < 0) ? ret : 0; 258 } 259 260 static int rmw_protect(struct tps6524x *hw, int reg, int mask, int val) 261 { 262 int ret; 263 264 mutex_lock(&hw->lock); 265 266 ret = __write_reg(hw, REG_WRITE_ENABLE, 1); 267 if (ret) { 268 dev_err(hw->dev, "failed to set write enable\n"); 269 goto error; 270 } 271 272 ret = __rmw_reg(hw, reg, mask, val); 273 if (ret) 274 dev_err(hw->dev, "failed to rmw register %d\n", reg); 275 276 ret = __write_reg(hw, REG_WRITE_ENABLE, 0); 277 if (ret) { 278 dev_err(hw->dev, "failed to clear write enable\n"); 279 goto error; 280 } 281 282 error: 283 mutex_unlock(&hw->lock); 284 285 return ret; 286 } 287 288 static int read_field(struct tps6524x *hw, const struct field *field) 289 { 290 int tmp; 291 292 tmp = read_reg(hw, field->reg); 293 if (tmp < 0) 294 return tmp; 295 296 return (tmp >> field->shift) & field->mask; 297 } 298 299 static int write_field(struct tps6524x *hw, const struct field *field, 300 int val) 301 { 302 if (val & ~field->mask) 303 return -EOVERFLOW; 304 305 return rmw_protect(hw, field->reg, 306 field->mask << field->shift, 307 val << field->shift); 308 } 309 310 static const int dcdc1_voltages[] = { 311 800000, 825000, 850000, 875000, 312 900000, 925000, 950000, 975000, 313 1000000, 1025000, 1050000, 1075000, 314 1100000, 1125000, 1150000, 1175000, 315 1200000, 1225000, 1250000, 1275000, 316 1300000, 1325000, 1350000, 1375000, 317 1400000, 1425000, 1450000, 1475000, 318 1500000, 1525000, 1550000, 1575000, 319 }; 320 321 static const int dcdc2_voltages[] = { 322 1400000, 1450000, 1500000, 1550000, 323 1600000, 1650000, 1700000, 1750000, 324 1800000, 1850000, 1900000, 1950000, 325 2000000, 2050000, 2100000, 2150000, 326 2200000, 2250000, 2300000, 2350000, 327 2400000, 2450000, 2500000, 2550000, 328 2600000, 2650000, 2700000, 2750000, 329 2800000, 2850000, 2900000, 2950000, 330 }; 331 332 static const int dcdc3_voltages[] = { 333 2400000, 2450000, 2500000, 2550000, 2600000, 334 2650000, 2700000, 2750000, 2800000, 2850000, 335 2900000, 2950000, 3000000, 3050000, 3100000, 336 3150000, 3200000, 3250000, 3300000, 3350000, 337 3400000, 3450000, 3500000, 3550000, 3600000, 338 }; 339 340 static const int ldo1_voltages[] = { 341 4300000, 4350000, 4400000, 4450000, 342 4500000, 4550000, 4600000, 4650000, 343 4700000, 4750000, 4800000, 4850000, 344 4900000, 4950000, 5000000, 5050000, 345 }; 346 347 static const int ldo2_voltages[] = { 348 1100000, 1150000, 1200000, 1250000, 349 1300000, 1700000, 1750000, 1800000, 350 1850000, 1900000, 3150000, 3200000, 351 3250000, 3300000, 3350000, 3400000, 352 }; 353 354 static const int ldo_ilimsel[] = { 355 400000, 1500000 356 }; 357 358 static const int usb_ilimsel[] = { 359 200000, 400000, 800000, 1000000 360 }; 361 362 #define __MK_FIELD(_reg, _mask, _shift) \ 363 { .reg = (_reg), .mask = (_mask), .shift = (_shift), } 364 365 static const struct supply_info supply_info[N_REGULATORS] = { 366 { 367 .name = "DCDC1", 368 .flags = FIXED_ILIMSEL, 369 .n_voltages = ARRAY_SIZE(dcdc1_voltages), 370 .voltages = dcdc1_voltages, 371 .fixed_ilimsel = 2400000, 372 .enable = __MK_FIELD(REG_DCDC_EN, DCDCDCDC_EN_MASK, 373 DCDCDCDC1_EN_SHIFT), 374 .voltage = __MK_FIELD(REG_DCDC_SET, DCDC_VDCDC_MASK, 375 DCDC_VDCDC1_SHIFT), 376 }, 377 { 378 .name = "DCDC2", 379 .flags = FIXED_ILIMSEL, 380 .n_voltages = ARRAY_SIZE(dcdc2_voltages), 381 .voltages = dcdc2_voltages, 382 .fixed_ilimsel = 1200000, 383 .enable = __MK_FIELD(REG_DCDC_EN, DCDCDCDC_EN_MASK, 384 DCDCDCDC2_EN_SHIFT), 385 .voltage = __MK_FIELD(REG_DCDC_SET, DCDC_VDCDC_MASK, 386 DCDC_VDCDC2_SHIFT), 387 }, 388 { 389 .name = "DCDC3", 390 .flags = FIXED_ILIMSEL, 391 .n_voltages = ARRAY_SIZE(dcdc3_voltages), 392 .voltages = dcdc3_voltages, 393 .fixed_ilimsel = 1200000, 394 .enable = __MK_FIELD(REG_DCDC_EN, DCDCDCDC_EN_MASK, 395 DCDCDCDC3_EN_SHIFT), 396 .voltage = __MK_FIELD(REG_DCDC_SET, DCDC_VDCDC_MASK, 397 DCDC_VDCDC3_SHIFT), 398 }, 399 { 400 .name = "LDO1", 401 .n_voltages = ARRAY_SIZE(ldo1_voltages), 402 .voltages = ldo1_voltages, 403 .n_ilimsels = ARRAY_SIZE(ldo_ilimsel), 404 .ilimsels = ldo_ilimsel, 405 .enable = __MK_FIELD(REG_BLOCK_EN, BLOCK_MASK, 406 BLOCK_LDO1_SHIFT), 407 .voltage = __MK_FIELD(REG_LDO_SET, LDO_VSEL_MASK, 408 LDO1_VSEL_SHIFT), 409 .ilimsel = __MK_FIELD(REG_LDO_SET, LDO_ILIM_MASK, 410 LDO1_ILIM_SHIFT), 411 }, 412 { 413 .name = "LDO2", 414 .n_voltages = ARRAY_SIZE(ldo2_voltages), 415 .voltages = ldo2_voltages, 416 .n_ilimsels = ARRAY_SIZE(ldo_ilimsel), 417 .ilimsels = ldo_ilimsel, 418 .enable = __MK_FIELD(REG_BLOCK_EN, BLOCK_MASK, 419 BLOCK_LDO2_SHIFT), 420 .voltage = __MK_FIELD(REG_LDO_SET, LDO_VSEL_MASK, 421 LDO2_VSEL_SHIFT), 422 .ilimsel = __MK_FIELD(REG_LDO_SET, LDO_ILIM_MASK, 423 LDO2_ILIM_SHIFT), 424 }, 425 { 426 .name = "USB", 427 .flags = FIXED_VOLTAGE, 428 .fixed_voltage = 5000000, 429 .n_ilimsels = ARRAY_SIZE(usb_ilimsel), 430 .ilimsels = usb_ilimsel, 431 .enable = __MK_FIELD(REG_BLOCK_EN, BLOCK_MASK, 432 BLOCK_USB_SHIFT), 433 .ilimsel = __MK_FIELD(REG_USB, USB_ILIM_MASK, 434 USB_ILIM_SHIFT), 435 }, 436 { 437 .name = "LCD", 438 .flags = FIXED_VOLTAGE | FIXED_ILIMSEL, 439 .fixed_voltage = 5000000, 440 .fixed_ilimsel = 400000, 441 .enable = __MK_FIELD(REG_BLOCK_EN, BLOCK_MASK, 442 BLOCK_LCD_SHIFT), 443 }, 444 }; 445 446 static int list_voltage(struct regulator_dev *rdev, unsigned selector) 447 { 448 const struct supply_info *info; 449 struct tps6524x *hw; 450 451 hw = rdev_get_drvdata(rdev); 452 info = &supply_info[rdev_get_id(rdev)]; 453 454 if (info->flags & FIXED_VOLTAGE) 455 return selector ? -EINVAL : info->fixed_voltage; 456 457 return ((selector < info->n_voltages) ? 458 info->voltages[selector] : -EINVAL); 459 } 460 461 static int set_voltage_sel(struct regulator_dev *rdev, unsigned selector) 462 { 463 const struct supply_info *info; 464 struct tps6524x *hw; 465 466 hw = rdev_get_drvdata(rdev); 467 info = &supply_info[rdev_get_id(rdev)]; 468 469 if (info->flags & FIXED_VOLTAGE) 470 return -EINVAL; 471 472 return write_field(hw, &info->voltage, selector); 473 } 474 475 static int get_voltage_sel(struct regulator_dev *rdev) 476 { 477 const struct supply_info *info; 478 struct tps6524x *hw; 479 int ret; 480 481 hw = rdev_get_drvdata(rdev); 482 info = &supply_info[rdev_get_id(rdev)]; 483 484 if (info->flags & FIXED_VOLTAGE) 485 return info->fixed_voltage; 486 487 ret = read_field(hw, &info->voltage); 488 if (ret < 0) 489 return ret; 490 if (WARN_ON(ret >= info->n_voltages)) 491 return -EIO; 492 493 return ret; 494 } 495 496 static int set_current_limit(struct regulator_dev *rdev, int min_uA, 497 int max_uA) 498 { 499 const struct supply_info *info; 500 struct tps6524x *hw; 501 int i; 502 503 hw = rdev_get_drvdata(rdev); 504 info = &supply_info[rdev_get_id(rdev)]; 505 506 if (info->flags & FIXED_ILIMSEL) 507 return -EINVAL; 508 509 for (i = 0; i < info->n_ilimsels; i++) 510 if (min_uA <= info->ilimsels[i] && 511 max_uA >= info->ilimsels[i]) 512 break; 513 514 if (i >= info->n_ilimsels) 515 return -EINVAL; 516 517 return write_field(hw, &info->ilimsel, i); 518 } 519 520 static int get_current_limit(struct regulator_dev *rdev) 521 { 522 const struct supply_info *info; 523 struct tps6524x *hw; 524 int ret; 525 526 hw = rdev_get_drvdata(rdev); 527 info = &supply_info[rdev_get_id(rdev)]; 528 529 if (info->flags & FIXED_ILIMSEL) 530 return info->fixed_ilimsel; 531 532 ret = read_field(hw, &info->ilimsel); 533 if (ret < 0) 534 return ret; 535 if (WARN_ON(ret >= info->n_ilimsels)) 536 return -EIO; 537 538 return info->ilimsels[ret]; 539 } 540 541 static int enable_supply(struct regulator_dev *rdev) 542 { 543 const struct supply_info *info; 544 struct tps6524x *hw; 545 546 hw = rdev_get_drvdata(rdev); 547 info = &supply_info[rdev_get_id(rdev)]; 548 549 return write_field(hw, &info->enable, 1); 550 } 551 552 static int disable_supply(struct regulator_dev *rdev) 553 { 554 const struct supply_info *info; 555 struct tps6524x *hw; 556 557 hw = rdev_get_drvdata(rdev); 558 info = &supply_info[rdev_get_id(rdev)]; 559 560 return write_field(hw, &info->enable, 0); 561 } 562 563 static int is_supply_enabled(struct regulator_dev *rdev) 564 { 565 const struct supply_info *info; 566 struct tps6524x *hw; 567 568 hw = rdev_get_drvdata(rdev); 569 info = &supply_info[rdev_get_id(rdev)]; 570 571 return read_field(hw, &info->enable); 572 } 573 574 static struct regulator_ops regulator_ops = { 575 .is_enabled = is_supply_enabled, 576 .enable = enable_supply, 577 .disable = disable_supply, 578 .get_voltage_sel = get_voltage_sel, 579 .set_voltage_sel = set_voltage_sel, 580 .list_voltage = list_voltage, 581 .set_current_limit = set_current_limit, 582 .get_current_limit = get_current_limit, 583 }; 584 585 static int pmic_remove(struct spi_device *spi) 586 { 587 struct tps6524x *hw = spi_get_drvdata(spi); 588 int i; 589 590 if (!hw) 591 return 0; 592 for (i = 0; i < N_REGULATORS; i++) { 593 if (hw->rdev[i]) 594 regulator_unregister(hw->rdev[i]); 595 hw->rdev[i] = NULL; 596 } 597 spi_set_drvdata(spi, NULL); 598 kfree(hw); 599 return 0; 600 } 601 602 static int __devinit pmic_probe(struct spi_device *spi) 603 { 604 struct tps6524x *hw; 605 struct device *dev = &spi->dev; 606 const struct supply_info *info = supply_info; 607 struct regulator_init_data *init_data; 608 struct regulator_config config = { }; 609 int ret = 0, i; 610 611 init_data = dev->platform_data; 612 if (!init_data) { 613 dev_err(dev, "could not find regulator platform data\n"); 614 return -EINVAL; 615 } 616 617 hw = kzalloc(sizeof(struct tps6524x), GFP_KERNEL); 618 if (!hw) { 619 dev_err(dev, "cannot allocate regulator private data\n"); 620 return -ENOMEM; 621 } 622 spi_set_drvdata(spi, hw); 623 624 memset(hw, 0, sizeof(struct tps6524x)); 625 hw->dev = dev; 626 hw->spi = spi_dev_get(spi); 627 mutex_init(&hw->lock); 628 629 for (i = 0; i < N_REGULATORS; i++, info++, init_data++) { 630 hw->desc[i].name = info->name; 631 hw->desc[i].id = i; 632 hw->desc[i].n_voltages = info->n_voltages; 633 hw->desc[i].ops = ®ulator_ops; 634 hw->desc[i].type = REGULATOR_VOLTAGE; 635 hw->desc[i].owner = THIS_MODULE; 636 637 if (info->flags & FIXED_VOLTAGE) 638 hw->desc[i].n_voltages = 1; 639 640 config.dev = dev; 641 config.init_data = init_data; 642 config.driver_data = hw; 643 644 hw->rdev[i] = regulator_register(&hw->desc[i], &config); 645 if (IS_ERR(hw->rdev[i])) { 646 ret = PTR_ERR(hw->rdev[i]); 647 hw->rdev[i] = NULL; 648 goto fail; 649 } 650 } 651 652 return 0; 653 654 fail: 655 pmic_remove(spi); 656 return ret; 657 } 658 659 static struct spi_driver pmic_driver = { 660 .probe = pmic_probe, 661 .remove = __devexit_p(pmic_remove), 662 .driver = { 663 .name = "tps6524x", 664 .owner = THIS_MODULE, 665 }, 666 }; 667 668 module_spi_driver(pmic_driver); 669 670 MODULE_DESCRIPTION("TPS6524X PMIC Driver"); 671 MODULE_AUTHOR("Cyril Chemparathy"); 672 MODULE_LICENSE("GPL"); 673 MODULE_ALIAS("spi:tps6524x"); 674