drivers/mfd/madera-core.c

   1 /*
   2  * Core MFD support for Cirrus Logic Madera codecs
   3  *
   4  * Copyright 2015-2017 Cirrus Logic
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 as
   8  * published by the Free Software Foundation.
   9  */
  10
  11 #include <linux/device.h>
  12 #include <linux/delay.h>
  13 #include <linux/err.h>
  14 #include <linux/gpio.h>
  15 #include <linux/mfd/core.h>
  16 #include <linux/module.h>
  17 #include <linux/notifier.h>
  18 #include <linux/of.h>
  19 #include <linux/of_device.h>
  20 #include <linux/of_gpio.h>
  21 #include <linux/pinctrl/consumer.h>
  22 #include <linux/platform_device.h>
  23 #include <linux/pm_runtime.h>
  24 #include <linux/regmap.h>
  25 #include <linux/regulator/consumer.h>
  26 #include <linux/regulator/driver.h>
  27 #include <linux/regulator/machine.h>
  28 #include <linux/regulator/of_regulator.h>
  29
  30 #include <linux/mfd/madera/core.h>
  31 #include <linux/mfd/madera/registers.h>
  32
  33 #include "madera.h"
  34
  35 #define CS47L15_SILICON_ID      0x6370
  36 #define CS47L35_SILICON_ID      0x6360
  37 #define CS47L85_SILICON_ID      0x6338
  38 #define CS47L90_SILICON_ID      0x6364
  39 #define CS47L92_SILICON_ID      0x6371
  40
  41 #define MADERA_32KZ_MCLK2       1
  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         { .name = "madera-ldo1" },
  50 };
  51
  52 static const struct mfd_cell madera_pinctrl_dev[] = {
  53         {
  54                 .name = "madera-pinctrl",
  55                 .of_compatible = "cirrus,madera-pinctrl",
  56         },
  57 };
  58
  59 static const char * const cs47l15_supplies[] = {
  60         "MICVDD",
  61         "CPVDD1",
  62         "SPKVDD",
  63 };
  64
  65 static const struct mfd_cell cs47l15_devs[] = {
  66         { .name = "madera-irq" },
  67         { .name = "madera-gpio" },
  68         {
  69                 .name = "madera-extcon",
  70                 .parent_supplies = cs47l15_supplies,
  71                 .num_parent_supplies = 1, /* We only need MICVDD */
  72         },
  73         {
  74                 .name = "cs47l15-codec",
  75                 .parent_supplies = cs47l15_supplies,
  76                 .num_parent_supplies = ARRAY_SIZE(cs47l15_supplies),
  77         },
  78 };
  79
  80 static const char * const cs47l35_supplies[] = {
  81         "MICVDD",
  82         "DBVDD2",
  83         "CPVDD1",
  84         "CPVDD2",
  85         "SPKVDD",
  86 };
  87
  88 static const struct mfd_cell cs47l35_devs[] = {
  89         { .name = "madera-irq", },
  90         { .name = "madera-micsupp" },
  91         { .name = "madera-gpio", },
  92         {
  93                 .name = "madera-extcon",
  94                 .parent_supplies = cs47l35_supplies,
  95                 .num_parent_supplies = 1, /* We only need MICVDD */
  96         },
  97         {
  98                 .name = "cs47l35-codec",
  99                 .parent_supplies = cs47l35_supplies,
 100                 .num_parent_supplies = ARRAY_SIZE(cs47l35_supplies),
 101         },
 102 };
 103
 104 static const char * const cs47l85_supplies[] = {
 105         "MICVDD",
 106         "DBVDD2",
 107         "DBVDD3",
 108         "DBVDD4",
 109         "CPVDD1",
 110         "CPVDD2",
 111         "SPKVDDL",
 112         "SPKVDDR",
 113 };
 114
 115 static const struct mfd_cell cs47l85_devs[] = {
 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-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-irq", },
 164         { .name = "madera-micsupp", },
 165         { .name = "madera-gpio" },
 166         {
 167                 .name = "madera-extcon",
 168                 .parent_supplies = cs47l92_supplies,
 169                 .num_parent_supplies = 1, /* We only need MICVDD */
 170         },
 171         {
 172                 .name = "cs47l92-codec",
 173                 .parent_supplies = cs47l92_supplies,
 174                 .num_parent_supplies = ARRAY_SIZE(cs47l92_supplies),
 175         },
 176 };
 177
 178
 179 const char *madera_name_from_type(enum madera_type type)
 180 {
 181         switch (type) {
 182         case CS47L15:
 183                 return "CS47L15";
 184         case CS47L35:
 185                 return "CS47L35";
 186         case CS47L85:
 187                 return "CS47L85";
 188         case CS47L90:
 189                 return "CS47L90";
 190         case CS47L91:
 191                 return "CS47L91";
 192         case CS47L92:
 193                 return "CS47L92";
 194         case CS47L93:
 195                 return "CS47L93";
 196         case WM1840:
 197                 return "WM1840";
 198         default:
 199                 return "Unknown";
 200         }
 201 }
 202 EXPORT_SYMBOL_GPL(madera_name_from_type);
 203
 204 #define MADERA_BOOT_POLL_MAX_INTERVAL_US  5000
 205 #define MADERA_BOOT_POLL_TIMEOUT_US      25000
 206
 207 static int madera_wait_for_boot(struct madera *madera)
 208 {
 209         unsigned int val;
 210         int ret;
 211
 212         /*
 213          * We can't use an interrupt as we need to runtime resume to do so,
 214          * so we poll the status bit. This won't race with the interrupt
 215          * handler because it will be blocked on runtime resume.
 216          */
 217         ret = regmap_read_poll_timeout(madera->regmap,
 218                                        MADERA_IRQ1_RAW_STATUS_1,
 219                                        val,
 220                                        (val & MADERA_BOOT_DONE_STS1),
 221                                        MADERA_BOOT_POLL_MAX_INTERVAL_US,
 222                                        MADERA_BOOT_POLL_TIMEOUT_US);
 223
 224         if (ret)
 225                 dev_err(madera->dev, "Polling BOOT_DONE_STS failed: %d\n", ret);
 226
 227         /*
 228          * BOOT_DONE defaults to unmasked on boot so we must ack it.
 229          * Do this unconditionally to avoid interrupt storms
 230          */
 231         regmap_write(madera->regmap, MADERA_IRQ1_STATUS_1,
 232                      MADERA_BOOT_DONE_EINT1);
 233
 234         if (ret)
 235                 dev_err(madera->dev, "Polling BOOT_DONE_STS failed: %d\n", ret);
 236
 237         pm_runtime_mark_last_busy(madera->dev);
 238
 239         return ret;
 240 }
 241
 242 static int madera_soft_reset(struct madera *madera)
 243 {
 244         int ret;
 245
 246         ret = regmap_write(madera->regmap, MADERA_SOFTWARE_RESET, 0);
 247         if (ret != 0) {
 248                 dev_err(madera->dev, "Failed to soft reset device: %d\n", ret);
 249                 return ret;
 250         }
 251
 252         /* Allow time for internal clocks to startup after reset */
 253         usleep_range(1000, 2000);
 254
 255         return 0;
 256 }
 257
 258 static void madera_enable_hard_reset(struct madera *madera)
 259 {
 260         if (madera->reset_gpio)
 261                 gpiod_set_value_cansleep(madera->reset_gpio, 0);
 262 }
 263
 264 static void madera_disable_hard_reset(struct madera *madera)
 265 {
 266         if (madera->reset_gpio) {
 267                 gpiod_set_value_cansleep(madera->reset_gpio, 1);
 268                 usleep_range(1000, 2000);
 269         }
 270 }
 271
 272 #ifdef CONFIG_PM
 273 static int madera_runtime_resume(struct device *dev)
 274 {
 275         struct madera *madera = dev_get_drvdata(dev);
 276         int ret;
 277
 278         dev_err(dev, "Leaving sleep mode\n");
 279
 280         madera_enable_hard_reset(madera);
 281
 282         ret = regulator_enable(madera->dcvdd);
 283         if (ret) {
 284                 dev_err(dev, "Failed to enable DCVDD: %d\n", ret);
 285                 return ret;
 286         }
 287
 288         if (IS_ENABLED(CONFIG_REGULATOR_S2MPU09))
 289                 msleep(10);
 290
 291         regcache_cache_only(madera->regmap, false);
 292         regcache_cache_only(madera->regmap_32bit, false);
 293
 294         madera_disable_hard_reset(madera);
 295
 296         if (!madera->reset_gpio) {
 297                 ret = madera_wait_for_boot(madera);
 298                 if (ret)
 299                         goto err;
 300
 301                 ret = madera_soft_reset(madera);
 302                 if (ret) {
 303                         dev_err(dev, "Failed to reset: %d\n", ret);
 304                         goto err;
 305                 }
 306         }
 307
 308         ret = madera_wait_for_boot(madera);
 309         if (ret)
 310                 goto err;
 311
 312         ret = regcache_sync(madera->regmap);
 313         if (ret) {
 314                 dev_err(dev, "Failed to restore 16-bit register cache\n");
 315                 goto err;
 316         }
 317
 318         ret = regcache_sync(madera->regmap_32bit);
 319         if (ret) {
 320                 dev_err(dev, "Failed to restore 32-bit register cache\n");
 321                 goto err;
 322         }
 323
 324         return 0;
 325
 326 err:
 327         regcache_cache_only(madera->regmap_32bit, true);
 328         regcache_cache_only(madera->regmap, true);
 329         regulator_disable(madera->dcvdd);
 330
 331         return ret;
 332 }
 333
 334 static int madera_runtime_suspend(struct device *dev)
 335 {
 336         struct madera *madera = dev_get_drvdata(dev);
 337
 338         dev_dbg(madera->dev, "Entering sleep mode\n");
 339
 340         regcache_cache_only(madera->regmap, true);
 341         regcache_mark_dirty(madera->regmap);
 342         regcache_cache_only(madera->regmap_32bit, true);
 343         regcache_mark_dirty(madera->regmap_32bit);
 344
 345         regulator_disable(madera->dcvdd);
 346
 347         return 0;
 348 }
 349 #endif
 350
 351 const struct dev_pm_ops madera_pm_ops = {
 352         SET_RUNTIME_PM_OPS(madera_runtime_suspend,
 353                            madera_runtime_resume,
 354                            NULL)
 355 };
 356 EXPORT_SYMBOL_GPL(madera_pm_ops);
 357
 358 unsigned int madera_get_num_micbias(struct madera *madera)
 359 {
 360
 361         switch (madera->type) {
 362         case CS47L15:
 363                 return 1;
 364         case CS47L35:
 365                 return 2;
 366         case CS47L85:
 367         case WM1840:
 368                 return 4;
 369         case CS47L90:
 370         case CS47L91:
 371         case CS47L92:
 372         case CS47L93:
 373                 return 2;
 374         default:
 375                 dev_warn(madera->dev, "No micbias known for codec %s\n",
 376                          madera_name_from_type(madera->type));
 377                 return 0;
 378         }
 379 }
 380 EXPORT_SYMBOL_GPL(madera_get_num_micbias);
 381
 382 unsigned int madera_get_num_childbias(struct madera *madera,
 383                                       unsigned int micbias)
 384 {
 385         /*
 386          * micbias argument reserved for future codecs that don't
 387          * have the same number of children on each micbias
 388          */
 389
 390         switch (madera->type) {
 391         case CS47L15:
 392                 return 3;
 393         case CS47L35:
 394                 return 2;
 395         case CS47L85:
 396         case WM1840:
 397                 return 0;
 398         case CS47L90:
 399         case CS47L91:
 400                 return 4;
 401         case CS47L92:
 402         case CS47L93:
 403                 switch (micbias) {
 404                 case 1:
 405                         return 4;
 406                 case 2:
 407                         return 2;
 408                 default:
 409                         dev_warn(madera->dev,
 410                                  "No child micbias for codec %s, micbias %u\n",
 411                                  madera_name_from_type(madera->type),
 412                                  micbias);
 413                         return 0;
 414                 }
 415         default:
 416                 dev_warn(madera->dev, "No child micbias known for codec %s\n",
 417                          madera_name_from_type(madera->type));
 418                 return 0;
 419         }
 420 }
 421 EXPORT_SYMBOL_GPL(madera_get_num_childbias);
 422
 423 #ifdef CONFIG_OF
 424 const struct of_device_id madera_of_match[] = {
 425         { .compatible = "cirrus,cs47l15", .data = (void *)CS47L15 },
 426         { .compatible = "cirrus,cs47l35", .data = (void *)CS47L35 },
 427         { .compatible = "cirrus,cs47l85", .data = (void *)CS47L85 },
 428         { .compatible = "cirrus,cs47l90", .data = (void *)CS47L90 },
 429         { .compatible = "cirrus,cs47l91", .data = (void *)CS47L91 },
 430         { .compatible = "cirrus,cs47l92", .data = (void *)CS47L92 },
 431         { .compatible = "cirrus,cs47l93", .data = (void *)CS47L93 },
 432         { .compatible = "cirrus,wm1840", .data = (void *)WM1840 },
 433         {},
 434 };
 435 EXPORT_SYMBOL_GPL(madera_of_match);
 436
 437 unsigned long madera_get_type_from_of(struct device *dev)
 438 {
 439         const struct of_device_id *id = of_match_device(madera_of_match, dev);
 440
 441         if (id)
 442                 return (unsigned long)id->data;
 443         else
 444                 return 0;
 445 }
 446 EXPORT_SYMBOL_GPL(madera_get_type_from_of);
 447 #endif
 448
 449 static int madera_get_reset_gpio(struct madera *madera)
 450 {
 451         int ret;
 452
 453         /* We use 0 in pdata to indicate a GPIO has not been set */
 454         if (dev_get_platdata(madera->dev) && (madera->pdata.reset > 0)) {
 455                 /* Start out with /RESET asserted */
 456                 ret = devm_gpio_request_one(madera->dev,
 457                                             madera->pdata.reset,
 458                                             GPIOF_DIR_OUT | GPIOF_INIT_LOW,
 459                                             "madera reset");
 460                 if (!ret)
 461                         madera->reset_gpio = gpio_to_desc(madera->pdata.reset);
 462         } else {
 463                 madera->reset_gpio = devm_gpiod_get_optional(madera->dev,
 464                                                              "reset",
 465                                                              GPIOD_OUT_LOW);
 466                 if (IS_ERR(madera->reset_gpio))
 467                         ret = PTR_ERR(madera->reset_gpio);
 468                 else
 469                         ret = 0;
 470         }
 471
 472         /* Ensure period of reset asserted before we apply the supplies */
 473         msleep(20);
 474
 475         if (ret == -EPROBE_DEFER)
 476                 return ret;
 477
 478         if (ret) {
 479                 dev_err(madera->dev, "Failed to request /RESET: %d\n", ret);
 480                 return ret;
 481         }
 482
 483         if (!madera->reset_gpio)
 484                 dev_warn(madera->dev,
 485                          "Running without reset GPIO is not recommended\n");
 486
 487         return 0;
 488 }
 489
 490 static void madera_prop_get_micbias_child(struct madera *madera,
 491                                          const char *name,
 492                                          struct madera_micbias_pin_pdata *pdata)
 493 {
 494         struct device_node *np;
 495         struct regulator_desc desc = { };
 496
 497         np = of_get_child_by_name(madera->dev->of_node, name);
 498         if (!np)
 499                 return;
 500
 501         desc.name = name;
 502         pdata->init_data = of_get_regulator_init_data(madera->dev, np, &desc);
 503         of_property_read_u32(np, "regulator-active-discharge",
 504                              &pdata->active_discharge);
 505 }
 506
 507 static void madera_prop_get_micbias_gen(struct madera *madera,
 508                                        const char *name,
 509                                        struct madera_micbias_pdata *pdata)
 510 {
 511         struct device_node *np;
 512         struct regulator_desc desc = { };
 513
 514         np = of_get_child_by_name(madera->dev->of_node, name);
 515         if (!np)
 516                 return;
 517
 518         desc.name = name;
 519         pdata->init_data = of_get_regulator_init_data(madera->dev, np, &desc);
 520         pdata->ext_cap = of_property_read_bool(np, "cirrus,ext-cap");
 521         of_property_read_u32(np, "regulator-active-discharge",
 522                              &pdata->active_discharge);
 523 }
 524
 525 static void madera_prop_get_micbias(struct madera *madera)
 526 {
 527         struct madera_micbias_pdata *pdata;
 528         char name[10];
 529         int i, child;
 530
 531         for (i = madera_get_num_micbias(madera) - 1; i >= 0; --i) {
 532                 pdata = &madera->pdata.micbias[i];
 533
 534                 snprintf(name, sizeof(name), "MICBIAS%d", i + 1);
 535                 madera_prop_get_micbias_gen(madera, name, pdata);
 536
 537                 child = madera_get_num_childbias(madera, i + 1) - 1;
 538                 for (; child >= 0; --child) {
 539                         snprintf(name, sizeof(name), "MICBIAS%d%c",
 540                                  i + 1, 'A' + child);
 541                         madera_prop_get_micbias_child(madera, name,
 542                                                      &pdata->pin[child]);
 543                 }
 544         }
 545 }
 546
 547 static void madera_configure_micbias(struct madera *madera)
 548 {
 549         unsigned int num_micbias = madera_get_num_micbias(madera);
 550         struct madera_micbias_pdata *pdata;
 551         struct regulator_init_data *init_data;
 552         unsigned int num_child_micbias;
 553         unsigned int val, mask, reg;
 554         int i, child, ret;
 555
 556         for (i = 0; i < num_micbias; ++i) {
 557                 pdata = &madera->pdata.micbias[i];
 558
 559                 /* Configure the child micbias pins */
 560                 val = 0;
 561                 mask = 0;
 562                 num_child_micbias = madera_get_num_childbias(madera, i + 1);
 563                 for (child = 0; child < num_child_micbias; ++child) {
 564                         if (!pdata->pin[child].init_data)
 565                                 continue;
 566
 567                         mask |= MADERA_MICB1A_DISCH << (child * 4);
 568                         if (pdata->pin[child].active_discharge)
 569                                 val |= MADERA_MICB1A_DISCH << (child * 4);
 570                 }
 571
 572                 if (mask) {
 573                         reg = MADERA_MIC_BIAS_CTRL_5 + (i * 2);
 574                         ret = regmap_update_bits(madera->regmap, reg, mask, val);
 575                         if (ret)
 576                                 dev_warn(madera->dev,
 577                                          "Failed to write 0x%x (%d)\n",
 578                                          reg, ret);
 579
 580                         dev_dbg(madera->dev,
 581                                 "Set MICBIAS_CTRL%d mask=0x%x val=0x%x\n",
 582                                 i + 5, mask, val);
 583                 }
 584
 585                 /* configure the parent */
 586                 init_data = pdata->init_data;
 587                 if (!init_data)
 588                         continue;
 589
 590                 mask = MADERA_MICB1_LVL_MASK | MADERA_MICB1_EXT_CAP |
 591                         MADERA_MICB1_BYPASS | MADERA_MICB1_RATE;
 592
 593                 if (!init_data->constraints.max_uV)
 594                         init_data->constraints.max_uV = 2800000;
 595
 596                 val = (init_data->constraints.max_uV - 1500000) / 100000;
 597                 val <<= MADERA_MICB1_LVL_SHIFT;
 598
 599                 if (pdata->ext_cap)
 600                         val |= MADERA_MICB1_EXT_CAP;
 601
 602                 /* if no child biases the discharge is set in the parent */
 603                 if (num_child_micbias == 0) {
 604                         mask |= MADERA_MICB1_DISCH;
 605
 606                         if (pdata->active_discharge)
 607                                 val |= MADERA_MICB1_DISCH;
 608                 }
 609
 610                 if (init_data->constraints.soft_start)
 611                         val |= MADERA_MICB1_RATE;
 612
 613                 if (init_data->constraints.valid_ops_mask &
 614                     REGULATOR_CHANGE_BYPASS)
 615                         val |= MADERA_MICB1_BYPASS;
 616
 617                 reg = MADERA_MIC_BIAS_CTRL_1 + i;
 618                 ret = regmap_update_bits(madera->regmap, reg, mask, val);
 619                 if (ret)
 620                         dev_warn(madera->dev, "Failed to write 0x%x (%d)\n",
 621                                  reg, ret);
 622
 623                 dev_dbg(madera->dev, "Set MICBIAS_CTRL%d mask=0x%x val=0x%x\n",
 624                         i + 1, mask, val);
 625         }
 626 }
 627
 628 static int madera_dev_select_pinctrl(struct madera *madera,
 629                                      struct pinctrl *pinctrl,
 630                                      const char *name)
 631 {
 632         struct pinctrl_state *pinctrl_state;
 633         int ret;
 634
 635         pinctrl_state = pinctrl_lookup_state(pinctrl, name);
 636
 637         /* it's ok if it doesn't exist */
 638         if (!IS_ERR(pinctrl_state)) {
 639                 dev_dbg(madera->dev, "Applying pinctrl %s state\n", name);
 640                 ret = pinctrl_select_state(pinctrl, pinctrl_state);
 641                 if (ret) {
 642                         dev_err(madera->dev,
 643                                 "Failed to select pinctrl %s state: %d\n",
 644                                 name, ret);
 645                         return ret;
 646                 }
 647         }
 648
 649         return 0;
 650 }
 651
 652 int madera_dev_init(struct madera *madera)
 653 {
 654         struct device *dev = madera->dev;
 655         const char *name;
 656         unsigned int hwid;
 657         int (*patch_fn)(struct madera *) = NULL;
 658         const struct mfd_cell *mfd_devs;
 659         struct pinctrl *pinctrl;
 660         int n_devs = 0;
 661         int i, ret;
 662
 663         dev_set_drvdata(madera->dev, madera);
 664
 665         /*
 666          * Pinctrl subsystem only configures pinctrls if all referenced pins
 667          * are registered. Create our pinctrl child now so that its pins exist
 668          * otherwise external pinctrl dependencies will fail
 669          * Note: Can't devm_ because it is cleaned up after children are already
 670          * destroyed
 671          */
 672         ret = mfd_add_devices(madera->dev, PLATFORM_DEVID_NONE,
 673                               madera_pinctrl_dev, 1, NULL, 0, NULL);
 674         if (ret) {
 675                 dev_err(madera->dev, "Failed to add pinctrl child: %d\n", ret);
 676                 return ret;
 677         }
 678
 679         pinctrl = pinctrl_get(dev);
 680         if (IS_ERR(pinctrl)) {
 681                 ret = PTR_ERR(pinctrl);
 682                 dev_err(madera->dev, "Failed to get pinctrl: %d\n", ret);
 683                 goto err_devs;
 684         }
 685
 686         /* Use (optional) minimal config with only external pin bindings */
 687         ret = madera_dev_select_pinctrl(madera, pinctrl, "probe");
 688         if (ret)
 689                 goto err_pinctrl;
 690
 691         mutex_init(&madera->reg_setting_lock);
 692
 693         BLOCKING_INIT_NOTIFIER_HEAD(&madera->notifier);
 694
 695         if (dev_get_platdata(madera->dev)) {
 696                 memcpy(&madera->pdata, dev_get_platdata(madera->dev),
 697                        sizeof(madera->pdata));
 698         }
 699
 700         ret = madera_get_reset_gpio(madera);
 701         if (ret)
 702                 goto err_pinctrl;
 703
 704         madera_prop_get_micbias(madera);
 705
 706         regcache_cache_only(madera->regmap, true);
 707         regcache_cache_only(madera->regmap_32bit, true);
 708
 709         for (i = 0; i < ARRAY_SIZE(madera_core_supplies); i++)
 710                 madera->core_supplies[i].supply = madera_core_supplies[i];
 711
 712         madera->num_core_supplies = ARRAY_SIZE(madera_core_supplies);
 713
 714         switch (madera->type) {
 715         case CS47L15:
 716         case CS47L35:
 717         case CS47L90:
 718         case CS47L91:
 719         case CS47L92:
 720         case CS47L93:
 721                 break;
 722         case CS47L85:
 723         case WM1840:
 724                 /* On these DCVDD could be supplied from the onboard LDO1 */
 725                 ret = mfd_add_devices(madera->dev, PLATFORM_DEVID_NONE,
 726                                       madera_ldo1_devs,
 727                                       ARRAY_SIZE(madera_ldo1_devs),
 728                                       NULL, 0, NULL);
 729                 if (ret) {
 730                         dev_err(dev, "Failed to add LDO1 child: %d\n", ret);
 731                         goto err_pinctrl;
 732                 }
 733                 break;
 734         default:
 735                 dev_err(madera->dev, "Unknown device type %d\n", madera->type);
 736                 ret = -ENODEV;
 737                 goto err_pinctrl;
 738         }
 739
 740         ret = devm_regulator_bulk_get(dev, madera->num_core_supplies,
 741                                       madera->core_supplies);
 742         if (ret) {
 743                 dev_err(dev, "Failed to request core supplies: %d\n", ret);
 744                 goto err_pinctrl;
 745         }
 746
 747         /*
 748          * Don't use devres here because the only device we have to get
 749          * against is the MFD device and DCVDD will likely be supplied by
 750          * one of its children. Meaning that the regulator will be
 751          * destroyed by the time devres calls regulator put.
 752          */
 753         madera->dcvdd = regulator_get(madera->dev, "DCVDD");
 754         if (IS_ERR(madera->dcvdd)) {
 755                 ret = PTR_ERR(madera->dcvdd);
 756                 dev_err(dev, "Failed to request DCVDD: %d\n", ret);
 757                 goto err_pinctrl;
 758         }
 759
 760         ret = regulator_bulk_enable(madera->num_core_supplies,
 761                                     madera->core_supplies);
 762         if (ret) {
 763                 dev_err(dev, "Failed to enable core supplies: %d\n", ret);
 764                 goto err_dcvdd;
 765         }
 766
 767         ret = regulator_enable(madera->dcvdd);
 768         if (ret) {
 769                 dev_err(dev, "Failed to enable DCVDD: %d\n", ret);
 770                 goto err_enable;
 771         }
 772
 773         if (IS_ENABLED(CONFIG_REGULATOR_S2MPU09))
 774                 msleep(10);
 775
 776         madera_disable_hard_reset(madera);
 777
 778         regcache_cache_only(madera->regmap, false);
 779         regcache_cache_only(madera->regmap_32bit, false);
 780
 781         /*
 782          * Verify that this is a chip we know about before we
 783          * starting doing any writes to its registers
 784          */
 785         ret = regmap_read(madera->regmap, MADERA_SOFTWARE_RESET, &hwid);
 786         if (ret) {
 787                 dev_err(dev, "Failed to read ID register: %d\n", ret);
 788                 goto err_reset;
 789         }
 790
 791         switch (hwid) {
 792         case CS47L15_SILICON_ID:
 793         case CS47L35_SILICON_ID:
 794         case CS47L85_SILICON_ID:
 795         case CS47L90_SILICON_ID:
 796         case CS47L92_SILICON_ID:
 797                 break;
 798         default:
 799                 dev_err(madera->dev, "Unknown device ID: %x\n", hwid);
 800                 ret = -EINVAL;
 801                 goto err_reset;
 802         }
 803
 804         /* If we don't have a reset GPIO use a soft reset */
 805         if (!madera->reset_gpio) {
 806                 ret = madera_soft_reset(madera);
 807                 if (ret)
 808                         goto err_reset;
 809         }
 810
 811         ret = madera_wait_for_boot(madera);
 812         if (ret) {
 813                 dev_err(madera->dev, "Device failed initial boot: %d\n", ret);
 814                 goto err_reset;
 815         }
 816
 817         ret = regmap_read(madera->regmap, MADERA_HARDWARE_REVISION,
 818                           &madera->rev);
 819         if (ret) {
 820                 dev_err(dev, "Failed to read revision register: %d\n", ret);
 821                 goto err_reset;
 822         }
 823         madera->rev &= MADERA_HW_REVISION_MASK;
 824
 825         name = madera_name_from_type(madera->type);
 826
 827         switch (hwid) {
 828         case CS47L15_SILICON_ID:
 829                 if (IS_ENABLED(CONFIG_MFD_CS47L15)) {
 830                         switch (madera->type) {
 831                         case CS47L15:
 832                                 patch_fn = cs47l15_patch;
 833                                 mfd_devs = cs47l15_devs;
 834                                 n_devs = ARRAY_SIZE(cs47l15_devs);
 835                                 break;
 836                         default:
 837                                 break;
 838                         }
 839                 }
 840                 break;
 841         case CS47L35_SILICON_ID:
 842                 if (IS_ENABLED(CONFIG_MFD_CS47L35)) {
 843                         switch (madera->type) {
 844                         case CS47L35:
 845                                 patch_fn = cs47l35_patch;
 846                                 mfd_devs = cs47l35_devs;
 847                                 n_devs = ARRAY_SIZE(cs47l35_devs);
 848                                 break;
 849                         default:
 850                                 break;
 851                         }
 852                 }
 853                 break;
 854         case CS47L85_SILICON_ID:
 855                 if (IS_ENABLED(CONFIG_MFD_CS47L85)) {
 856                         switch (madera->type) {
 857                         case CS47L85:
 858                         case WM1840:
 859                                 patch_fn = cs47l85_patch;
 860                                 mfd_devs = cs47l85_devs;
 861                                 n_devs = ARRAY_SIZE(cs47l85_devs);
 862                                 break;
 863                         default:
 864                                 break;
 865                         }
 866                 }
 867                 break;
 868         case CS47L90_SILICON_ID:
 869                 if (IS_ENABLED(CONFIG_MFD_CS47L90)) {
 870                         switch (madera->type) {
 871                         case CS47L90:
 872                         case CS47L91:
 873                                 patch_fn = cs47l90_patch;
 874                                 mfd_devs = cs47l90_devs;
 875                                 n_devs = ARRAY_SIZE(cs47l90_devs);
 876                                 break;
 877                         default:
 878                                 break;
 879                         }
 880                 }
 881                 break;
 882         case CS47L92_SILICON_ID:
 883                 if (IS_ENABLED(CONFIG_MFD_CS47L92)) {
 884                         switch (madera->type) {
 885                         case CS47L92:
 886                         case CS47L93:
 887                                 patch_fn = cs47l92_patch;
 888                                 mfd_devs = cs47l92_devs;
 889                                 n_devs = ARRAY_SIZE(cs47l92_devs);
 890                                 break;
 891                         default:
 892                                 break;
 893                         }
 894                 }
 895                 break;
 896         default:
 897                 break;
 898         }
 899
 900         if (!n_devs) {
 901                 dev_err(madera->dev, "Device ID 0x%x not a %s\n", hwid, name);
 902                 ret = -ENODEV;
 903                 goto err_reset;
 904         }
 905
 906         dev_info(dev, "%s silicon revision %d\n", name, madera->rev);
 907
 908         /* Apply hardware patch */
 909         if (patch_fn) {
 910                 ret = patch_fn(madera);
 911                 if (ret) {
 912                         dev_err(madera->dev, "Failed to apply patch %d\n", ret);
 913                         goto err_reset;
 914                 }
 915         }
 916
 917         /* Apply (optional) main pinctrl config, this will configure our pins */
 918         ret = madera_dev_select_pinctrl(madera, pinctrl, "active");
 919         if (ret)
 920                 goto err_reset;
 921
 922         /* Init 32k clock sourced from MCLK2 */
 923         ret = regmap_update_bits(madera->regmap,
 924                         MADERA_CLOCK_32K_1,
 925                         MADERA_CLK_32K_ENA_MASK | MADERA_CLK_32K_SRC_MASK,
 926                         MADERA_CLK_32K_ENA | MADERA_32KZ_MCLK2);
 927         if (ret) {
 928                 dev_err(madera->dev, "Failed to init 32k clock: %d\n", ret);
 929                 goto err_reset;
 930         }
 931
 932         madera_configure_micbias(madera);
 933
 934         pm_runtime_set_active(madera->dev);
 935         pm_runtime_enable(madera->dev);
 936         pm_runtime_set_autosuspend_delay(madera->dev, 100);
 937         pm_runtime_use_autosuspend(madera->dev);
 938
 939         ret = mfd_add_devices(madera->dev, PLATFORM_DEVID_NONE,
 940                               mfd_devs, n_devs,
 941                               NULL, 0, NULL);
 942         if (ret) {
 943                 dev_err(madera->dev, "Failed to add subdevices: %d\n", ret);
 944                 goto err_pm_runtime;
 945         }
 946
 947         pinctrl_put(pinctrl);
 948
 949         return 0;
 950
 951 err_pm_runtime:
 952         pm_runtime_disable(madera->dev);
 953 err_reset:
 954         madera_enable_hard_reset(madera);
 955         regulator_disable(madera->dcvdd);
 956 err_enable:
 957         regulator_bulk_disable(madera->num_core_supplies,
 958                                madera->core_supplies);
 959 err_dcvdd:
 960         regulator_put(madera->dcvdd);
 961 err_pinctrl:
 962         pinctrl_put(pinctrl);
 963 err_devs:
 964         mfd_remove_devices(dev);
 965
 966         return ret;
 967 }
 968 EXPORT_SYMBOL_GPL(madera_dev_init);
 969
 970 int madera_dev_exit(struct madera *madera)
 971 {
 972         /* Prevent any IRQs being serviced while we clean up */
 973         disable_irq(madera->irq);
 974
 975         /*
 976          * DCVDD could be supplied by a child node, we must disable it before
 977          * removing the children, and prevent PM runtime from turning it back on
 978          */
 979         pm_runtime_disable(madera->dev);
 980
 981         regulator_disable(madera->dcvdd);
 982         regulator_put(madera->dcvdd);
 983
 984         mfd_remove_devices(madera->dev);
 985         madera_enable_hard_reset(madera);
 986
 987         regulator_bulk_disable(madera->num_core_supplies,
 988                                madera->core_supplies);
 989         return 0;
 990 }
 991 EXPORT_SYMBOL_GPL(madera_dev_exit);