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