1 // SPDX-License-Identifier: GPL-2.0+ 2 // 3 // wm831x-dcdc.c -- DC-DC buck converter driver for the WM831x series 4 // 5 // Copyright 2009 Wolfson Microelectronics PLC. 6 // 7 // Author: Mark Brown <broonie@opensource.wolfsonmicro.com> 8 9 #include <linux/module.h> 10 #include <linux/moduleparam.h> 11 #include <linux/init.h> 12 #include <linux/bitops.h> 13 #include <linux/err.h> 14 #include <linux/i2c.h> 15 #include <linux/platform_device.h> 16 #include <linux/regulator/driver.h> 17 #include <linux/regulator/machine.h> 18 #include <linux/gpio/consumer.h> 19 #include <linux/slab.h> 20 21 #include <linux/mfd/wm831x/core.h> 22 #include <linux/mfd/wm831x/regulator.h> 23 #include <linux/mfd/wm831x/pdata.h> 24 25 #define WM831X_BUCKV_MAX_SELECTOR 0x68 26 #define WM831X_BUCKP_MAX_SELECTOR 0x66 27 28 #define WM831X_DCDC_MODE_FAST 0 29 #define WM831X_DCDC_MODE_NORMAL 1 30 #define WM831X_DCDC_MODE_IDLE 2 31 #define WM831X_DCDC_MODE_STANDBY 3 32 33 #define WM831X_DCDC_MAX_NAME 9 34 35 /* Register offsets in control block */ 36 #define WM831X_DCDC_CONTROL_1 0 37 #define WM831X_DCDC_CONTROL_2 1 38 #define WM831X_DCDC_ON_CONFIG 2 39 #define WM831X_DCDC_SLEEP_CONTROL 3 40 #define WM831X_DCDC_DVS_CONTROL 4 41 42 /* 43 * Shared 44 */ 45 46 struct wm831x_dcdc { 47 char name[WM831X_DCDC_MAX_NAME]; 48 char supply_name[WM831X_DCDC_MAX_NAME]; 49 struct regulator_desc desc; 50 int base; 51 struct wm831x *wm831x; 52 struct regulator_dev *regulator; 53 struct gpio_desc *dvs_gpiod; 54 int dvs_gpio_state; 55 int on_vsel; 56 int dvs_vsel; 57 }; 58 59 static unsigned int wm831x_dcdc_get_mode(struct regulator_dev *rdev) 60 61 { 62 struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev); 63 struct wm831x *wm831x = dcdc->wm831x; 64 u16 reg = dcdc->base + WM831X_DCDC_ON_CONFIG; 65 int val; 66 67 val = wm831x_reg_read(wm831x, reg); 68 if (val < 0) 69 return val; 70 71 val = (val & WM831X_DC1_ON_MODE_MASK) >> WM831X_DC1_ON_MODE_SHIFT; 72 73 switch (val) { 74 case WM831X_DCDC_MODE_FAST: 75 return REGULATOR_MODE_FAST; 76 case WM831X_DCDC_MODE_NORMAL: 77 return REGULATOR_MODE_NORMAL; 78 case WM831X_DCDC_MODE_STANDBY: 79 return REGULATOR_MODE_STANDBY; 80 case WM831X_DCDC_MODE_IDLE: 81 return REGULATOR_MODE_IDLE; 82 default: 83 BUG(); 84 return -EINVAL; 85 } 86 } 87 88 static int wm831x_dcdc_set_mode_int(struct wm831x *wm831x, int reg, 89 unsigned int mode) 90 { 91 int val; 92 93 switch (mode) { 94 case REGULATOR_MODE_FAST: 95 val = WM831X_DCDC_MODE_FAST; 96 break; 97 case REGULATOR_MODE_NORMAL: 98 val = WM831X_DCDC_MODE_NORMAL; 99 break; 100 case REGULATOR_MODE_STANDBY: 101 val = WM831X_DCDC_MODE_STANDBY; 102 break; 103 case REGULATOR_MODE_IDLE: 104 val = WM831X_DCDC_MODE_IDLE; 105 break; 106 default: 107 return -EINVAL; 108 } 109 110 return wm831x_set_bits(wm831x, reg, WM831X_DC1_ON_MODE_MASK, 111 val << WM831X_DC1_ON_MODE_SHIFT); 112 } 113 114 static int wm831x_dcdc_set_mode(struct regulator_dev *rdev, unsigned int mode) 115 { 116 struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev); 117 struct wm831x *wm831x = dcdc->wm831x; 118 u16 reg = dcdc->base + WM831X_DCDC_ON_CONFIG; 119 120 return wm831x_dcdc_set_mode_int(wm831x, reg, mode); 121 } 122 123 static int wm831x_dcdc_set_suspend_mode(struct regulator_dev *rdev, 124 unsigned int mode) 125 { 126 struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev); 127 struct wm831x *wm831x = dcdc->wm831x; 128 u16 reg = dcdc->base + WM831X_DCDC_SLEEP_CONTROL; 129 130 return wm831x_dcdc_set_mode_int(wm831x, reg, mode); 131 } 132 133 static int wm831x_dcdc_get_status(struct regulator_dev *rdev) 134 { 135 struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev); 136 struct wm831x *wm831x = dcdc->wm831x; 137 int ret; 138 139 /* First, check for errors */ 140 ret = wm831x_reg_read(wm831x, WM831X_DCDC_UV_STATUS); 141 if (ret < 0) 142 return ret; 143 144 if (ret & (1 << rdev_get_id(rdev))) { 145 dev_dbg(wm831x->dev, "DCDC%d under voltage\n", 146 rdev_get_id(rdev) + 1); 147 return REGULATOR_STATUS_ERROR; 148 } 149 150 /* DCDC1 and DCDC2 can additionally detect high voltage/current */ 151 if (rdev_get_id(rdev) < 2) { 152 if (ret & (WM831X_DC1_OV_STS << rdev_get_id(rdev))) { 153 dev_dbg(wm831x->dev, "DCDC%d over voltage\n", 154 rdev_get_id(rdev) + 1); 155 return REGULATOR_STATUS_ERROR; 156 } 157 158 if (ret & (WM831X_DC1_HC_STS << rdev_get_id(rdev))) { 159 dev_dbg(wm831x->dev, "DCDC%d over current\n", 160 rdev_get_id(rdev) + 1); 161 return REGULATOR_STATUS_ERROR; 162 } 163 } 164 165 /* Is the regulator on? */ 166 ret = wm831x_reg_read(wm831x, WM831X_DCDC_STATUS); 167 if (ret < 0) 168 return ret; 169 if (!(ret & (1 << rdev_get_id(rdev)))) 170 return REGULATOR_STATUS_OFF; 171 172 /* TODO: When we handle hardware control modes so we can report the 173 * current mode. */ 174 return REGULATOR_STATUS_ON; 175 } 176 177 static irqreturn_t wm831x_dcdc_uv_irq(int irq, void *data) 178 { 179 struct wm831x_dcdc *dcdc = data; 180 181 regulator_notifier_call_chain(dcdc->regulator, 182 REGULATOR_EVENT_UNDER_VOLTAGE, 183 NULL); 184 185 return IRQ_HANDLED; 186 } 187 188 static irqreturn_t wm831x_dcdc_oc_irq(int irq, void *data) 189 { 190 struct wm831x_dcdc *dcdc = data; 191 192 regulator_notifier_call_chain(dcdc->regulator, 193 REGULATOR_EVENT_OVER_CURRENT, 194 NULL); 195 196 return IRQ_HANDLED; 197 } 198 199 /* 200 * BUCKV specifics 201 */ 202 203 static const struct linear_range wm831x_buckv_ranges[] = { 204 REGULATOR_LINEAR_RANGE(600000, 0, 0x7, 0), 205 REGULATOR_LINEAR_RANGE(600000, 0x8, 0x68, 12500), 206 }; 207 208 static int wm831x_buckv_set_dvs(struct regulator_dev *rdev, int state) 209 { 210 struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev); 211 212 if (state == dcdc->dvs_gpio_state) 213 return 0; 214 215 dcdc->dvs_gpio_state = state; 216 gpiod_set_value(dcdc->dvs_gpiod, state); 217 218 /* Should wait for DVS state change to be asserted if we have 219 * a GPIO for it, for now assume the device is configured 220 * for the fastest possible transition. 221 */ 222 223 return 0; 224 } 225 226 static int wm831x_buckv_set_voltage_sel(struct regulator_dev *rdev, 227 unsigned vsel) 228 { 229 struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev); 230 struct wm831x *wm831x = dcdc->wm831x; 231 int on_reg = dcdc->base + WM831X_DCDC_ON_CONFIG; 232 int dvs_reg = dcdc->base + WM831X_DCDC_DVS_CONTROL; 233 int ret; 234 235 /* If this value is already set then do a GPIO update if we can */ 236 if (dcdc->dvs_gpiod && dcdc->on_vsel == vsel) 237 return wm831x_buckv_set_dvs(rdev, 0); 238 239 if (dcdc->dvs_gpiod && dcdc->dvs_vsel == vsel) 240 return wm831x_buckv_set_dvs(rdev, 1); 241 242 /* Always set the ON status to the minimum voltage */ 243 ret = wm831x_set_bits(wm831x, on_reg, WM831X_DC1_ON_VSEL_MASK, vsel); 244 if (ret < 0) 245 return ret; 246 dcdc->on_vsel = vsel; 247 248 if (!dcdc->dvs_gpiod) 249 return ret; 250 251 /* Kick the voltage transition now */ 252 ret = wm831x_buckv_set_dvs(rdev, 0); 253 if (ret < 0) 254 return ret; 255 256 /* 257 * If this VSEL is higher than the last one we've seen then 258 * remember it as the DVS VSEL. This is optimised for CPUfreq 259 * usage where we want to get to the highest voltage very 260 * quickly. 261 */ 262 if (vsel > dcdc->dvs_vsel) { 263 ret = wm831x_set_bits(wm831x, dvs_reg, 264 WM831X_DC1_DVS_VSEL_MASK, 265 vsel); 266 if (ret == 0) 267 dcdc->dvs_vsel = vsel; 268 else 269 dev_warn(wm831x->dev, 270 "Failed to set DCDC DVS VSEL: %d\n", ret); 271 } 272 273 return 0; 274 } 275 276 static int wm831x_buckv_set_suspend_voltage(struct regulator_dev *rdev, 277 int uV) 278 { 279 struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev); 280 struct wm831x *wm831x = dcdc->wm831x; 281 u16 reg = dcdc->base + WM831X_DCDC_SLEEP_CONTROL; 282 int vsel; 283 284 vsel = regulator_map_voltage_linear_range(rdev, uV, uV); 285 if (vsel < 0) 286 return vsel; 287 288 return wm831x_set_bits(wm831x, reg, WM831X_DC1_SLP_VSEL_MASK, vsel); 289 } 290 291 static int wm831x_buckv_get_voltage_sel(struct regulator_dev *rdev) 292 { 293 struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev); 294 295 if (dcdc->dvs_gpiod && dcdc->dvs_gpio_state) 296 return dcdc->dvs_vsel; 297 else 298 return dcdc->on_vsel; 299 } 300 301 /* Current limit options */ 302 static const unsigned int wm831x_dcdc_ilim[] = { 303 125000, 250000, 375000, 500000, 625000, 750000, 875000, 1000000 304 }; 305 306 static const struct regulator_ops wm831x_buckv_ops = { 307 .set_voltage_sel = wm831x_buckv_set_voltage_sel, 308 .get_voltage_sel = wm831x_buckv_get_voltage_sel, 309 .list_voltage = regulator_list_voltage_linear_range, 310 .map_voltage = regulator_map_voltage_linear_range, 311 .set_suspend_voltage = wm831x_buckv_set_suspend_voltage, 312 .set_current_limit = regulator_set_current_limit_regmap, 313 .get_current_limit = regulator_get_current_limit_regmap, 314 315 .is_enabled = regulator_is_enabled_regmap, 316 .enable = regulator_enable_regmap, 317 .disable = regulator_disable_regmap, 318 .get_status = wm831x_dcdc_get_status, 319 .get_mode = wm831x_dcdc_get_mode, 320 .set_mode = wm831x_dcdc_set_mode, 321 .set_suspend_mode = wm831x_dcdc_set_suspend_mode, 322 }; 323 324 /* 325 * Set up DVS control. We just log errors since we can still run 326 * (with reduced performance) if we fail. 327 */ 328 static void wm831x_buckv_dvs_init(struct platform_device *pdev, 329 struct wm831x_dcdc *dcdc, 330 struct wm831x_buckv_pdata *pdata) 331 { 332 struct wm831x *wm831x = dcdc->wm831x; 333 int ret; 334 u16 ctrl; 335 336 if (!pdata) 337 return; 338 339 /* gpiolib won't let us read the GPIO status so pick the higher 340 * of the two existing voltages so we take it as platform data. 341 */ 342 dcdc->dvs_gpio_state = pdata->dvs_init_state; 343 344 dcdc->dvs_gpiod = devm_gpiod_get(&pdev->dev, "dvs", 345 dcdc->dvs_gpio_state ? GPIOD_OUT_HIGH : GPIOD_OUT_LOW); 346 if (IS_ERR(dcdc->dvs_gpiod)) { 347 dev_err(wm831x->dev, "Failed to get %s DVS GPIO: %ld\n", 348 dcdc->name, PTR_ERR(dcdc->dvs_gpiod)); 349 return; 350 } 351 352 switch (pdata->dvs_control_src) { 353 case 1: 354 ctrl = 2 << WM831X_DC1_DVS_SRC_SHIFT; 355 break; 356 case 2: 357 ctrl = 3 << WM831X_DC1_DVS_SRC_SHIFT; 358 break; 359 default: 360 dev_err(wm831x->dev, "Invalid DVS control source %d for %s\n", 361 pdata->dvs_control_src, dcdc->name); 362 return; 363 } 364 365 /* If DVS_VSEL is set to the minimum value then raise it to ON_VSEL 366 * to make bootstrapping a bit smoother. 367 */ 368 if (!dcdc->dvs_vsel) { 369 ret = wm831x_set_bits(wm831x, 370 dcdc->base + WM831X_DCDC_DVS_CONTROL, 371 WM831X_DC1_DVS_VSEL_MASK, dcdc->on_vsel); 372 if (ret == 0) 373 dcdc->dvs_vsel = dcdc->on_vsel; 374 else 375 dev_warn(wm831x->dev, "Failed to set DVS_VSEL: %d\n", 376 ret); 377 } 378 379 ret = wm831x_set_bits(wm831x, dcdc->base + WM831X_DCDC_DVS_CONTROL, 380 WM831X_DC1_DVS_SRC_MASK, ctrl); 381 if (ret < 0) { 382 dev_err(wm831x->dev, "Failed to set %s DVS source: %d\n", 383 dcdc->name, ret); 384 } 385 } 386 387 static int wm831x_buckv_probe(struct platform_device *pdev) 388 { 389 struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent); 390 struct wm831x_pdata *pdata = dev_get_platdata(wm831x->dev); 391 struct regulator_config config = { }; 392 int id; 393 struct wm831x_dcdc *dcdc; 394 struct resource *res; 395 int ret, irq; 396 397 if (pdata && pdata->wm831x_num) 398 id = (pdata->wm831x_num * 10) + 1; 399 else 400 id = 0; 401 id = pdev->id - id; 402 403 dev_dbg(&pdev->dev, "Probing DCDC%d\n", id + 1); 404 405 dcdc = devm_kzalloc(&pdev->dev, sizeof(struct wm831x_dcdc), 406 GFP_KERNEL); 407 if (!dcdc) 408 return -ENOMEM; 409 410 dcdc->wm831x = wm831x; 411 412 res = platform_get_resource(pdev, IORESOURCE_REG, 0); 413 if (res == NULL) { 414 dev_err(&pdev->dev, "No REG resource\n"); 415 ret = -EINVAL; 416 goto err; 417 } 418 dcdc->base = res->start; 419 420 snprintf(dcdc->name, sizeof(dcdc->name), "DCDC%d", id + 1); 421 dcdc->desc.name = dcdc->name; 422 423 snprintf(dcdc->supply_name, sizeof(dcdc->supply_name), 424 "DC%dVDD", id + 1); 425 dcdc->desc.supply_name = dcdc->supply_name; 426 427 dcdc->desc.id = id; 428 dcdc->desc.type = REGULATOR_VOLTAGE; 429 dcdc->desc.n_voltages = WM831X_BUCKV_MAX_SELECTOR + 1; 430 dcdc->desc.linear_ranges = wm831x_buckv_ranges; 431 dcdc->desc.n_linear_ranges = ARRAY_SIZE(wm831x_buckv_ranges); 432 dcdc->desc.ops = &wm831x_buckv_ops; 433 dcdc->desc.owner = THIS_MODULE; 434 dcdc->desc.enable_reg = WM831X_DCDC_ENABLE; 435 dcdc->desc.enable_mask = 1 << id; 436 dcdc->desc.csel_reg = dcdc->base + WM831X_DCDC_CONTROL_2; 437 dcdc->desc.csel_mask = WM831X_DC1_HC_THR_MASK; 438 dcdc->desc.n_current_limits = ARRAY_SIZE(wm831x_dcdc_ilim); 439 dcdc->desc.curr_table = wm831x_dcdc_ilim; 440 441 ret = wm831x_reg_read(wm831x, dcdc->base + WM831X_DCDC_ON_CONFIG); 442 if (ret < 0) { 443 dev_err(wm831x->dev, "Failed to read ON VSEL: %d\n", ret); 444 goto err; 445 } 446 dcdc->on_vsel = ret & WM831X_DC1_ON_VSEL_MASK; 447 448 ret = wm831x_reg_read(wm831x, dcdc->base + WM831X_DCDC_DVS_CONTROL); 449 if (ret < 0) { 450 dev_err(wm831x->dev, "Failed to read DVS VSEL: %d\n", ret); 451 goto err; 452 } 453 dcdc->dvs_vsel = ret & WM831X_DC1_DVS_VSEL_MASK; 454 455 if (pdata && pdata->dcdc[id]) 456 wm831x_buckv_dvs_init(pdev, dcdc, 457 pdata->dcdc[id]->driver_data); 458 459 config.dev = pdev->dev.parent; 460 if (pdata) 461 config.init_data = pdata->dcdc[id]; 462 config.driver_data = dcdc; 463 config.regmap = wm831x->regmap; 464 465 dcdc->regulator = devm_regulator_register(&pdev->dev, &dcdc->desc, 466 &config); 467 if (IS_ERR(dcdc->regulator)) { 468 ret = PTR_ERR(dcdc->regulator); 469 dev_err(wm831x->dev, "Failed to register DCDC%d: %d\n", 470 id + 1, ret); 471 goto err; 472 } 473 474 irq = wm831x_irq(wm831x, platform_get_irq_byname(pdev, "UV")); 475 ret = devm_request_threaded_irq(&pdev->dev, irq, NULL, 476 wm831x_dcdc_uv_irq, 477 IRQF_TRIGGER_RISING | IRQF_ONESHOT, 478 dcdc->name, dcdc); 479 if (ret != 0) { 480 dev_err(&pdev->dev, "Failed to request UV IRQ %d: %d\n", 481 irq, ret); 482 goto err; 483 } 484 485 irq = wm831x_irq(wm831x, platform_get_irq_byname(pdev, "HC")); 486 ret = devm_request_threaded_irq(&pdev->dev, irq, NULL, 487 wm831x_dcdc_oc_irq, 488 IRQF_TRIGGER_RISING | IRQF_ONESHOT, 489 dcdc->name, dcdc); 490 if (ret != 0) { 491 dev_err(&pdev->dev, "Failed to request HC IRQ %d: %d\n", 492 irq, ret); 493 goto err; 494 } 495 496 platform_set_drvdata(pdev, dcdc); 497 498 return 0; 499 500 err: 501 return ret; 502 } 503 504 static struct platform_driver wm831x_buckv_driver = { 505 .probe = wm831x_buckv_probe, 506 .driver = { 507 .name = "wm831x-buckv", 508 }, 509 }; 510 511 /* 512 * BUCKP specifics 513 */ 514 515 static int wm831x_buckp_set_suspend_voltage(struct regulator_dev *rdev, int uV) 516 { 517 struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev); 518 struct wm831x *wm831x = dcdc->wm831x; 519 u16 reg = dcdc->base + WM831X_DCDC_SLEEP_CONTROL; 520 int sel; 521 522 sel = regulator_map_voltage_linear(rdev, uV, uV); 523 if (sel < 0) 524 return sel; 525 526 return wm831x_set_bits(wm831x, reg, WM831X_DC3_ON_VSEL_MASK, sel); 527 } 528 529 static const struct regulator_ops wm831x_buckp_ops = { 530 .set_voltage_sel = regulator_set_voltage_sel_regmap, 531 .get_voltage_sel = regulator_get_voltage_sel_regmap, 532 .list_voltage = regulator_list_voltage_linear, 533 .map_voltage = regulator_map_voltage_linear, 534 .set_suspend_voltage = wm831x_buckp_set_suspend_voltage, 535 536 .is_enabled = regulator_is_enabled_regmap, 537 .enable = regulator_enable_regmap, 538 .disable = regulator_disable_regmap, 539 .get_status = wm831x_dcdc_get_status, 540 .get_mode = wm831x_dcdc_get_mode, 541 .set_mode = wm831x_dcdc_set_mode, 542 .set_suspend_mode = wm831x_dcdc_set_suspend_mode, 543 }; 544 545 static int wm831x_buckp_probe(struct platform_device *pdev) 546 { 547 struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent); 548 struct wm831x_pdata *pdata = dev_get_platdata(wm831x->dev); 549 struct regulator_config config = { }; 550 int id; 551 struct wm831x_dcdc *dcdc; 552 struct resource *res; 553 int ret, irq; 554 555 if (pdata && pdata->wm831x_num) 556 id = (pdata->wm831x_num * 10) + 1; 557 else 558 id = 0; 559 id = pdev->id - id; 560 561 dev_dbg(&pdev->dev, "Probing DCDC%d\n", id + 1); 562 563 dcdc = devm_kzalloc(&pdev->dev, sizeof(struct wm831x_dcdc), 564 GFP_KERNEL); 565 if (!dcdc) 566 return -ENOMEM; 567 568 dcdc->wm831x = wm831x; 569 570 res = platform_get_resource(pdev, IORESOURCE_REG, 0); 571 if (res == NULL) { 572 dev_err(&pdev->dev, "No REG resource\n"); 573 ret = -EINVAL; 574 goto err; 575 } 576 dcdc->base = res->start; 577 578 snprintf(dcdc->name, sizeof(dcdc->name), "DCDC%d", id + 1); 579 dcdc->desc.name = dcdc->name; 580 581 snprintf(dcdc->supply_name, sizeof(dcdc->supply_name), 582 "DC%dVDD", id + 1); 583 dcdc->desc.supply_name = dcdc->supply_name; 584 585 dcdc->desc.id = id; 586 dcdc->desc.type = REGULATOR_VOLTAGE; 587 dcdc->desc.n_voltages = WM831X_BUCKP_MAX_SELECTOR + 1; 588 dcdc->desc.ops = &wm831x_buckp_ops; 589 dcdc->desc.owner = THIS_MODULE; 590 dcdc->desc.vsel_reg = dcdc->base + WM831X_DCDC_ON_CONFIG; 591 dcdc->desc.vsel_mask = WM831X_DC3_ON_VSEL_MASK; 592 dcdc->desc.enable_reg = WM831X_DCDC_ENABLE; 593 dcdc->desc.enable_mask = 1 << id; 594 dcdc->desc.min_uV = 850000; 595 dcdc->desc.uV_step = 25000; 596 597 config.dev = pdev->dev.parent; 598 if (pdata) 599 config.init_data = pdata->dcdc[id]; 600 config.driver_data = dcdc; 601 config.regmap = wm831x->regmap; 602 603 dcdc->regulator = devm_regulator_register(&pdev->dev, &dcdc->desc, 604 &config); 605 if (IS_ERR(dcdc->regulator)) { 606 ret = PTR_ERR(dcdc->regulator); 607 dev_err(wm831x->dev, "Failed to register DCDC%d: %d\n", 608 id + 1, ret); 609 goto err; 610 } 611 612 irq = wm831x_irq(wm831x, platform_get_irq_byname(pdev, "UV")); 613 ret = devm_request_threaded_irq(&pdev->dev, irq, NULL, 614 wm831x_dcdc_uv_irq, 615 IRQF_TRIGGER_RISING | IRQF_ONESHOT, 616 dcdc->name, dcdc); 617 if (ret != 0) { 618 dev_err(&pdev->dev, "Failed to request UV IRQ %d: %d\n", 619 irq, ret); 620 goto err; 621 } 622 623 platform_set_drvdata(pdev, dcdc); 624 625 return 0; 626 627 err: 628 return ret; 629 } 630 631 static struct platform_driver wm831x_buckp_driver = { 632 .probe = wm831x_buckp_probe, 633 .driver = { 634 .name = "wm831x-buckp", 635 }, 636 }; 637 638 /* 639 * DCDC boost convertors 640 */ 641 642 static int wm831x_boostp_get_status(struct regulator_dev *rdev) 643 { 644 struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev); 645 struct wm831x *wm831x = dcdc->wm831x; 646 int ret; 647 648 /* First, check for errors */ 649 ret = wm831x_reg_read(wm831x, WM831X_DCDC_UV_STATUS); 650 if (ret < 0) 651 return ret; 652 653 if (ret & (1 << rdev_get_id(rdev))) { 654 dev_dbg(wm831x->dev, "DCDC%d under voltage\n", 655 rdev_get_id(rdev) + 1); 656 return REGULATOR_STATUS_ERROR; 657 } 658 659 /* Is the regulator on? */ 660 ret = wm831x_reg_read(wm831x, WM831X_DCDC_STATUS); 661 if (ret < 0) 662 return ret; 663 if (ret & (1 << rdev_get_id(rdev))) 664 return REGULATOR_STATUS_ON; 665 else 666 return REGULATOR_STATUS_OFF; 667 } 668 669 static const struct regulator_ops wm831x_boostp_ops = { 670 .get_status = wm831x_boostp_get_status, 671 672 .is_enabled = regulator_is_enabled_regmap, 673 .enable = regulator_enable_regmap, 674 .disable = regulator_disable_regmap, 675 }; 676 677 static int wm831x_boostp_probe(struct platform_device *pdev) 678 { 679 struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent); 680 struct wm831x_pdata *pdata = dev_get_platdata(wm831x->dev); 681 struct regulator_config config = { }; 682 int id = pdev->id % ARRAY_SIZE(pdata->dcdc); 683 struct wm831x_dcdc *dcdc; 684 struct resource *res; 685 int ret, irq; 686 687 dev_dbg(&pdev->dev, "Probing DCDC%d\n", id + 1); 688 689 if (pdata == NULL || pdata->dcdc[id] == NULL) 690 return -ENODEV; 691 692 dcdc = devm_kzalloc(&pdev->dev, sizeof(struct wm831x_dcdc), GFP_KERNEL); 693 if (!dcdc) 694 return -ENOMEM; 695 696 dcdc->wm831x = wm831x; 697 698 res = platform_get_resource(pdev, IORESOURCE_REG, 0); 699 if (res == NULL) { 700 dev_err(&pdev->dev, "No REG resource\n"); 701 return -EINVAL; 702 } 703 dcdc->base = res->start; 704 705 snprintf(dcdc->name, sizeof(dcdc->name), "DCDC%d", id + 1); 706 dcdc->desc.name = dcdc->name; 707 dcdc->desc.id = id; 708 dcdc->desc.type = REGULATOR_VOLTAGE; 709 dcdc->desc.ops = &wm831x_boostp_ops; 710 dcdc->desc.owner = THIS_MODULE; 711 dcdc->desc.enable_reg = WM831X_DCDC_ENABLE; 712 dcdc->desc.enable_mask = 1 << id; 713 714 config.dev = pdev->dev.parent; 715 if (pdata) 716 config.init_data = pdata->dcdc[id]; 717 config.driver_data = dcdc; 718 config.regmap = wm831x->regmap; 719 720 dcdc->regulator = devm_regulator_register(&pdev->dev, &dcdc->desc, 721 &config); 722 if (IS_ERR(dcdc->regulator)) { 723 ret = PTR_ERR(dcdc->regulator); 724 dev_err(wm831x->dev, "Failed to register DCDC%d: %d\n", 725 id + 1, ret); 726 return ret; 727 } 728 729 irq = wm831x_irq(wm831x, platform_get_irq_byname(pdev, "UV")); 730 ret = devm_request_threaded_irq(&pdev->dev, irq, NULL, 731 wm831x_dcdc_uv_irq, 732 IRQF_TRIGGER_RISING | IRQF_ONESHOT, 733 dcdc->name, 734 dcdc); 735 if (ret != 0) { 736 dev_err(&pdev->dev, "Failed to request UV IRQ %d: %d\n", 737 irq, ret); 738 return ret; 739 } 740 741 platform_set_drvdata(pdev, dcdc); 742 743 return 0; 744 } 745 746 static struct platform_driver wm831x_boostp_driver = { 747 .probe = wm831x_boostp_probe, 748 .driver = { 749 .name = "wm831x-boostp", 750 }, 751 }; 752 753 /* 754 * External Power Enable 755 * 756 * These aren't actually DCDCs but look like them in hardware so share 757 * code. 758 */ 759 760 #define WM831X_EPE_BASE 6 761 762 static const struct regulator_ops wm831x_epe_ops = { 763 .is_enabled = regulator_is_enabled_regmap, 764 .enable = regulator_enable_regmap, 765 .disable = regulator_disable_regmap, 766 .get_status = wm831x_dcdc_get_status, 767 }; 768 769 static int wm831x_epe_probe(struct platform_device *pdev) 770 { 771 struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent); 772 struct wm831x_pdata *pdata = dev_get_platdata(wm831x->dev); 773 struct regulator_config config = { }; 774 int id = pdev->id % ARRAY_SIZE(pdata->epe); 775 struct wm831x_dcdc *dcdc; 776 int ret; 777 778 dev_dbg(&pdev->dev, "Probing EPE%d\n", id + 1); 779 780 dcdc = devm_kzalloc(&pdev->dev, sizeof(struct wm831x_dcdc), GFP_KERNEL); 781 if (!dcdc) 782 return -ENOMEM; 783 784 dcdc->wm831x = wm831x; 785 786 /* For current parts this is correct; probably need to revisit 787 * in future. 788 */ 789 snprintf(dcdc->name, sizeof(dcdc->name), "EPE%d", id + 1); 790 dcdc->desc.name = dcdc->name; 791 dcdc->desc.id = id + WM831X_EPE_BASE; /* Offset in DCDC registers */ 792 dcdc->desc.ops = &wm831x_epe_ops; 793 dcdc->desc.type = REGULATOR_VOLTAGE; 794 dcdc->desc.owner = THIS_MODULE; 795 dcdc->desc.enable_reg = WM831X_DCDC_ENABLE; 796 dcdc->desc.enable_mask = 1 << dcdc->desc.id; 797 798 config.dev = pdev->dev.parent; 799 if (pdata) 800 config.init_data = pdata->epe[id]; 801 config.driver_data = dcdc; 802 config.regmap = wm831x->regmap; 803 804 dcdc->regulator = devm_regulator_register(&pdev->dev, &dcdc->desc, 805 &config); 806 if (IS_ERR(dcdc->regulator)) { 807 ret = PTR_ERR(dcdc->regulator); 808 dev_err(wm831x->dev, "Failed to register EPE%d: %d\n", 809 id + 1, ret); 810 goto err; 811 } 812 813 platform_set_drvdata(pdev, dcdc); 814 815 return 0; 816 817 err: 818 return ret; 819 } 820 821 static struct platform_driver wm831x_epe_driver = { 822 .probe = wm831x_epe_probe, 823 .driver = { 824 .name = "wm831x-epe", 825 }, 826 }; 827 828 static struct platform_driver * const drivers[] = { 829 &wm831x_buckv_driver, 830 &wm831x_buckp_driver, 831 &wm831x_boostp_driver, 832 &wm831x_epe_driver, 833 }; 834 835 static int __init wm831x_dcdc_init(void) 836 { 837 return platform_register_drivers(drivers, ARRAY_SIZE(drivers)); 838 } 839 subsys_initcall(wm831x_dcdc_init); 840 841 static void __exit wm831x_dcdc_exit(void) 842 { 843 platform_unregister_drivers(drivers, ARRAY_SIZE(drivers)); 844 } 845 module_exit(wm831x_dcdc_exit); 846 847 /* Module information */ 848 MODULE_AUTHOR("Mark Brown"); 849 MODULE_DESCRIPTION("WM831x DC-DC convertor driver"); 850 MODULE_LICENSE("GPL"); 851 MODULE_ALIAS("platform:wm831x-buckv"); 852 MODULE_ALIAS("platform:wm831x-buckp"); 853 MODULE_ALIAS("platform:wm831x-boostp"); 854 MODULE_ALIAS("platform:wm831x-epe"); 855