1 // SPDX-License-Identifier: GPL-2.0-only
3 * Core MFD support for Cirrus Logic Madera codecs
5 * Copyright (C) 2015-2018 Cirrus Logic
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>
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>
25 #include <linux/mfd/madera/core.h>
26 #include <linux/mfd/madera/registers.h>
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
36 #define MADERA_32KZ_MCLK2 1
38 static const char * const madera_core_supplies[] = {
43 static const struct mfd_cell madera_ldo1_devs[] = {
44 { .name = "madera-ldo1" },
47 static const char * const cs47l15_supplies[] = {
53 static const struct mfd_cell cs47l15_devs[] = {
54 { .name = "madera-pinctrl", },
55 { .name = "madera-irq" },
56 { .name = "madera-gpio" },
58 .name = "madera-extcon",
59 .parent_supplies = cs47l15_supplies,
60 .num_parent_supplies = 1, /* We only need MICVDD */
63 .name = "cs47l15-codec",
64 .parent_supplies = cs47l15_supplies,
65 .num_parent_supplies = ARRAY_SIZE(cs47l15_supplies),
69 static const char * const cs47l35_supplies[] = {
77 static const struct mfd_cell cs47l35_devs[] = {
78 { .name = "madera-pinctrl", },
79 { .name = "madera-irq", },
80 { .name = "madera-micsupp", },
81 { .name = "madera-gpio", },
83 .name = "madera-extcon",
84 .parent_supplies = cs47l35_supplies,
85 .num_parent_supplies = 1, /* We only need MICVDD */
88 .name = "cs47l35-codec",
89 .parent_supplies = cs47l35_supplies,
90 .num_parent_supplies = ARRAY_SIZE(cs47l35_supplies),
94 static const char * const cs47l85_supplies[] = {
105 static const struct mfd_cell cs47l85_devs[] = {
106 { .name = "madera-pinctrl", },
107 { .name = "madera-irq", },
108 { .name = "madera-micsupp" },
109 { .name = "madera-gpio", },
111 .name = "madera-extcon",
112 .parent_supplies = cs47l85_supplies,
113 .num_parent_supplies = 1, /* We only need MICVDD */
116 .name = "cs47l85-codec",
117 .parent_supplies = cs47l85_supplies,
118 .num_parent_supplies = ARRAY_SIZE(cs47l85_supplies),
122 static const char * const cs47l90_supplies[] = {
131 static const struct mfd_cell cs47l90_devs[] = {
132 { .name = "madera-pinctrl", },
133 { .name = "madera-irq", },
134 { .name = "madera-micsupp", },
135 { .name = "madera-gpio", },
137 .name = "madera-extcon",
138 .parent_supplies = cs47l90_supplies,
139 .num_parent_supplies = 1, /* We only need MICVDD */
142 .name = "cs47l90-codec",
143 .parent_supplies = cs47l90_supplies,
144 .num_parent_supplies = ARRAY_SIZE(cs47l90_supplies),
148 static const char * const cs47l92_supplies[] = {
154 static const struct mfd_cell cs47l92_devs[] = {
155 { .name = "madera-pinctrl" },
156 { .name = "madera-irq", },
157 { .name = "madera-micsupp", },
158 { .name = "madera-gpio" },
160 .name = "madera-extcon",
161 .parent_supplies = cs47l92_supplies,
162 .num_parent_supplies = 1, /* We only need MICVDD */
165 .name = "cs47l92-codec",
166 .parent_supplies = cs47l92_supplies,
167 .num_parent_supplies = ARRAY_SIZE(cs47l92_supplies),
171 /* Used by madera-i2c and madera-spi drivers */
172 const char *madera_name_from_type(enum madera_type type)
197 EXPORT_SYMBOL_GPL(madera_name_from_type);
199 #define MADERA_BOOT_POLL_INTERVAL_USEC 5000
200 #define MADERA_BOOT_POLL_TIMEOUT_USEC 25000
202 static int madera_wait_for_boot(struct madera *madera)
205 unsigned int val = 0;
209 * We can't use an interrupt as we need to runtime resume to do so,
210 * so we poll the status bit. This won't race with the interrupt
211 * handler because it will be blocked on runtime resume.
212 * The chip could NAK a read request while it is booting so ignore
213 * errors from regmap_read.
215 timeout = ktime_add_us(ktime_get(), MADERA_BOOT_POLL_TIMEOUT_USEC);
216 regmap_read(madera->regmap, MADERA_IRQ1_RAW_STATUS_1, &val);
217 while (!(val & MADERA_BOOT_DONE_STS1) &&
218 !ktime_after(ktime_get(), timeout)) {
219 usleep_range(MADERA_BOOT_POLL_INTERVAL_USEC / 2,
220 MADERA_BOOT_POLL_INTERVAL_USEC);
221 regmap_read(madera->regmap, MADERA_IRQ1_RAW_STATUS_1, &val);
224 if (!(val & MADERA_BOOT_DONE_STS1)) {
225 dev_err(madera->dev, "Polling BOOT_DONE_STS timed out\n");
230 * BOOT_DONE defaults to unmasked on boot so we must ack it.
231 * Do this even after a timeout to avoid interrupt storms.
233 regmap_write(madera->regmap, MADERA_IRQ1_STATUS_1,
234 MADERA_BOOT_DONE_EINT1);
236 pm_runtime_mark_last_busy(madera->dev);
241 static int madera_soft_reset(struct madera *madera)
245 ret = regmap_write(madera->regmap, MADERA_SOFTWARE_RESET, 0);
247 dev_err(madera->dev, "Failed to soft reset device: %d\n", ret);
251 /* Allow time for internal clocks to startup after reset */
252 usleep_range(1000, 2000);
257 static void madera_enable_hard_reset(struct madera *madera)
259 if (!madera->pdata.reset)
263 * There are many existing out-of-tree users of these codecs that we
264 * can't break so preserve the expected behaviour of setting the line
265 * low to assert reset.
267 gpiod_set_raw_value_cansleep(madera->pdata.reset, 0);
270 static void madera_disable_hard_reset(struct madera *madera)
272 if (!madera->pdata.reset)
275 gpiod_set_raw_value_cansleep(madera->pdata.reset, 1);
276 usleep_range(1000, 2000);
279 static int __maybe_unused madera_runtime_resume(struct device *dev)
281 struct madera *madera = dev_get_drvdata(dev);
284 dev_dbg(dev, "Leaving sleep mode\n");
286 ret = regulator_enable(madera->dcvdd);
288 dev_err(dev, "Failed to enable DCVDD: %d\n", ret);
292 regcache_cache_only(madera->regmap, false);
293 regcache_cache_only(madera->regmap_32bit, false);
295 ret = madera_wait_for_boot(madera);
299 ret = regcache_sync(madera->regmap);
301 dev_err(dev, "Failed to restore 16-bit register cache\n");
305 ret = regcache_sync(madera->regmap_32bit);
307 dev_err(dev, "Failed to restore 32-bit register cache\n");
314 regcache_cache_only(madera->regmap_32bit, true);
315 regcache_cache_only(madera->regmap, true);
316 regulator_disable(madera->dcvdd);
321 static int __maybe_unused madera_runtime_suspend(struct device *dev)
323 struct madera *madera = dev_get_drvdata(dev);
325 dev_dbg(madera->dev, "Entering sleep mode\n");
327 regcache_cache_only(madera->regmap, true);
328 regcache_mark_dirty(madera->regmap);
329 regcache_cache_only(madera->regmap_32bit, true);
330 regcache_mark_dirty(madera->regmap_32bit);
332 regulator_disable(madera->dcvdd);
337 const struct dev_pm_ops madera_pm_ops = {
338 SET_RUNTIME_PM_OPS(madera_runtime_suspend,
339 madera_runtime_resume,
342 EXPORT_SYMBOL_GPL(madera_pm_ops);
344 const struct of_device_id madera_of_match[] = {
345 { .compatible = "cirrus,cs47l15", .data = (void *)CS47L15 },
346 { .compatible = "cirrus,cs47l35", .data = (void *)CS47L35 },
347 { .compatible = "cirrus,cs47l85", .data = (void *)CS47L85 },
348 { .compatible = "cirrus,cs47l90", .data = (void *)CS47L90 },
349 { .compatible = "cirrus,cs47l91", .data = (void *)CS47L91 },
350 { .compatible = "cirrus,cs42l92", .data = (void *)CS42L92 },
351 { .compatible = "cirrus,cs47l92", .data = (void *)CS47L92 },
352 { .compatible = "cirrus,cs47l93", .data = (void *)CS47L93 },
353 { .compatible = "cirrus,wm1840", .data = (void *)WM1840 },
356 MODULE_DEVICE_TABLE(of, madera_of_match);
357 EXPORT_SYMBOL_GPL(madera_of_match);
359 static int madera_get_reset_gpio(struct madera *madera)
361 struct gpio_desc *reset;
364 if (madera->pdata.reset)
367 reset = devm_gpiod_get_optional(madera->dev, "reset", GPIOD_OUT_LOW);
369 ret = PTR_ERR(reset);
370 if (ret != -EPROBE_DEFER)
371 dev_err(madera->dev, "Failed to request /RESET: %d\n",
377 * A hard reset is needed for full reset of the chip. We allow running
378 * without hard reset only because it can be useful for early
379 * prototyping and some debugging, but we need to warn it's not ideal.
382 dev_warn(madera->dev,
383 "Running without reset GPIO is not recommended\n");
385 madera->pdata.reset = reset;
390 static void madera_set_micbias_info(struct madera *madera)
393 * num_childbias is an array because future codecs can have different
394 * childbiases for each micbias. Unspecified values default to 0.
396 switch (madera->type) {
398 madera->num_micbias = 1;
399 madera->num_childbias[0] = 3;
402 madera->num_micbias = 2;
403 madera->num_childbias[0] = 2;
404 madera->num_childbias[1] = 2;
408 madera->num_micbias = 4;
409 /* no child biases */
413 madera->num_micbias = 2;
414 madera->num_childbias[0] = 4;
415 madera->num_childbias[1] = 4;
420 madera->num_micbias = 2;
421 madera->num_childbias[0] = 4;
422 madera->num_childbias[1] = 2;
429 int madera_dev_init(struct madera *madera)
431 struct device *dev = madera->dev;
433 int (*patch_fn)(struct madera *) = NULL;
434 const struct mfd_cell *mfd_devs;
438 dev_set_drvdata(madera->dev, madera);
439 BLOCKING_INIT_NOTIFIER_HEAD(&madera->notifier);
440 mutex_init(&madera->dapm_ptr_lock);
442 madera_set_micbias_info(madera);
445 * We need writable hw config info that all children can share.
446 * Simplest to take one shared copy of pdata struct.
448 if (dev_get_platdata(madera->dev)) {
449 memcpy(&madera->pdata, dev_get_platdata(madera->dev),
450 sizeof(madera->pdata));
453 ret = madera_get_reset_gpio(madera);
457 regcache_cache_only(madera->regmap, true);
458 regcache_cache_only(madera->regmap_32bit, true);
460 for (i = 0; i < ARRAY_SIZE(madera_core_supplies); i++)
461 madera->core_supplies[i].supply = madera_core_supplies[i];
463 madera->num_core_supplies = ARRAY_SIZE(madera_core_supplies);
466 * On some codecs DCVDD could be supplied by the internal LDO1.
467 * For those we must add the LDO1 driver before requesting DCVDD
468 * No devm_ because we need to control shutdown order of children.
470 switch (madera->type) {
481 ret = mfd_add_devices(madera->dev, PLATFORM_DEVID_NONE,
483 ARRAY_SIZE(madera_ldo1_devs),
486 dev_err(dev, "Failed to add LDO1 child: %d\n", ret);
491 /* No point continuing if the type is unknown */
492 dev_err(madera->dev, "Unknown device type %d\n", madera->type);
496 ret = devm_regulator_bulk_get(dev, madera->num_core_supplies,
497 madera->core_supplies);
499 dev_err(dev, "Failed to request core supplies: %d\n", ret);
504 * Don't use devres here. If the regulator is one of our children it
505 * will already have been removed before devres cleanup on this mfd
506 * driver tries to call put() on it. We need control of shutdown order.
508 madera->dcvdd = regulator_get(madera->dev, "DCVDD");
509 if (IS_ERR(madera->dcvdd)) {
510 ret = PTR_ERR(madera->dcvdd);
511 dev_err(dev, "Failed to request DCVDD: %d\n", ret);
515 ret = regulator_bulk_enable(madera->num_core_supplies,
516 madera->core_supplies);
518 dev_err(dev, "Failed to enable core supplies: %d\n", ret);
522 ret = regulator_enable(madera->dcvdd);
524 dev_err(dev, "Failed to enable DCVDD: %d\n", ret);
528 madera_disable_hard_reset(madera);
530 regcache_cache_only(madera->regmap, false);
531 regcache_cache_only(madera->regmap_32bit, false);
534 * Now we can power up and verify that this is a chip we know about
535 * before we start doing any writes to its registers.
537 ret = regmap_read(madera->regmap, MADERA_SOFTWARE_RESET, &hwid);
539 dev_err(dev, "Failed to read ID register: %d\n", ret);
544 case CS47L15_SILICON_ID:
545 if (IS_ENABLED(CONFIG_MFD_CS47L15)) {
546 switch (madera->type) {
548 patch_fn = &cs47l15_patch;
549 mfd_devs = cs47l15_devs;
550 n_devs = ARRAY_SIZE(cs47l15_devs);
557 case CS47L35_SILICON_ID:
558 if (IS_ENABLED(CONFIG_MFD_CS47L35)) {
559 switch (madera->type) {
561 patch_fn = cs47l35_patch;
562 mfd_devs = cs47l35_devs;
563 n_devs = ARRAY_SIZE(cs47l35_devs);
570 case CS47L85_SILICON_ID:
571 if (IS_ENABLED(CONFIG_MFD_CS47L85)) {
572 switch (madera->type) {
575 patch_fn = cs47l85_patch;
576 mfd_devs = cs47l85_devs;
577 n_devs = ARRAY_SIZE(cs47l85_devs);
584 case CS47L90_SILICON_ID:
585 if (IS_ENABLED(CONFIG_MFD_CS47L90)) {
586 switch (madera->type) {
589 patch_fn = cs47l90_patch;
590 mfd_devs = cs47l90_devs;
591 n_devs = ARRAY_SIZE(cs47l90_devs);
598 case CS47L92_SILICON_ID:
599 if (IS_ENABLED(CONFIG_MFD_CS47L92)) {
600 switch (madera->type) {
604 patch_fn = cs47l92_patch;
605 mfd_devs = cs47l92_devs;
606 n_devs = ARRAY_SIZE(cs47l92_devs);
614 dev_err(madera->dev, "Unknown device ID: %x\n", hwid);
620 dev_err(madera->dev, "Device ID 0x%x not a %s\n", hwid,
627 * It looks like a device we support. If we don't have a hard reset
628 * we can now attempt a soft reset.
630 if (!madera->pdata.reset) {
631 ret = madera_soft_reset(madera);
636 ret = madera_wait_for_boot(madera);
638 dev_err(madera->dev, "Device failed initial boot: %d\n", ret);
642 ret = regmap_read(madera->regmap, MADERA_HARDWARE_REVISION,
645 dev_err(dev, "Failed to read revision register: %d\n", ret);
648 madera->rev &= MADERA_HW_REVISION_MASK;
650 dev_info(dev, "%s silicon revision %d\n", madera->type_name,
653 /* Apply hardware patch */
655 ret = patch_fn(madera);
657 dev_err(madera->dev, "Failed to apply patch %d\n", ret);
662 /* Init 32k clock sourced from MCLK2 */
663 ret = regmap_update_bits(madera->regmap,
665 MADERA_CLK_32K_ENA_MASK | MADERA_CLK_32K_SRC_MASK,
666 MADERA_CLK_32K_ENA | MADERA_32KZ_MCLK2);
668 dev_err(madera->dev, "Failed to init 32k clock: %d\n", ret);
672 pm_runtime_set_active(madera->dev);
673 pm_runtime_enable(madera->dev);
674 pm_runtime_set_autosuspend_delay(madera->dev, 100);
675 pm_runtime_use_autosuspend(madera->dev);
677 /* No devm_ because we need to control shutdown order of children */
678 ret = mfd_add_devices(madera->dev, PLATFORM_DEVID_NONE,
682 dev_err(madera->dev, "Failed to add subdevices: %d\n", ret);
689 pm_runtime_disable(madera->dev);
691 madera_enable_hard_reset(madera);
692 regulator_disable(madera->dcvdd);
694 regulator_bulk_disable(madera->num_core_supplies,
695 madera->core_supplies);
697 regulator_put(madera->dcvdd);
699 mfd_remove_devices(dev);
703 EXPORT_SYMBOL_GPL(madera_dev_init);
705 int madera_dev_exit(struct madera *madera)
707 /* Prevent any IRQs being serviced while we clean up */
708 disable_irq(madera->irq);
711 * DCVDD could be supplied by a child node, we must disable it before
712 * removing the children, and prevent PM runtime from turning it back on
714 pm_runtime_disable(madera->dev);
716 regulator_disable(madera->dcvdd);
717 regulator_put(madera->dcvdd);
719 mfd_remove_devices(madera->dev);
720 madera_enable_hard_reset(madera);
722 regulator_bulk_disable(madera->num_core_supplies,
723 madera->core_supplies);
726 EXPORT_SYMBOL_GPL(madera_dev_exit);
728 MODULE_DESCRIPTION("Madera core MFD driver");
729 MODULE_AUTHOR("Richard Fitzgerald <rf@opensource.cirrus.com>");
730 MODULE_LICENSE("GPL v2");