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         madera_enable_hard_reset(madera);
 295
 296         ret = regulator_enable(madera->dcvdd);
 297         if (ret) {
 298                 dev_err(dev, "Failed to enable DCVDD: %d\n", ret);
 299                 return ret;
 300         }
 301
 302         regcache_cache_only(madera->regmap, false);
 303         regcache_cache_only(madera->regmap_32bit, false);
 304
 305         madera_disable_hard_reset(madera);
 306
 307         if (!madera->pdata.reset) {
 308                 ret = madera_wait_for_boot(madera);
 309                 if (ret)
 310                         goto err;
 311
 312                 ret = madera_soft_reset(madera);
 313                 if (ret) {
 314                         dev_err(dev, "Failed to reset: %d\n", ret);
 315                         goto err;
 316                 }
 317         }
 318
 319         ret = madera_wait_for_boot(madera);
 320         if (ret)
 321                 goto err;
 322
 323         ret = regcache_sync(madera->regmap);
 324         if (ret) {
 325                 dev_err(dev, "Failed to restore 16-bit register cache\n");
 326                 goto err;
 327         }
 328
 329         ret = regcache_sync(madera->regmap_32bit);
 330         if (ret) {
 331                 dev_err(dev, "Failed to restore 32-bit register cache\n");
 332                 goto err;
 333         }
 334
 335         return 0;
 336
 337 err:
 338         regcache_cache_only(madera->regmap_32bit, true);
 339         regcache_cache_only(madera->regmap, true);
 340         regulator_disable(madera->dcvdd);
 341
 342         return ret;
 343 }
 344
 345 static int __maybe_unused madera_runtime_suspend(struct device *dev)
 346 {
 347         struct madera *madera = dev_get_drvdata(dev);
 348
 349         dev_dbg(madera->dev, "Entering sleep mode\n");
 350
 351         regcache_cache_only(madera->regmap, true);
 352         regcache_mark_dirty(madera->regmap);
 353         regcache_cache_only(madera->regmap_32bit, true);
 354         regcache_mark_dirty(madera->regmap_32bit);
 355
 356         regulator_disable(madera->dcvdd);
 357
 358         return 0;
 359 }
 360
 361 const struct dev_pm_ops madera_pm_ops = {
 362         SET_RUNTIME_PM_OPS(madera_runtime_suspend,
 363                            madera_runtime_resume,
 364                            NULL)
 365 };
 366 EXPORT_SYMBOL_GPL(madera_pm_ops);
 367
 368 const struct of_device_id madera_of_match[] = {
 369         { .compatible = "cirrus,cs47l15", .data = (void *)CS47L15 },
 370         { .compatible = "cirrus,cs47l35", .data = (void *)CS47L35 },
 371         { .compatible = "cirrus,cs47l85", .data = (void *)CS47L85 },
 372         { .compatible = "cirrus,cs47l90", .data = (void *)CS47L90 },
 373         { .compatible = "cirrus,cs47l91", .data = (void *)CS47L91 },
 374         { .compatible = "cirrus,cs42l92", .data = (void *)CS42L92 },
 375         { .compatible = "cirrus,cs47l92", .data = (void *)CS47L92 },
 376         { .compatible = "cirrus,cs47l93", .data = (void *)CS47L93 },
 377         { .compatible = "cirrus,wm1840", .data = (void *)WM1840 },
 378         {}
 379 };
 380 MODULE_DEVICE_TABLE(of, madera_of_match);
 381 EXPORT_SYMBOL_GPL(madera_of_match);
 382
 383 static int madera_get_reset_gpio(struct madera *madera)
 384 {
 385         struct gpio_desc *reset;
 386
 387         if (madera->pdata.reset)
 388                 return 0;
 389
 390         reset = devm_gpiod_get_optional(madera->dev, "reset", GPIOD_OUT_LOW);
 391         if (IS_ERR(reset))
 392                 return dev_err_probe(madera->dev, PTR_ERR(reset),
 393                                 "Failed to request /RESET");
 394
 395         /*
 396          * A hard reset is needed for full reset of the chip. We allow running
 397          * without hard reset only because it can be useful for early
 398          * prototyping and some debugging, but we need to warn it's not ideal.
 399          */
 400         if (!reset)
 401                 dev_warn(madera->dev,
 402                          "Running without reset GPIO is not recommended\n");
 403
 404         madera->pdata.reset = reset;
 405
 406         return 0;
 407 }
 408
 409 static void madera_set_micbias_info(struct madera *madera)
 410 {
 411         /*
 412          * num_childbias is an array because future codecs can have different
 413          * childbiases for each micbias. Unspecified values default to 0.
 414          */
 415         switch (madera->type) {
 416         case CS47L15:
 417                 madera->num_micbias = 1;
 418                 madera->num_childbias[0] = 3;
 419                 return;
 420         case CS47L35:
 421                 madera->num_micbias = 2;
 422                 madera->num_childbias[0] = 2;
 423                 madera->num_childbias[1] = 2;
 424                 return;
 425         case CS47L85:
 426         case WM1840:
 427                 madera->num_micbias = 4;
 428                 /* no child biases */
 429                 return;
 430         case CS47L90:
 431         case CS47L91:
 432                 madera->num_micbias = 2;
 433                 madera->num_childbias[0] = 4;
 434                 madera->num_childbias[1] = 4;
 435                 return;
 436         case CS42L92:
 437         case CS47L92:
 438         case CS47L93:
 439                 madera->num_micbias = 2;
 440                 madera->num_childbias[0] = 4;
 441                 madera->num_childbias[1] = 2;
 442                 return;
 443         default:
 444                 return;
 445         }
 446 }
 447
 448 int madera_dev_init(struct madera *madera)
 449 {
 450         struct device *dev = madera->dev;
 451         unsigned int hwid;
 452         int (*patch_fn)(struct madera *) = NULL;
 453         const struct mfd_cell *mfd_devs;
 454         int n_devs = 0;
 455         int i, ret;
 456
 457         dev_set_drvdata(madera->dev, madera);
 458         BLOCKING_INIT_NOTIFIER_HEAD(&madera->notifier);
 459         mutex_init(&madera->dapm_ptr_lock);
 460
 461         madera_set_micbias_info(madera);
 462
 463         /*
 464          * We need writable hw config info that all children can share.
 465          * Simplest to take one shared copy of pdata struct.
 466          */
 467         if (dev_get_platdata(madera->dev)) {
 468                 memcpy(&madera->pdata, dev_get_platdata(madera->dev),
 469                        sizeof(madera->pdata));
 470         }
 471
 472         madera->mclk[MADERA_MCLK1].id = "mclk1";
 473         madera->mclk[MADERA_MCLK2].id = "mclk2";
 474         madera->mclk[MADERA_MCLK3].id = "mclk3";
 475
 476         ret = devm_clk_bulk_get_optional(madera->dev, ARRAY_SIZE(madera->mclk),
 477                                          madera->mclk);
 478         if (ret) {
 479                 dev_err(madera->dev, "Failed to get clocks: %d\n", ret);
 480                 return ret;
 481         }
 482
 483         /* Not using devm_clk_get to prevent breakage of existing DTs */
 484         if (!madera->mclk[MADERA_MCLK2].clk)
 485                 dev_warn(madera->dev, "Missing MCLK2, requires 32kHz clock\n");
 486
 487         ret = madera_get_reset_gpio(madera);
 488         if (ret)
 489                 return ret;
 490
 491         regcache_cache_only(madera->regmap, true);
 492         regcache_cache_only(madera->regmap_32bit, true);
 493
 494         for (i = 0; i < ARRAY_SIZE(madera_core_supplies); i++)
 495                 madera->core_supplies[i].supply = madera_core_supplies[i];
 496
 497         madera->num_core_supplies = ARRAY_SIZE(madera_core_supplies);
 498
 499         /*
 500          * On some codecs DCVDD could be supplied by the internal LDO1.
 501          * For those we must add the LDO1 driver before requesting DCVDD
 502          * No devm_ because we need to control shutdown order of children.
 503          */
 504         switch (madera->type) {
 505         case CS47L15:
 506         case CS47L35:
 507         case CS47L90:
 508         case CS47L91:
 509         case CS42L92:
 510         case CS47L92:
 511         case CS47L93:
 512                 break;
 513         case CS47L85:
 514         case WM1840:
 515                 ret = mfd_add_devices(madera->dev, PLATFORM_DEVID_NONE,
 516                                       madera_ldo1_devs,
 517                                       ARRAY_SIZE(madera_ldo1_devs),
 518                                       NULL, 0, NULL);
 519                 if (ret) {
 520                         dev_err(dev, "Failed to add LDO1 child: %d\n", ret);
 521                         return ret;
 522                 }
 523                 break;
 524         default:
 525                 /* No point continuing if the type is unknown */
 526                 dev_err(madera->dev, "Unknown device type %d\n", madera->type);
 527                 return -ENODEV;
 528         }
 529
 530         ret = devm_regulator_bulk_get(dev, madera->num_core_supplies,
 531                                       madera->core_supplies);
 532         if (ret) {
 533                 dev_err(dev, "Failed to request core supplies: %d\n", ret);
 534                 goto err_devs;
 535         }
 536
 537         /*
 538          * Don't use devres here. If the regulator is one of our children it
 539          * will already have been removed before devres cleanup on this mfd
 540          * driver tries to call put() on it. We need control of shutdown order.
 541          */
 542         madera->dcvdd = regulator_get(madera->dev, "DCVDD");
 543         if (IS_ERR(madera->dcvdd)) {
 544                 ret = PTR_ERR(madera->dcvdd);
 545                 dev_err(dev, "Failed to request DCVDD: %d\n", ret);
 546                 goto err_devs;
 547         }
 548
 549         ret = regulator_bulk_enable(madera->num_core_supplies,
 550                                     madera->core_supplies);
 551         if (ret) {
 552                 dev_err(dev, "Failed to enable core supplies: %d\n", ret);
 553                 goto err_dcvdd;
 554         }
 555
 556         ret = regulator_enable(madera->dcvdd);
 557         if (ret) {
 558                 dev_err(dev, "Failed to enable DCVDD: %d\n", ret);
 559                 goto err_enable;
 560         }
 561
 562         madera_disable_hard_reset(madera);
 563
 564         regcache_cache_only(madera->regmap, false);
 565         regcache_cache_only(madera->regmap_32bit, false);
 566
 567         ret = madera_wait_for_boot_noack(madera);
 568         if (ret) {
 569                 dev_err(madera->dev, "Device failed initial boot: %d\n", ret);
 570                 goto err_reset;
 571         }
 572
 573         /*
 574          * Now we can power up and verify that this is a chip we know about
 575          * before we start doing any writes to its registers.
 576          */
 577         ret = regmap_read(madera->regmap, MADERA_SOFTWARE_RESET, &hwid);
 578         if (ret) {
 579                 dev_err(dev, "Failed to read ID register: %d\n", ret);
 580                 goto err_reset;
 581         }
 582
 583         switch (hwid) {
 584         case CS47L15_SILICON_ID:
 585                 if (IS_ENABLED(CONFIG_MFD_CS47L15)) {
 586                         switch (madera->type) {
 587                         case CS47L15:
 588                                 patch_fn = &cs47l15_patch;
 589                                 mfd_devs = cs47l15_devs;
 590                                 n_devs = ARRAY_SIZE(cs47l15_devs);
 591                                 break;
 592                         default:
 593                                 break;
 594                         }
 595                 }
 596                 break;
 597         case CS47L35_SILICON_ID:
 598                 if (IS_ENABLED(CONFIG_MFD_CS47L35)) {
 599                         switch (madera->type) {
 600                         case CS47L35:
 601                                 patch_fn = cs47l35_patch;
 602                                 mfd_devs = cs47l35_devs;
 603                                 n_devs = ARRAY_SIZE(cs47l35_devs);
 604                                 break;
 605                         default:
 606                                 break;
 607                         }
 608                 }
 609                 break;
 610         case CS47L85_SILICON_ID:
 611                 if (IS_ENABLED(CONFIG_MFD_CS47L85)) {
 612                         switch (madera->type) {
 613                         case CS47L85:
 614                         case WM1840:
 615                                 patch_fn = cs47l85_patch;
 616                                 mfd_devs = cs47l85_devs;
 617                                 n_devs = ARRAY_SIZE(cs47l85_devs);
 618                                 break;
 619                         default:
 620                                 break;
 621                         }
 622                 }
 623                 break;
 624         case CS47L90_SILICON_ID:
 625                 if (IS_ENABLED(CONFIG_MFD_CS47L90)) {
 626                         switch (madera->type) {
 627                         case CS47L90:
 628                         case CS47L91:
 629                                 patch_fn = cs47l90_patch;
 630                                 mfd_devs = cs47l90_devs;
 631                                 n_devs = ARRAY_SIZE(cs47l90_devs);
 632                                 break;
 633                         default:
 634                                 break;
 635                         }
 636                 }
 637                 break;
 638         case CS47L92_SILICON_ID:
 639                 if (IS_ENABLED(CONFIG_MFD_CS47L92)) {
 640                         switch (madera->type) {
 641                         case CS42L92:
 642                         case CS47L92:
 643                         case CS47L93:
 644                                 patch_fn = cs47l92_patch;
 645                                 mfd_devs = cs47l92_devs;
 646                                 n_devs = ARRAY_SIZE(cs47l92_devs);
 647                                 break;
 648                         default:
 649                                 break;
 650                         }
 651                 }
 652                 break;
 653         default:
 654                 dev_err(madera->dev, "Unknown device ID: %x\n", hwid);
 655                 ret = -EINVAL;
 656                 goto err_reset;
 657         }
 658
 659         if (!n_devs) {
 660                 dev_err(madera->dev, "Device ID 0x%x not a %s\n", hwid,
 661                         madera->type_name);
 662                 ret = -ENODEV;
 663                 goto err_reset;
 664         }
 665
 666         /*
 667          * It looks like a device we support. If we don't have a hard reset
 668          * we can now attempt a soft reset.
 669          */
 670         if (!madera->pdata.reset) {
 671                 ret = madera_soft_reset(madera);
 672                 if (ret)
 673                         goto err_reset;
 674         }
 675
 676         ret = madera_wait_for_boot(madera);
 677         if (ret) {
 678                 dev_err(madera->dev, "Failed to clear boot done: %d\n", ret);
 679                 goto err_reset;
 680         }
 681
 682         ret = regmap_read(madera->regmap, MADERA_HARDWARE_REVISION,
 683                           &madera->rev);
 684         if (ret) {
 685                 dev_err(dev, "Failed to read revision register: %d\n", ret);
 686                 goto err_reset;
 687         }
 688         madera->rev &= MADERA_HW_REVISION_MASK;
 689
 690         dev_info(dev, "%s silicon revision %d\n", madera->type_name,
 691                  madera->rev);
 692
 693         /* Apply hardware patch */
 694         if (patch_fn) {
 695                 ret = patch_fn(madera);
 696                 if (ret) {
 697                         dev_err(madera->dev, "Failed to apply patch %d\n", ret);
 698                         goto err_reset;
 699                 }
 700         }
 701
 702         /* Init 32k clock sourced from MCLK2 */
 703         ret = clk_prepare_enable(madera->mclk[MADERA_MCLK2].clk);
 704         if (ret) {
 705                 dev_err(madera->dev, "Failed to enable 32k clock: %d\n", ret);
 706                 goto err_reset;
 707         }
 708
 709         ret = regmap_update_bits(madera->regmap,
 710                         MADERA_CLOCK_32K_1,
 711                         MADERA_CLK_32K_ENA_MASK | MADERA_CLK_32K_SRC_MASK,
 712                         MADERA_CLK_32K_ENA | MADERA_32KZ_MCLK2);
 713         if (ret) {
 714                 dev_err(madera->dev, "Failed to init 32k clock: %d\n", ret);
 715                 goto err_clock;
 716         }
 717
 718         pm_runtime_set_active(madera->dev);
 719         pm_runtime_enable(madera->dev);
 720         pm_runtime_set_autosuspend_delay(madera->dev, 100);
 721         pm_runtime_use_autosuspend(madera->dev);
 722
 723         /* No devm_ because we need to control shutdown order of children */
 724         ret = mfd_add_devices(madera->dev, PLATFORM_DEVID_NONE,
 725                               mfd_devs, n_devs,
 726                               NULL, 0, NULL);
 727         if (ret) {
 728                 dev_err(madera->dev, "Failed to add subdevices: %d\n", ret);
 729                 goto err_pm_runtime;
 730         }
 731
 732         return 0;
 733
 734 err_pm_runtime:
 735         pm_runtime_disable(madera->dev);
 736 err_clock:
 737         clk_disable_unprepare(madera->mclk[MADERA_MCLK2].clk);
 738 err_reset:
 739         madera_enable_hard_reset(madera);
 740         regulator_disable(madera->dcvdd);
 741 err_enable:
 742         regulator_bulk_disable(madera->num_core_supplies,
 743                                madera->core_supplies);
 744 err_dcvdd:
 745         regulator_put(madera->dcvdd);
 746 err_devs:
 747         mfd_remove_devices(dev);
 748
 749         return ret;
 750 }
 751 EXPORT_SYMBOL_GPL(madera_dev_init);
 752
 753 int madera_dev_exit(struct madera *madera)
 754 {
 755         /* Prevent any IRQs being serviced while we clean up */
 756         disable_irq(madera->irq);
 757
 758         pm_runtime_get_sync(madera->dev);
 759
 760         mfd_remove_devices(madera->dev);
 761
 762         pm_runtime_disable(madera->dev);
 763
 764         regulator_disable(madera->dcvdd);
 765         regulator_put(madera->dcvdd);
 766
 767         mfd_remove_devices_late(madera->dev);
 768
 769         pm_runtime_set_suspended(madera->dev);
 770         pm_runtime_put_noidle(madera->dev);
 771
 772         clk_disable_unprepare(madera->mclk[MADERA_MCLK2].clk);
 773
 774         madera_enable_hard_reset(madera);
 775
 776         regulator_bulk_disable(madera->num_core_supplies,
 777                                madera->core_supplies);
 778         return 0;
 779 }
 780 EXPORT_SYMBOL_GPL(madera_dev_exit);
 781
 782 MODULE_DESCRIPTION("Madera core MFD driver");
 783 MODULE_AUTHOR("Richard Fitzgerald <rf@opensource.cirrus.com>");
 784 MODULE_LICENSE("GPL v2");