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