drivers/mfd/madera-core.c

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