drivers/mfd/madera-core.c

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