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 CMD_READ(reg) ((reg) << 6) 114 #define CMD_WRITE(reg) (BIT(5) | (reg) << 6) 115 #define STAT_CLK BIT(3) 116 #define STAT_WRITE BIT(2) 117 #define STAT_INVALID BIT(1) 118 #define STAT_WP BIT(0) 119 120 struct field { 121 int reg; 122 int shift; 123 int mask; 124 }; 125 126 struct supply_info { 127 const char *name; 128 int n_voltages; 129 const unsigned int *voltages; 130 int n_ilimsels; 131 const unsigned int *ilimsels; 132 struct field enable, voltage, ilimsel; 133 }; 134 135 struct tps6524x { 136 struct device *dev; 137 struct spi_device *spi; 138 struct mutex lock; 139 struct regulator_desc desc[N_REGULATORS]; 140 }; 141 142 static int __read_reg(struct tps6524x *hw, int reg) 143 { 144 int error = 0; 145 u16 cmd = CMD_READ(reg), in; 146 u8 status; 147 struct spi_message m; 148 struct spi_transfer t[3]; 149 150 spi_message_init(&m); 151 memset(t, 0, sizeof(t)); 152 153 t[0].tx_buf = &cmd; 154 t[0].len = 2; 155 t[0].bits_per_word = 12; 156 spi_message_add_tail(&t[0], &m); 157 158 t[1].rx_buf = ∈ 159 t[1].len = 2; 160 t[1].bits_per_word = 16; 161 spi_message_add_tail(&t[1], &m); 162 163 t[2].rx_buf = &status; 164 t[2].len = 1; 165 t[2].bits_per_word = 4; 166 spi_message_add_tail(&t[2], &m); 167 168 error = spi_sync(hw->spi, &m); 169 if (error < 0) 170 return error; 171 172 dev_dbg(hw->dev, "read reg %d, data %x, status %x\n", 173 reg, in, status); 174 175 if (!(status & STAT_CLK) || (status & STAT_WRITE)) 176 return -EIO; 177 178 if (status & STAT_INVALID) 179 return -EINVAL; 180 181 return in; 182 } 183 184 static int read_reg(struct tps6524x *hw, int reg) 185 { 186 int ret; 187 188 mutex_lock(&hw->lock); 189 ret = __read_reg(hw, reg); 190 mutex_unlock(&hw->lock); 191 192 return ret; 193 } 194 195 static int __write_reg(struct tps6524x *hw, int reg, int val) 196 { 197 int error = 0; 198 u16 cmd = CMD_WRITE(reg), out = val; 199 u8 status; 200 struct spi_message m; 201 struct spi_transfer t[3]; 202 203 spi_message_init(&m); 204 memset(t, 0, sizeof(t)); 205 206 t[0].tx_buf = &cmd; 207 t[0].len = 2; 208 t[0].bits_per_word = 12; 209 spi_message_add_tail(&t[0], &m); 210 211 t[1].tx_buf = &out; 212 t[1].len = 2; 213 t[1].bits_per_word = 16; 214 spi_message_add_tail(&t[1], &m); 215 216 t[2].rx_buf = &status; 217 t[2].len = 1; 218 t[2].bits_per_word = 4; 219 spi_message_add_tail(&t[2], &m); 220 221 error = spi_sync(hw->spi, &m); 222 if (error < 0) 223 return error; 224 225 dev_dbg(hw->dev, "wrote reg %d, data %x, status %x\n", 226 reg, out, status); 227 228 if (!(status & STAT_CLK) || !(status & STAT_WRITE)) 229 return -EIO; 230 231 if (status & (STAT_INVALID | STAT_WP)) 232 return -EINVAL; 233 234 return error; 235 } 236 237 static int __rmw_reg(struct tps6524x *hw, int reg, int mask, int val) 238 { 239 int ret; 240 241 ret = __read_reg(hw, reg); 242 if (ret < 0) 243 return ret; 244 245 ret &= ~mask; 246 ret |= val; 247 248 ret = __write_reg(hw, reg, ret); 249 250 return (ret < 0) ? ret : 0; 251 } 252 253 static int rmw_protect(struct tps6524x *hw, int reg, int mask, int val) 254 { 255 int ret; 256 257 mutex_lock(&hw->lock); 258 259 ret = __write_reg(hw, REG_WRITE_ENABLE, 1); 260 if (ret) { 261 dev_err(hw->dev, "failed to set write enable\n"); 262 goto error; 263 } 264 265 ret = __rmw_reg(hw, reg, mask, val); 266 if (ret) 267 dev_err(hw->dev, "failed to rmw register %d\n", reg); 268 269 ret = __write_reg(hw, REG_WRITE_ENABLE, 0); 270 if (ret) { 271 dev_err(hw->dev, "failed to clear write enable\n"); 272 goto error; 273 } 274 275 error: 276 mutex_unlock(&hw->lock); 277 278 return ret; 279 } 280 281 static int read_field(struct tps6524x *hw, const struct field *field) 282 { 283 int tmp; 284 285 tmp = read_reg(hw, field->reg); 286 if (tmp < 0) 287 return tmp; 288 289 return (tmp >> field->shift) & field->mask; 290 } 291 292 static int write_field(struct tps6524x *hw, const struct field *field, 293 int val) 294 { 295 if (val & ~field->mask) 296 return -EOVERFLOW; 297 298 return rmw_protect(hw, field->reg, 299 field->mask << field->shift, 300 val << field->shift); 301 } 302 303 static const unsigned int dcdc1_voltages[] = { 304 800000, 825000, 850000, 875000, 305 900000, 925000, 950000, 975000, 306 1000000, 1025000, 1050000, 1075000, 307 1100000, 1125000, 1150000, 1175000, 308 1200000, 1225000, 1250000, 1275000, 309 1300000, 1325000, 1350000, 1375000, 310 1400000, 1425000, 1450000, 1475000, 311 1500000, 1525000, 1550000, 1575000, 312 }; 313 314 static const unsigned int dcdc2_voltages[] = { 315 1400000, 1450000, 1500000, 1550000, 316 1600000, 1650000, 1700000, 1750000, 317 1800000, 1850000, 1900000, 1950000, 318 2000000, 2050000, 2100000, 2150000, 319 2200000, 2250000, 2300000, 2350000, 320 2400000, 2450000, 2500000, 2550000, 321 2600000, 2650000, 2700000, 2750000, 322 2800000, 2850000, 2900000, 2950000, 323 }; 324 325 static const unsigned int dcdc3_voltages[] = { 326 2400000, 2450000, 2500000, 2550000, 2600000, 327 2650000, 2700000, 2750000, 2800000, 2850000, 328 2900000, 2950000, 3000000, 3050000, 3100000, 329 3150000, 3200000, 3250000, 3300000, 3350000, 330 3400000, 3450000, 3500000, 3550000, 3600000, 331 }; 332 333 static const unsigned int ldo1_voltages[] = { 334 4300000, 4350000, 4400000, 4450000, 335 4500000, 4550000, 4600000, 4650000, 336 4700000, 4750000, 4800000, 4850000, 337 4900000, 4950000, 5000000, 5050000, 338 }; 339 340 static const unsigned int ldo2_voltages[] = { 341 1100000, 1150000, 1200000, 1250000, 342 1300000, 1700000, 1750000, 1800000, 343 1850000, 1900000, 3150000, 3200000, 344 3250000, 3300000, 3350000, 3400000, 345 }; 346 347 static const unsigned int fixed_5000000_voltage[] = { 348 5000000 349 }; 350 351 static const unsigned int ldo_ilimsel[] = { 352 400000, 1500000 353 }; 354 355 static const unsigned int usb_ilimsel[] = { 356 200000, 400000, 800000, 1000000 357 }; 358 359 static const unsigned int fixed_2400000_ilimsel[] = { 360 2400000 361 }; 362 363 static const unsigned int fixed_1200000_ilimsel[] = { 364 1200000 365 }; 366 367 static const unsigned int fixed_400000_ilimsel[] = { 368 400000 369 }; 370 371 #define __MK_FIELD(_reg, _mask, _shift) \ 372 { .reg = (_reg), .mask = (_mask), .shift = (_shift), } 373 374 static const struct supply_info supply_info[N_REGULATORS] = { 375 { 376 .name = "DCDC1", 377 .n_voltages = ARRAY_SIZE(dcdc1_voltages), 378 .voltages = dcdc1_voltages, 379 .n_ilimsels = ARRAY_SIZE(fixed_2400000_ilimsel), 380 .ilimsels = fixed_2400000_ilimsel, 381 .enable = __MK_FIELD(REG_DCDC_EN, DCDCDCDC_EN_MASK, 382 DCDCDCDC1_EN_SHIFT), 383 .voltage = __MK_FIELD(REG_DCDC_SET, DCDC_VDCDC_MASK, 384 DCDC_VDCDC1_SHIFT), 385 }, 386 { 387 .name = "DCDC2", 388 .n_voltages = ARRAY_SIZE(dcdc2_voltages), 389 .voltages = dcdc2_voltages, 390 .n_ilimsels = ARRAY_SIZE(fixed_1200000_ilimsel), 391 .ilimsels = fixed_1200000_ilimsel, 392 .enable = __MK_FIELD(REG_DCDC_EN, DCDCDCDC_EN_MASK, 393 DCDCDCDC2_EN_SHIFT), 394 .voltage = __MK_FIELD(REG_DCDC_SET, DCDC_VDCDC_MASK, 395 DCDC_VDCDC2_SHIFT), 396 }, 397 { 398 .name = "DCDC3", 399 .n_voltages = ARRAY_SIZE(dcdc3_voltages), 400 .voltages = dcdc3_voltages, 401 .n_ilimsels = ARRAY_SIZE(fixed_1200000_ilimsel), 402 .ilimsels = fixed_1200000_ilimsel, 403 .enable = __MK_FIELD(REG_DCDC_EN, DCDCDCDC_EN_MASK, 404 DCDCDCDC3_EN_SHIFT), 405 .voltage = __MK_FIELD(REG_DCDC_SET, DCDC_VDCDC_MASK, 406 DCDC_VDCDC3_SHIFT), 407 }, 408 { 409 .name = "LDO1", 410 .n_voltages = ARRAY_SIZE(ldo1_voltages), 411 .voltages = ldo1_voltages, 412 .n_ilimsels = ARRAY_SIZE(ldo_ilimsel), 413 .ilimsels = ldo_ilimsel, 414 .enable = __MK_FIELD(REG_BLOCK_EN, BLOCK_MASK, 415 BLOCK_LDO1_SHIFT), 416 .voltage = __MK_FIELD(REG_LDO_SET, LDO_VSEL_MASK, 417 LDO1_VSEL_SHIFT), 418 .ilimsel = __MK_FIELD(REG_LDO_SET, LDO_ILIM_MASK, 419 LDO1_ILIM_SHIFT), 420 }, 421 { 422 .name = "LDO2", 423 .n_voltages = ARRAY_SIZE(ldo2_voltages), 424 .voltages = ldo2_voltages, 425 .n_ilimsels = ARRAY_SIZE(ldo_ilimsel), 426 .ilimsels = ldo_ilimsel, 427 .enable = __MK_FIELD(REG_BLOCK_EN, BLOCK_MASK, 428 BLOCK_LDO2_SHIFT), 429 .voltage = __MK_FIELD(REG_LDO_SET, LDO_VSEL_MASK, 430 LDO2_VSEL_SHIFT), 431 .ilimsel = __MK_FIELD(REG_LDO_SET, LDO_ILIM_MASK, 432 LDO2_ILIM_SHIFT), 433 }, 434 { 435 .name = "USB", 436 .n_voltages = ARRAY_SIZE(fixed_5000000_voltage), 437 .voltages = fixed_5000000_voltage, 438 .n_ilimsels = ARRAY_SIZE(usb_ilimsel), 439 .ilimsels = usb_ilimsel, 440 .enable = __MK_FIELD(REG_BLOCK_EN, BLOCK_MASK, 441 BLOCK_USB_SHIFT), 442 .ilimsel = __MK_FIELD(REG_USB, USB_ILIM_MASK, 443 USB_ILIM_SHIFT), 444 }, 445 { 446 .name = "LCD", 447 .n_voltages = ARRAY_SIZE(fixed_5000000_voltage), 448 .voltages = fixed_5000000_voltage, 449 .n_ilimsels = ARRAY_SIZE(fixed_400000_ilimsel), 450 .ilimsels = fixed_400000_ilimsel, 451 .enable = __MK_FIELD(REG_BLOCK_EN, BLOCK_MASK, 452 BLOCK_LCD_SHIFT), 453 }, 454 }; 455 456 static int set_voltage_sel(struct regulator_dev *rdev, unsigned selector) 457 { 458 const struct supply_info *info; 459 struct tps6524x *hw; 460 461 hw = rdev_get_drvdata(rdev); 462 info = &supply_info[rdev_get_id(rdev)]; 463 464 if (rdev->desc->n_voltages == 1) 465 return -EINVAL; 466 467 return write_field(hw, &info->voltage, selector); 468 } 469 470 static int get_voltage_sel(struct regulator_dev *rdev) 471 { 472 const struct supply_info *info; 473 struct tps6524x *hw; 474 int ret; 475 476 hw = rdev_get_drvdata(rdev); 477 info = &supply_info[rdev_get_id(rdev)]; 478 479 if (rdev->desc->n_voltages == 1) 480 return 0; 481 482 ret = read_field(hw, &info->voltage); 483 if (ret < 0) 484 return ret; 485 if (WARN_ON(ret >= info->n_voltages)) 486 return -EIO; 487 488 return ret; 489 } 490 491 static int set_current_limit(struct regulator_dev *rdev, int min_uA, 492 int max_uA) 493 { 494 const struct supply_info *info; 495 struct tps6524x *hw; 496 int i; 497 498 hw = rdev_get_drvdata(rdev); 499 info = &supply_info[rdev_get_id(rdev)]; 500 501 if (info->n_ilimsels == 1) 502 return -EINVAL; 503 504 for (i = info->n_ilimsels - 1; i >= 0; i--) { 505 if (min_uA <= info->ilimsels[i] && 506 max_uA >= info->ilimsels[i]) 507 return write_field(hw, &info->ilimsel, i); 508 } 509 510 return -EINVAL; 511 } 512 513 static int get_current_limit(struct regulator_dev *rdev) 514 { 515 const struct supply_info *info; 516 struct tps6524x *hw; 517 int ret; 518 519 hw = rdev_get_drvdata(rdev); 520 info = &supply_info[rdev_get_id(rdev)]; 521 522 if (info->n_ilimsels == 1) 523 return info->ilimsels[0]; 524 525 ret = read_field(hw, &info->ilimsel); 526 if (ret < 0) 527 return ret; 528 if (WARN_ON(ret >= info->n_ilimsels)) 529 return -EIO; 530 531 return info->ilimsels[ret]; 532 } 533 534 static int enable_supply(struct regulator_dev *rdev) 535 { 536 const struct supply_info *info; 537 struct tps6524x *hw; 538 539 hw = rdev_get_drvdata(rdev); 540 info = &supply_info[rdev_get_id(rdev)]; 541 542 return write_field(hw, &info->enable, 1); 543 } 544 545 static int disable_supply(struct regulator_dev *rdev) 546 { 547 const struct supply_info *info; 548 struct tps6524x *hw; 549 550 hw = rdev_get_drvdata(rdev); 551 info = &supply_info[rdev_get_id(rdev)]; 552 553 return write_field(hw, &info->enable, 0); 554 } 555 556 static int is_supply_enabled(struct regulator_dev *rdev) 557 { 558 const struct supply_info *info; 559 struct tps6524x *hw; 560 561 hw = rdev_get_drvdata(rdev); 562 info = &supply_info[rdev_get_id(rdev)]; 563 564 return read_field(hw, &info->enable); 565 } 566 567 static const struct regulator_ops regulator_ops = { 568 .is_enabled = is_supply_enabled, 569 .enable = enable_supply, 570 .disable = disable_supply, 571 .get_voltage_sel = get_voltage_sel, 572 .set_voltage_sel = set_voltage_sel, 573 .list_voltage = regulator_list_voltage_table, 574 .map_voltage = regulator_map_voltage_ascend, 575 .set_current_limit = set_current_limit, 576 .get_current_limit = get_current_limit, 577 }; 578 579 static int pmic_probe(struct spi_device *spi) 580 { 581 struct tps6524x *hw; 582 struct device *dev = &spi->dev; 583 const struct supply_info *info = supply_info; 584 struct regulator_init_data *init_data; 585 struct regulator_config config = { }; 586 struct regulator_dev *rdev; 587 int i; 588 589 init_data = dev_get_platdata(dev); 590 if (!init_data) { 591 dev_err(dev, "could not find regulator platform data\n"); 592 return -EINVAL; 593 } 594 595 hw = devm_kzalloc(&spi->dev, sizeof(struct tps6524x), GFP_KERNEL); 596 if (!hw) 597 return -ENOMEM; 598 599 spi_set_drvdata(spi, hw); 600 601 memset(hw, 0, sizeof(struct tps6524x)); 602 hw->dev = dev; 603 hw->spi = spi; 604 mutex_init(&hw->lock); 605 606 for (i = 0; i < N_REGULATORS; i++, info++, init_data++) { 607 hw->desc[i].name = info->name; 608 hw->desc[i].id = i; 609 hw->desc[i].n_voltages = info->n_voltages; 610 hw->desc[i].volt_table = info->voltages; 611 hw->desc[i].ops = ®ulator_ops; 612 hw->desc[i].type = REGULATOR_VOLTAGE; 613 hw->desc[i].owner = THIS_MODULE; 614 615 config.dev = dev; 616 config.init_data = init_data; 617 config.driver_data = hw; 618 619 rdev = devm_regulator_register(dev, &hw->desc[i], &config); 620 if (IS_ERR(rdev)) 621 return PTR_ERR(rdev); 622 } 623 624 return 0; 625 } 626 627 static struct spi_driver pmic_driver = { 628 .probe = pmic_probe, 629 .driver = { 630 .name = "tps6524x", 631 .probe_type = PROBE_PREFER_ASYNCHRONOUS, 632 }, 633 }; 634 635 module_spi_driver(pmic_driver); 636 637 MODULE_DESCRIPTION("TPS6524X PMIC Driver"); 638 MODULE_AUTHOR("Cyril Chemparathy"); 639 MODULE_LICENSE("GPL"); 640 MODULE_ALIAS("spi:tps6524x"); 641