1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Core MFD support for Cirrus Logic Madera codecs 4 * 5 * Copyright (C) 2015-2018 Cirrus Logic 6 */ 7 8 #include <linux/device.h> 9 #include <linux/delay.h> 10 #include <linux/err.h> 11 #include <linux/gpio.h> 12 #include <linux/mfd/core.h> 13 #include <linux/module.h> 14 #include <linux/mutex.h> 15 #include <linux/notifier.h> 16 #include <linux/of.h> 17 #include <linux/of_gpio.h> 18 #include <linux/platform_device.h> 19 #include <linux/pm_runtime.h> 20 #include <linux/regmap.h> 21 #include <linux/regulator/consumer.h> 22 #include <linux/regulator/machine.h> 23 #include <linux/regulator/of_regulator.h> 24 25 #include <linux/mfd/madera/core.h> 26 #include <linux/mfd/madera/registers.h> 27 28 #include "madera.h" 29 30 #define CS47L15_SILICON_ID 0x6370 31 #define CS47L35_SILICON_ID 0x6360 32 #define CS47L85_SILICON_ID 0x6338 33 #define CS47L90_SILICON_ID 0x6364 34 #define CS47L92_SILICON_ID 0x6371 35 36 #define MADERA_32KZ_MCLK2 1 37 38 #define MADERA_RESET_MIN_US 2000 39 #define MADERA_RESET_MAX_US 3000 40 41 #define ERRATA_DCVDD_MIN_US 10000 42 #define ERRATA_DCVDD_MAX_US 15000 43 44 static const char * const madera_core_supplies[] = { 45 "AVDD", 46 "DBVDD1", 47 }; 48 49 static const struct mfd_cell madera_ldo1_devs[] = { 50 { 51 .name = "madera-ldo1", 52 .level = MFD_DEP_LEVEL_HIGH, 53 }, 54 }; 55 56 static const char * const cs47l15_supplies[] = { 57 "MICVDD", 58 "CPVDD1", 59 "SPKVDD", 60 }; 61 62 static const struct mfd_cell cs47l15_devs[] = { 63 { .name = "madera-pinctrl", }, 64 { .name = "madera-irq", }, 65 { .name = "madera-gpio", }, 66 { 67 .name = "madera-extcon", 68 .parent_supplies = cs47l15_supplies, 69 .num_parent_supplies = 1, /* We only need MICVDD */ 70 }, 71 { 72 .name = "cs47l15-codec", 73 .parent_supplies = cs47l15_supplies, 74 .num_parent_supplies = ARRAY_SIZE(cs47l15_supplies), 75 }, 76 }; 77 78 static const char * const cs47l35_supplies[] = { 79 "MICVDD", 80 "DBVDD2", 81 "CPVDD1", 82 "CPVDD2", 83 "SPKVDD", 84 }; 85 86 static const struct mfd_cell cs47l35_devs[] = { 87 { .name = "madera-pinctrl", }, 88 { .name = "madera-irq", }, 89 { .name = "madera-micsupp", }, 90 { .name = "madera-gpio", }, 91 { 92 .name = "madera-extcon", 93 .parent_supplies = cs47l35_supplies, 94 .num_parent_supplies = 1, /* We only need MICVDD */ 95 }, 96 { 97 .name = "cs47l35-codec", 98 .parent_supplies = cs47l35_supplies, 99 .num_parent_supplies = ARRAY_SIZE(cs47l35_supplies), 100 }, 101 }; 102 103 static const char * const cs47l85_supplies[] = { 104 "MICVDD", 105 "DBVDD2", 106 "DBVDD3", 107 "DBVDD4", 108 "CPVDD1", 109 "CPVDD2", 110 "SPKVDDL", 111 "SPKVDDR", 112 }; 113 114 static const struct mfd_cell cs47l85_devs[] = { 115 { .name = "madera-pinctrl", }, 116 { .name = "madera-irq", }, 117 { .name = "madera-micsupp", }, 118 { .name = "madera-gpio", }, 119 { 120 .name = "madera-extcon", 121 .parent_supplies = cs47l85_supplies, 122 .num_parent_supplies = 1, /* We only need MICVDD */ 123 }, 124 { 125 .name = "cs47l85-codec", 126 .parent_supplies = cs47l85_supplies, 127 .num_parent_supplies = ARRAY_SIZE(cs47l85_supplies), 128 }, 129 }; 130 131 static const char * const cs47l90_supplies[] = { 132 "MICVDD", 133 "DBVDD2", 134 "DBVDD3", 135 "DBVDD4", 136 "CPVDD1", 137 "CPVDD2", 138 }; 139 140 static const struct mfd_cell cs47l90_devs[] = { 141 { .name = "madera-pinctrl", }, 142 { .name = "madera-irq", }, 143 { .name = "madera-micsupp", }, 144 { .name = "madera-gpio", }, 145 { 146 .name = "madera-extcon", 147 .parent_supplies = cs47l90_supplies, 148 .num_parent_supplies = 1, /* We only need MICVDD */ 149 }, 150 { 151 .name = "cs47l90-codec", 152 .parent_supplies = cs47l90_supplies, 153 .num_parent_supplies = ARRAY_SIZE(cs47l90_supplies), 154 }, 155 }; 156 157 static const char * const cs47l92_supplies[] = { 158 "MICVDD", 159 "CPVDD1", 160 "CPVDD2", 161 }; 162 163 static const struct mfd_cell cs47l92_devs[] = { 164 { .name = "madera-pinctrl", }, 165 { .name = "madera-irq", }, 166 { .name = "madera-micsupp", }, 167 { .name = "madera-gpio", }, 168 { 169 .name = "madera-extcon", 170 .parent_supplies = cs47l92_supplies, 171 .num_parent_supplies = 1, /* We only need MICVDD */ 172 }, 173 { 174 .name = "cs47l92-codec", 175 .parent_supplies = cs47l92_supplies, 176 .num_parent_supplies = ARRAY_SIZE(cs47l92_supplies), 177 }, 178 }; 179 180 /* Used by madera-i2c and madera-spi drivers */ 181 const char *madera_name_from_type(enum madera_type type) 182 { 183 switch (type) { 184 case CS47L15: 185 return "CS47L15"; 186 case CS47L35: 187 return "CS47L35"; 188 case CS47L85: 189 return "CS47L85"; 190 case CS47L90: 191 return "CS47L90"; 192 case CS47L91: 193 return "CS47L91"; 194 case CS42L92: 195 return "CS42L92"; 196 case CS47L92: 197 return "CS47L92"; 198 case CS47L93: 199 return "CS47L93"; 200 case WM1840: 201 return "WM1840"; 202 default: 203 return "Unknown"; 204 } 205 } 206 EXPORT_SYMBOL_GPL(madera_name_from_type); 207 208 #define MADERA_BOOT_POLL_INTERVAL_USEC 5000 209 #define MADERA_BOOT_POLL_TIMEOUT_USEC 25000 210 211 static int madera_wait_for_boot_noack(struct madera *madera) 212 { 213 ktime_t timeout; 214 unsigned int val = 0; 215 int ret = 0; 216 217 /* 218 * We can't use an interrupt as we need to runtime resume to do so, 219 * so we poll the status bit. This won't race with the interrupt 220 * handler because it will be blocked on runtime resume. 221 * The chip could NAK a read request while it is booting so ignore 222 * errors from regmap_read. 223 */ 224 timeout = ktime_add_us(ktime_get(), MADERA_BOOT_POLL_TIMEOUT_USEC); 225 regmap_read(madera->regmap, MADERA_IRQ1_RAW_STATUS_1, &val); 226 while (!(val & MADERA_BOOT_DONE_STS1) && 227 !ktime_after(ktime_get(), timeout)) { 228 usleep_range(MADERA_BOOT_POLL_INTERVAL_USEC / 2, 229 MADERA_BOOT_POLL_INTERVAL_USEC); 230 regmap_read(madera->regmap, MADERA_IRQ1_RAW_STATUS_1, &val); 231 } 232 233 if (!(val & MADERA_BOOT_DONE_STS1)) { 234 dev_err(madera->dev, "Polling BOOT_DONE_STS timed out\n"); 235 ret = -ETIMEDOUT; 236 } 237 238 return ret; 239 } 240 241 static int madera_wait_for_boot(struct madera *madera) 242 { 243 int ret = madera_wait_for_boot_noack(madera); 244 245 /* 246 * BOOT_DONE defaults to unmasked on boot so we must ack it. 247 * Do this even after a timeout to avoid interrupt storms. 248 */ 249 regmap_write(madera->regmap, MADERA_IRQ1_STATUS_1, 250 MADERA_BOOT_DONE_EINT1); 251 252 pm_runtime_mark_last_busy(madera->dev); 253 254 return ret; 255 } 256 257 static int madera_soft_reset(struct madera *madera) 258 { 259 int ret; 260 261 ret = regmap_write(madera->regmap, MADERA_SOFTWARE_RESET, 0); 262 if (ret != 0) { 263 dev_err(madera->dev, "Failed to soft reset device: %d\n", ret); 264 return ret; 265 } 266 267 /* Allow time for internal clocks to startup after reset */ 268 usleep_range(MADERA_RESET_MIN_US, MADERA_RESET_MAX_US); 269 270 return 0; 271 } 272 273 static void madera_enable_hard_reset(struct madera *madera) 274 { 275 /* 276 * There are many existing out-of-tree users of these codecs that we 277 * can't break so preserve the expected behaviour of setting the line 278 * low to assert reset. 279 */ 280 gpiod_set_raw_value_cansleep(madera->pdata.reset, 0); 281 } 282 283 static void madera_disable_hard_reset(struct madera *madera) 284 { 285 gpiod_set_raw_value_cansleep(madera->pdata.reset, 1); 286 287 usleep_range(MADERA_RESET_MIN_US, MADERA_RESET_MAX_US); 288 } 289 290 static int __maybe_unused madera_runtime_resume(struct device *dev) 291 { 292 struct madera *madera = dev_get_drvdata(dev); 293 int ret; 294 295 dev_dbg(dev, "Leaving sleep mode\n"); 296 297 if (!madera->reset_errata) 298 madera_enable_hard_reset(madera); 299 300 ret = regulator_enable(madera->dcvdd); 301 if (ret) { 302 dev_err(dev, "Failed to enable DCVDD: %d\n", ret); 303 return ret; 304 } 305 306 regcache_cache_only(madera->regmap, false); 307 regcache_cache_only(madera->regmap_32bit, false); 308 309 if (madera->reset_errata) 310 usleep_range(ERRATA_DCVDD_MIN_US, ERRATA_DCVDD_MAX_US); 311 else 312 madera_disable_hard_reset(madera); 313 314 if (!madera->pdata.reset || madera->reset_errata) { 315 ret = madera_wait_for_boot(madera); 316 if (ret) 317 goto err; 318 319 ret = madera_soft_reset(madera); 320 if (ret) { 321 dev_err(dev, "Failed to reset: %d\n", ret); 322 goto err; 323 } 324 } 325 326 ret = madera_wait_for_boot(madera); 327 if (ret) 328 goto err; 329 330 ret = regcache_sync(madera->regmap); 331 if (ret) { 332 dev_err(dev, "Failed to restore 16-bit register cache\n"); 333 goto err; 334 } 335 336 ret = regcache_sync(madera->regmap_32bit); 337 if (ret) { 338 dev_err(dev, "Failed to restore 32-bit register cache\n"); 339 goto err; 340 } 341 342 return 0; 343 344 err: 345 regcache_cache_only(madera->regmap_32bit, true); 346 regcache_cache_only(madera->regmap, true); 347 regulator_disable(madera->dcvdd); 348 349 return ret; 350 } 351 352 static int __maybe_unused madera_runtime_suspend(struct device *dev) 353 { 354 struct madera *madera = dev_get_drvdata(dev); 355 356 dev_dbg(madera->dev, "Entering sleep mode\n"); 357 358 regcache_cache_only(madera->regmap, true); 359 regcache_mark_dirty(madera->regmap); 360 regcache_cache_only(madera->regmap_32bit, true); 361 regcache_mark_dirty(madera->regmap_32bit); 362 363 regulator_disable(madera->dcvdd); 364 365 return 0; 366 } 367 368 const struct dev_pm_ops madera_pm_ops = { 369 SET_RUNTIME_PM_OPS(madera_runtime_suspend, 370 madera_runtime_resume, 371 NULL) 372 }; 373 EXPORT_SYMBOL_GPL(madera_pm_ops); 374 375 const struct of_device_id madera_of_match[] = { 376 { .compatible = "cirrus,cs47l15", .data = (void *)CS47L15 }, 377 { .compatible = "cirrus,cs47l35", .data = (void *)CS47L35 }, 378 { .compatible = "cirrus,cs47l85", .data = (void *)CS47L85 }, 379 { .compatible = "cirrus,cs47l90", .data = (void *)CS47L90 }, 380 { .compatible = "cirrus,cs47l91", .data = (void *)CS47L91 }, 381 { .compatible = "cirrus,cs42l92", .data = (void *)CS42L92 }, 382 { .compatible = "cirrus,cs47l92", .data = (void *)CS47L92 }, 383 { .compatible = "cirrus,cs47l93", .data = (void *)CS47L93 }, 384 { .compatible = "cirrus,wm1840", .data = (void *)WM1840 }, 385 {} 386 }; 387 MODULE_DEVICE_TABLE(of, madera_of_match); 388 EXPORT_SYMBOL_GPL(madera_of_match); 389 390 static int madera_get_reset_gpio(struct madera *madera) 391 { 392 struct gpio_desc *reset; 393 394 if (madera->pdata.reset) 395 return 0; 396 397 reset = devm_gpiod_get_optional(madera->dev, "reset", GPIOD_OUT_LOW); 398 if (IS_ERR(reset)) 399 return dev_err_probe(madera->dev, PTR_ERR(reset), 400 "Failed to request /RESET"); 401 402 /* 403 * A hard reset is needed for full reset of the chip. We allow running 404 * without hard reset only because it can be useful for early 405 * prototyping and some debugging, but we need to warn it's not ideal. 406 */ 407 if (!reset) 408 dev_warn(madera->dev, 409 "Running without reset GPIO is not recommended\n"); 410 411 madera->pdata.reset = reset; 412 413 return 0; 414 } 415 416 static void madera_set_micbias_info(struct madera *madera) 417 { 418 /* 419 * num_childbias is an array because future codecs can have different 420 * childbiases for each micbias. Unspecified values default to 0. 421 */ 422 switch (madera->type) { 423 case CS47L15: 424 madera->num_micbias = 1; 425 madera->num_childbias[0] = 3; 426 return; 427 case CS47L35: 428 madera->num_micbias = 2; 429 madera->num_childbias[0] = 2; 430 madera->num_childbias[1] = 2; 431 return; 432 case CS47L85: 433 case WM1840: 434 madera->num_micbias = 4; 435 /* no child biases */ 436 return; 437 case CS47L90: 438 case CS47L91: 439 madera->num_micbias = 2; 440 madera->num_childbias[0] = 4; 441 madera->num_childbias[1] = 4; 442 return; 443 case CS42L92: 444 case CS47L92: 445 case CS47L93: 446 madera->num_micbias = 2; 447 madera->num_childbias[0] = 4; 448 madera->num_childbias[1] = 2; 449 return; 450 default: 451 return; 452 } 453 } 454 455 int madera_dev_init(struct madera *madera) 456 { 457 struct device *dev = madera->dev; 458 unsigned int hwid; 459 int (*patch_fn)(struct madera *) = NULL; 460 const struct mfd_cell *mfd_devs; 461 int n_devs = 0; 462 int i, ret; 463 464 dev_set_drvdata(madera->dev, madera); 465 BLOCKING_INIT_NOTIFIER_HEAD(&madera->notifier); 466 mutex_init(&madera->dapm_ptr_lock); 467 468 madera_set_micbias_info(madera); 469 470 /* 471 * We need writable hw config info that all children can share. 472 * Simplest to take one shared copy of pdata struct. 473 */ 474 if (dev_get_platdata(madera->dev)) { 475 memcpy(&madera->pdata, dev_get_platdata(madera->dev), 476 sizeof(madera->pdata)); 477 } 478 479 madera->mclk[MADERA_MCLK1].id = "mclk1"; 480 madera->mclk[MADERA_MCLK2].id = "mclk2"; 481 madera->mclk[MADERA_MCLK3].id = "mclk3"; 482 483 ret = devm_clk_bulk_get_optional(madera->dev, ARRAY_SIZE(madera->mclk), 484 madera->mclk); 485 if (ret) { 486 dev_err(madera->dev, "Failed to get clocks: %d\n", ret); 487 return ret; 488 } 489 490 /* Not using devm_clk_get to prevent breakage of existing DTs */ 491 if (!madera->mclk[MADERA_MCLK2].clk) 492 dev_warn(madera->dev, "Missing MCLK2, requires 32kHz clock\n"); 493 494 ret = madera_get_reset_gpio(madera); 495 if (ret) 496 return ret; 497 498 regcache_cache_only(madera->regmap, true); 499 regcache_cache_only(madera->regmap_32bit, true); 500 501 for (i = 0; i < ARRAY_SIZE(madera_core_supplies); i++) 502 madera->core_supplies[i].supply = madera_core_supplies[i]; 503 504 madera->num_core_supplies = ARRAY_SIZE(madera_core_supplies); 505 506 /* 507 * On some codecs DCVDD could be supplied by the internal LDO1. 508 * For those we must add the LDO1 driver before requesting DCVDD 509 * No devm_ because we need to control shutdown order of children. 510 */ 511 switch (madera->type) { 512 case CS47L15: 513 madera->reset_errata = true; 514 break; 515 case CS47L35: 516 case CS47L90: 517 case CS47L91: 518 case CS42L92: 519 case CS47L92: 520 case CS47L93: 521 break; 522 case CS47L85: 523 case WM1840: 524 ret = mfd_add_devices(madera->dev, PLATFORM_DEVID_NONE, 525 madera_ldo1_devs, 526 ARRAY_SIZE(madera_ldo1_devs), 527 NULL, 0, NULL); 528 if (ret) { 529 dev_err(dev, "Failed to add LDO1 child: %d\n", ret); 530 return ret; 531 } 532 break; 533 default: 534 /* No point continuing if the type is unknown */ 535 dev_err(madera->dev, "Unknown device type %d\n", madera->type); 536 return -ENODEV; 537 } 538 539 ret = devm_regulator_bulk_get(dev, madera->num_core_supplies, 540 madera->core_supplies); 541 if (ret) { 542 dev_err(dev, "Failed to request core supplies: %d\n", ret); 543 goto err_devs; 544 } 545 546 /* 547 * Don't use devres here. If the regulator is one of our children it 548 * will already have been removed before devres cleanup on this mfd 549 * driver tries to call put() on it. We need control of shutdown order. 550 */ 551 madera->dcvdd = regulator_get(madera->dev, "DCVDD"); 552 if (IS_ERR(madera->dcvdd)) { 553 ret = PTR_ERR(madera->dcvdd); 554 dev_err(dev, "Failed to request DCVDD: %d\n", ret); 555 goto err_devs; 556 } 557 558 ret = regulator_bulk_enable(madera->num_core_supplies, 559 madera->core_supplies); 560 if (ret) { 561 dev_err(dev, "Failed to enable core supplies: %d\n", ret); 562 goto err_dcvdd; 563 } 564 565 if (madera->reset_errata) 566 madera_disable_hard_reset(madera); 567 568 ret = regulator_enable(madera->dcvdd); 569 if (ret) { 570 dev_err(dev, "Failed to enable DCVDD: %d\n", ret); 571 goto err_enable; 572 } 573 574 if (madera->reset_errata) 575 usleep_range(ERRATA_DCVDD_MIN_US, ERRATA_DCVDD_MAX_US); 576 else 577 madera_disable_hard_reset(madera); 578 579 regcache_cache_only(madera->regmap, false); 580 regcache_cache_only(madera->regmap_32bit, false); 581 582 ret = madera_wait_for_boot_noack(madera); 583 if (ret) { 584 dev_err(madera->dev, "Device failed initial boot: %d\n", ret); 585 goto err_reset; 586 } 587 588 /* 589 * Now we can power up and verify that this is a chip we know about 590 * before we start doing any writes to its registers. 591 */ 592 ret = regmap_read(madera->regmap, MADERA_SOFTWARE_RESET, &hwid); 593 if (ret) { 594 dev_err(dev, "Failed to read ID register: %d\n", ret); 595 goto err_reset; 596 } 597 598 switch (hwid) { 599 case CS47L15_SILICON_ID: 600 if (IS_ENABLED(CONFIG_MFD_CS47L15)) { 601 switch (madera->type) { 602 case CS47L15: 603 patch_fn = &cs47l15_patch; 604 mfd_devs = cs47l15_devs; 605 n_devs = ARRAY_SIZE(cs47l15_devs); 606 break; 607 default: 608 break; 609 } 610 } 611 break; 612 case CS47L35_SILICON_ID: 613 if (IS_ENABLED(CONFIG_MFD_CS47L35)) { 614 switch (madera->type) { 615 case CS47L35: 616 patch_fn = cs47l35_patch; 617 mfd_devs = cs47l35_devs; 618 n_devs = ARRAY_SIZE(cs47l35_devs); 619 break; 620 default: 621 break; 622 } 623 } 624 break; 625 case CS47L85_SILICON_ID: 626 if (IS_ENABLED(CONFIG_MFD_CS47L85)) { 627 switch (madera->type) { 628 case CS47L85: 629 case WM1840: 630 patch_fn = cs47l85_patch; 631 mfd_devs = cs47l85_devs; 632 n_devs = ARRAY_SIZE(cs47l85_devs); 633 break; 634 default: 635 break; 636 } 637 } 638 break; 639 case CS47L90_SILICON_ID: 640 if (IS_ENABLED(CONFIG_MFD_CS47L90)) { 641 switch (madera->type) { 642 case CS47L90: 643 case CS47L91: 644 patch_fn = cs47l90_patch; 645 mfd_devs = cs47l90_devs; 646 n_devs = ARRAY_SIZE(cs47l90_devs); 647 break; 648 default: 649 break; 650 } 651 } 652 break; 653 case CS47L92_SILICON_ID: 654 if (IS_ENABLED(CONFIG_MFD_CS47L92)) { 655 switch (madera->type) { 656 case CS42L92: 657 case CS47L92: 658 case CS47L93: 659 patch_fn = cs47l92_patch; 660 mfd_devs = cs47l92_devs; 661 n_devs = ARRAY_SIZE(cs47l92_devs); 662 break; 663 default: 664 break; 665 } 666 } 667 break; 668 default: 669 dev_err(madera->dev, "Unknown device ID: %x\n", hwid); 670 ret = -EINVAL; 671 goto err_reset; 672 } 673 674 if (!n_devs) { 675 dev_err(madera->dev, "Device ID 0x%x not a %s\n", hwid, 676 madera->type_name); 677 ret = -ENODEV; 678 goto err_reset; 679 } 680 681 /* 682 * It looks like a device we support. If we don't have a hard reset 683 * we can now attempt a soft reset. 684 */ 685 if (!madera->pdata.reset || madera->reset_errata) { 686 ret = madera_soft_reset(madera); 687 if (ret) 688 goto err_reset; 689 } 690 691 ret = madera_wait_for_boot(madera); 692 if (ret) { 693 dev_err(madera->dev, "Failed to clear boot done: %d\n", ret); 694 goto err_reset; 695 } 696 697 ret = regmap_read(madera->regmap, MADERA_HARDWARE_REVISION, 698 &madera->rev); 699 if (ret) { 700 dev_err(dev, "Failed to read revision register: %d\n", ret); 701 goto err_reset; 702 } 703 madera->rev &= MADERA_HW_REVISION_MASK; 704 705 dev_info(dev, "%s silicon revision %d\n", madera->type_name, 706 madera->rev); 707 708 /* Apply hardware patch */ 709 if (patch_fn) { 710 ret = patch_fn(madera); 711 if (ret) { 712 dev_err(madera->dev, "Failed to apply patch %d\n", ret); 713 goto err_reset; 714 } 715 } 716 717 /* Init 32k clock sourced from MCLK2 */ 718 ret = clk_prepare_enable(madera->mclk[MADERA_MCLK2].clk); 719 if (ret) { 720 dev_err(madera->dev, "Failed to enable 32k clock: %d\n", ret); 721 goto err_reset; 722 } 723 724 ret = regmap_update_bits(madera->regmap, 725 MADERA_CLOCK_32K_1, 726 MADERA_CLK_32K_ENA_MASK | MADERA_CLK_32K_SRC_MASK, 727 MADERA_CLK_32K_ENA | MADERA_32KZ_MCLK2); 728 if (ret) { 729 dev_err(madera->dev, "Failed to init 32k clock: %d\n", ret); 730 goto err_clock; 731 } 732 733 pm_runtime_set_active(madera->dev); 734 pm_runtime_enable(madera->dev); 735 pm_runtime_set_autosuspend_delay(madera->dev, 100); 736 pm_runtime_use_autosuspend(madera->dev); 737 738 /* No devm_ because we need to control shutdown order of children */ 739 ret = mfd_add_devices(madera->dev, PLATFORM_DEVID_NONE, 740 mfd_devs, n_devs, 741 NULL, 0, NULL); 742 if (ret) { 743 dev_err(madera->dev, "Failed to add subdevices: %d\n", ret); 744 goto err_pm_runtime; 745 } 746 747 return 0; 748 749 err_pm_runtime: 750 pm_runtime_disable(madera->dev); 751 err_clock: 752 clk_disable_unprepare(madera->mclk[MADERA_MCLK2].clk); 753 err_reset: 754 madera_enable_hard_reset(madera); 755 regulator_disable(madera->dcvdd); 756 err_enable: 757 regulator_bulk_disable(madera->num_core_supplies, 758 madera->core_supplies); 759 err_dcvdd: 760 regulator_put(madera->dcvdd); 761 err_devs: 762 mfd_remove_devices(dev); 763 764 return ret; 765 } 766 EXPORT_SYMBOL_GPL(madera_dev_init); 767 768 int madera_dev_exit(struct madera *madera) 769 { 770 /* Prevent any IRQs being serviced while we clean up */ 771 disable_irq(madera->irq); 772 773 pm_runtime_get_sync(madera->dev); 774 775 mfd_remove_devices(madera->dev); 776 777 pm_runtime_disable(madera->dev); 778 779 regulator_disable(madera->dcvdd); 780 regulator_put(madera->dcvdd); 781 782 mfd_remove_devices_late(madera->dev); 783 784 pm_runtime_set_suspended(madera->dev); 785 pm_runtime_put_noidle(madera->dev); 786 787 clk_disable_unprepare(madera->mclk[MADERA_MCLK2].clk); 788 789 madera_enable_hard_reset(madera); 790 791 regulator_bulk_disable(madera->num_core_supplies, 792 madera->core_supplies); 793 return 0; 794 } 795 EXPORT_SYMBOL_GPL(madera_dev_exit); 796 797 MODULE_DESCRIPTION("Madera core MFD driver"); 798 MODULE_AUTHOR("Richard Fitzgerald <rf@opensource.cirrus.com>"); 799 MODULE_LICENSE("GPL v2"); 800