Loading...
Note: File does not exist in v3.1.
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Core MFD support for Cirrus Logic Madera codecs
4 *
5 * Copyright (C) 2015-2018 Cirrus Logic
6 */
7
8#include <linux/device.h>
9#include <linux/delay.h>
10#include <linux/err.h>
11#include <linux/gpio.h>
12#include <linux/mfd/core.h>
13#include <linux/module.h>
14#include <linux/mutex.h>
15#include <linux/notifier.h>
16#include <linux/of.h>
17#include <linux/of_gpio.h>
18#include <linux/platform_device.h>
19#include <linux/pm_runtime.h>
20#include <linux/regmap.h>
21#include <linux/regulator/consumer.h>
22#include <linux/regulator/machine.h>
23#include <linux/regulator/of_regulator.h>
24
25#include <linux/mfd/madera/core.h>
26#include <linux/mfd/madera/registers.h>
27
28#include "madera.h"
29
30#define CS47L15_SILICON_ID 0x6370
31#define CS47L35_SILICON_ID 0x6360
32#define CS47L85_SILICON_ID 0x6338
33#define CS47L90_SILICON_ID 0x6364
34#define CS47L92_SILICON_ID 0x6371
35
36#define MADERA_32KZ_MCLK2 1
37
38#define MADERA_RESET_MIN_US 2000
39#define MADERA_RESET_MAX_US 3000
40
41#define ERRATA_DCVDD_MIN_US 10000
42#define ERRATA_DCVDD_MAX_US 15000
43
44static const char * const madera_core_supplies[] = {
45 "AVDD",
46 "DBVDD1",
47};
48
49static const struct mfd_cell madera_ldo1_devs[] = {
50 {
51 .name = "madera-ldo1",
52 .level = MFD_DEP_LEVEL_HIGH,
53 },
54};
55
56static const char * const cs47l15_supplies[] = {
57 "MICVDD",
58 "CPVDD1",
59 "SPKVDD",
60};
61
62static const struct mfd_cell cs47l15_devs[] = {
63 { .name = "madera-pinctrl", },
64 { .name = "madera-irq", },
65 { .name = "madera-gpio", },
66 {
67 .name = "madera-extcon",
68 .parent_supplies = cs47l15_supplies,
69 .num_parent_supplies = 1, /* We only need MICVDD */
70 },
71 {
72 .name = "cs47l15-codec",
73 .parent_supplies = cs47l15_supplies,
74 .num_parent_supplies = ARRAY_SIZE(cs47l15_supplies),
75 },
76};
77
78static const char * const cs47l35_supplies[] = {
79 "MICVDD",
80 "DBVDD2",
81 "CPVDD1",
82 "CPVDD2",
83 "SPKVDD",
84};
85
86static const struct mfd_cell cs47l35_devs[] = {
87 { .name = "madera-pinctrl", },
88 { .name = "madera-irq", },
89 { .name = "madera-micsupp", },
90 { .name = "madera-gpio", },
91 {
92 .name = "madera-extcon",
93 .parent_supplies = cs47l35_supplies,
94 .num_parent_supplies = 1, /* We only need MICVDD */
95 },
96 {
97 .name = "cs47l35-codec",
98 .parent_supplies = cs47l35_supplies,
99 .num_parent_supplies = ARRAY_SIZE(cs47l35_supplies),
100 },
101};
102
103static const char * const cs47l85_supplies[] = {
104 "MICVDD",
105 "DBVDD2",
106 "DBVDD3",
107 "DBVDD4",
108 "CPVDD1",
109 "CPVDD2",
110 "SPKVDDL",
111 "SPKVDDR",
112};
113
114static const struct mfd_cell cs47l85_devs[] = {
115 { .name = "madera-pinctrl", },
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
131static const char * const cs47l90_supplies[] = {
132 "MICVDD",
133 "DBVDD2",
134 "DBVDD3",
135 "DBVDD4",
136 "CPVDD1",
137 "CPVDD2",
138};
139
140static const struct mfd_cell cs47l90_devs[] = {
141 { .name = "madera-pinctrl", },
142 { .name = "madera-irq", },
143 { .name = "madera-micsupp", },
144 { .name = "madera-gpio", },
145 {
146 .name = "madera-extcon",
147 .parent_supplies = cs47l90_supplies,
148 .num_parent_supplies = 1, /* We only need MICVDD */
149 },
150 {
151 .name = "cs47l90-codec",
152 .parent_supplies = cs47l90_supplies,
153 .num_parent_supplies = ARRAY_SIZE(cs47l90_supplies),
154 },
155};
156
157static const char * const cs47l92_supplies[] = {
158 "MICVDD",
159 "CPVDD1",
160 "CPVDD2",
161};
162
163static const struct mfd_cell cs47l92_devs[] = {
164 { .name = "madera-pinctrl", },
165 { .name = "madera-irq", },
166 { .name = "madera-micsupp", },
167 { .name = "madera-gpio", },
168 {
169 .name = "madera-extcon",
170 .parent_supplies = cs47l92_supplies,
171 .num_parent_supplies = 1, /* We only need MICVDD */
172 },
173 {
174 .name = "cs47l92-codec",
175 .parent_supplies = cs47l92_supplies,
176 .num_parent_supplies = ARRAY_SIZE(cs47l92_supplies),
177 },
178};
179
180/* Used by madera-i2c and madera-spi drivers */
181const char *madera_name_from_type(enum madera_type type)
182{
183 switch (type) {
184 case CS47L15:
185 return "CS47L15";
186 case CS47L35:
187 return "CS47L35";
188 case CS47L85:
189 return "CS47L85";
190 case CS47L90:
191 return "CS47L90";
192 case CS47L91:
193 return "CS47L91";
194 case CS42L92:
195 return "CS42L92";
196 case CS47L92:
197 return "CS47L92";
198 case CS47L93:
199 return "CS47L93";
200 case WM1840:
201 return "WM1840";
202 default:
203 return "Unknown";
204 }
205}
206EXPORT_SYMBOL_GPL(madera_name_from_type);
207
208#define MADERA_BOOT_POLL_INTERVAL_USEC 5000
209#define MADERA_BOOT_POLL_TIMEOUT_USEC 25000
210
211static int madera_wait_for_boot_noack(struct madera *madera)
212{
213 ktime_t timeout;
214 unsigned int val = 0;
215 int ret = 0;
216
217 /*
218 * We can't use an interrupt as we need to runtime resume to do so,
219 * so we poll the status bit. This won't race with the interrupt
220 * handler because it will be blocked on runtime resume.
221 * The chip could NAK a read request while it is booting so ignore
222 * errors from regmap_read.
223 */
224 timeout = ktime_add_us(ktime_get(), MADERA_BOOT_POLL_TIMEOUT_USEC);
225 regmap_read(madera->regmap, MADERA_IRQ1_RAW_STATUS_1, &val);
226 while (!(val & MADERA_BOOT_DONE_STS1) &&
227 !ktime_after(ktime_get(), timeout)) {
228 usleep_range(MADERA_BOOT_POLL_INTERVAL_USEC / 2,
229 MADERA_BOOT_POLL_INTERVAL_USEC);
230 regmap_read(madera->regmap, MADERA_IRQ1_RAW_STATUS_1, &val);
231 }
232
233 if (!(val & MADERA_BOOT_DONE_STS1)) {
234 dev_err(madera->dev, "Polling BOOT_DONE_STS timed out\n");
235 ret = -ETIMEDOUT;
236 }
237
238 return ret;
239}
240
241static int madera_wait_for_boot(struct madera *madera)
242{
243 int ret = madera_wait_for_boot_noack(madera);
244
245 /*
246 * BOOT_DONE defaults to unmasked on boot so we must ack it.
247 * Do this even after a timeout to avoid interrupt storms.
248 */
249 regmap_write(madera->regmap, MADERA_IRQ1_STATUS_1,
250 MADERA_BOOT_DONE_EINT1);
251
252 pm_runtime_mark_last_busy(madera->dev);
253
254 return ret;
255}
256
257static int madera_soft_reset(struct madera *madera)
258{
259 int ret;
260
261 ret = regmap_write(madera->regmap, MADERA_SOFTWARE_RESET, 0);
262 if (ret != 0) {
263 dev_err(madera->dev, "Failed to soft reset device: %d\n", ret);
264 return ret;
265 }
266
267 /* Allow time for internal clocks to startup after reset */
268 usleep_range(MADERA_RESET_MIN_US, MADERA_RESET_MAX_US);
269
270 return 0;
271}
272
273static void madera_enable_hard_reset(struct madera *madera)
274{
275 /*
276 * There are many existing out-of-tree users of these codecs that we
277 * can't break so preserve the expected behaviour of setting the line
278 * low to assert reset.
279 */
280 gpiod_set_raw_value_cansleep(madera->pdata.reset, 0);
281}
282
283static void madera_disable_hard_reset(struct madera *madera)
284{
285 gpiod_set_raw_value_cansleep(madera->pdata.reset, 1);
286
287 usleep_range(MADERA_RESET_MIN_US, MADERA_RESET_MAX_US);
288}
289
290static int __maybe_unused madera_runtime_resume(struct device *dev)
291{
292 struct madera *madera = dev_get_drvdata(dev);
293 int ret;
294
295 dev_dbg(dev, "Leaving sleep mode\n");
296
297 if (!madera->reset_errata)
298 madera_enable_hard_reset(madera);
299
300 ret = regulator_enable(madera->dcvdd);
301 if (ret) {
302 dev_err(dev, "Failed to enable DCVDD: %d\n", ret);
303 return ret;
304 }
305
306 regcache_cache_only(madera->regmap, false);
307 regcache_cache_only(madera->regmap_32bit, false);
308
309 if (madera->reset_errata)
310 usleep_range(ERRATA_DCVDD_MIN_US, ERRATA_DCVDD_MAX_US);
311 else
312 madera_disable_hard_reset(madera);
313
314 if (!madera->pdata.reset || madera->reset_errata) {
315 ret = madera_wait_for_boot(madera);
316 if (ret)
317 goto err;
318
319 ret = madera_soft_reset(madera);
320 if (ret) {
321 dev_err(dev, "Failed to reset: %d\n", ret);
322 goto err;
323 }
324 }
325
326 ret = madera_wait_for_boot(madera);
327 if (ret)
328 goto err;
329
330 ret = regcache_sync(madera->regmap);
331 if (ret) {
332 dev_err(dev, "Failed to restore 16-bit register cache\n");
333 goto err;
334 }
335
336 ret = regcache_sync(madera->regmap_32bit);
337 if (ret) {
338 dev_err(dev, "Failed to restore 32-bit register cache\n");
339 goto err;
340 }
341
342 return 0;
343
344err:
345 regcache_cache_only(madera->regmap_32bit, true);
346 regcache_cache_only(madera->regmap, true);
347 regulator_disable(madera->dcvdd);
348
349 return ret;
350}
351
352static int __maybe_unused madera_runtime_suspend(struct device *dev)
353{
354 struct madera *madera = dev_get_drvdata(dev);
355
356 dev_dbg(madera->dev, "Entering sleep mode\n");
357
358 regcache_cache_only(madera->regmap, true);
359 regcache_mark_dirty(madera->regmap);
360 regcache_cache_only(madera->regmap_32bit, true);
361 regcache_mark_dirty(madera->regmap_32bit);
362
363 regulator_disable(madera->dcvdd);
364
365 return 0;
366}
367
368const struct dev_pm_ops madera_pm_ops = {
369 SET_RUNTIME_PM_OPS(madera_runtime_suspend,
370 madera_runtime_resume,
371 NULL)
372};
373EXPORT_SYMBOL_GPL(madera_pm_ops);
374
375const struct of_device_id madera_of_match[] = {
376 { .compatible = "cirrus,cs47l15", .data = (void *)CS47L15 },
377 { .compatible = "cirrus,cs47l35", .data = (void *)CS47L35 },
378 { .compatible = "cirrus,cs47l85", .data = (void *)CS47L85 },
379 { .compatible = "cirrus,cs47l90", .data = (void *)CS47L90 },
380 { .compatible = "cirrus,cs47l91", .data = (void *)CS47L91 },
381 { .compatible = "cirrus,cs42l92", .data = (void *)CS42L92 },
382 { .compatible = "cirrus,cs47l92", .data = (void *)CS47L92 },
383 { .compatible = "cirrus,cs47l93", .data = (void *)CS47L93 },
384 { .compatible = "cirrus,wm1840", .data = (void *)WM1840 },
385 {}
386};
387MODULE_DEVICE_TABLE(of, madera_of_match);
388EXPORT_SYMBOL_GPL(madera_of_match);
389
390static int madera_get_reset_gpio(struct madera *madera)
391{
392 struct gpio_desc *reset;
393
394 if (madera->pdata.reset)
395 return 0;
396
397 reset = devm_gpiod_get_optional(madera->dev, "reset", GPIOD_OUT_LOW);
398 if (IS_ERR(reset))
399 return dev_err_probe(madera->dev, PTR_ERR(reset),
400 "Failed to request /RESET");
401
402 /*
403 * A hard reset is needed for full reset of the chip. We allow running
404 * without hard reset only because it can be useful for early
405 * prototyping and some debugging, but we need to warn it's not ideal.
406 */
407 if (!reset)
408 dev_warn(madera->dev,
409 "Running without reset GPIO is not recommended\n");
410
411 madera->pdata.reset = reset;
412
413 return 0;
414}
415
416static void madera_set_micbias_info(struct madera *madera)
417{
418 /*
419 * num_childbias is an array because future codecs can have different
420 * childbiases for each micbias. Unspecified values default to 0.
421 */
422 switch (madera->type) {
423 case CS47L15:
424 madera->num_micbias = 1;
425 madera->num_childbias[0] = 3;
426 return;
427 case CS47L35:
428 madera->num_micbias = 2;
429 madera->num_childbias[0] = 2;
430 madera->num_childbias[1] = 2;
431 return;
432 case CS47L85:
433 case WM1840:
434 madera->num_micbias = 4;
435 /* no child biases */
436 return;
437 case CS47L90:
438 case CS47L91:
439 madera->num_micbias = 2;
440 madera->num_childbias[0] = 4;
441 madera->num_childbias[1] = 4;
442 return;
443 case CS42L92:
444 case CS47L92:
445 case CS47L93:
446 madera->num_micbias = 2;
447 madera->num_childbias[0] = 4;
448 madera->num_childbias[1] = 2;
449 return;
450 default:
451 return;
452 }
453}
454
455int madera_dev_init(struct madera *madera)
456{
457 struct device *dev = madera->dev;
458 unsigned int hwid;
459 int (*patch_fn)(struct madera *) = NULL;
460 const struct mfd_cell *mfd_devs;
461 int n_devs = 0;
462 int i, ret;
463
464 dev_set_drvdata(madera->dev, madera);
465 BLOCKING_INIT_NOTIFIER_HEAD(&madera->notifier);
466 mutex_init(&madera->dapm_ptr_lock);
467
468 madera_set_micbias_info(madera);
469
470 /*
471 * We need writable hw config info that all children can share.
472 * Simplest to take one shared copy of pdata struct.
473 */
474 if (dev_get_platdata(madera->dev)) {
475 memcpy(&madera->pdata, dev_get_platdata(madera->dev),
476 sizeof(madera->pdata));
477 }
478
479 madera->mclk[MADERA_MCLK1].id = "mclk1";
480 madera->mclk[MADERA_MCLK2].id = "mclk2";
481 madera->mclk[MADERA_MCLK3].id = "mclk3";
482
483 ret = devm_clk_bulk_get_optional(madera->dev, ARRAY_SIZE(madera->mclk),
484 madera->mclk);
485 if (ret) {
486 dev_err(madera->dev, "Failed to get clocks: %d\n", ret);
487 return ret;
488 }
489
490 /* Not using devm_clk_get to prevent breakage of existing DTs */
491 if (!madera->mclk[MADERA_MCLK2].clk)
492 dev_warn(madera->dev, "Missing MCLK2, requires 32kHz clock\n");
493
494 ret = madera_get_reset_gpio(madera);
495 if (ret)
496 return ret;
497
498 regcache_cache_only(madera->regmap, true);
499 regcache_cache_only(madera->regmap_32bit, true);
500
501 for (i = 0; i < ARRAY_SIZE(madera_core_supplies); i++)
502 madera->core_supplies[i].supply = madera_core_supplies[i];
503
504 madera->num_core_supplies = ARRAY_SIZE(madera_core_supplies);
505
506 /*
507 * On some codecs DCVDD could be supplied by the internal LDO1.
508 * For those we must add the LDO1 driver before requesting DCVDD
509 * No devm_ because we need to control shutdown order of children.
510 */
511 switch (madera->type) {
512 case CS47L15:
513 madera->reset_errata = true;
514 break;
515 case CS47L35:
516 case CS47L90:
517 case CS47L91:
518 case CS42L92:
519 case CS47L92:
520 case CS47L93:
521 break;
522 case CS47L85:
523 case WM1840:
524 ret = mfd_add_devices(madera->dev, PLATFORM_DEVID_NONE,
525 madera_ldo1_devs,
526 ARRAY_SIZE(madera_ldo1_devs),
527 NULL, 0, NULL);
528 if (ret) {
529 dev_err(dev, "Failed to add LDO1 child: %d\n", ret);
530 return ret;
531 }
532 break;
533 default:
534 /* No point continuing if the type is unknown */
535 dev_err(madera->dev, "Unknown device type %d\n", madera->type);
536 return -ENODEV;
537 }
538
539 ret = devm_regulator_bulk_get(dev, madera->num_core_supplies,
540 madera->core_supplies);
541 if (ret) {
542 dev_err(dev, "Failed to request core supplies: %d\n", ret);
543 goto err_devs;
544 }
545
546 /*
547 * Don't use devres here. If the regulator is one of our children it
548 * will already have been removed before devres cleanup on this mfd
549 * driver tries to call put() on it. We need control of shutdown order.
550 */
551 madera->dcvdd = regulator_get(madera->dev, "DCVDD");
552 if (IS_ERR(madera->dcvdd)) {
553 ret = PTR_ERR(madera->dcvdd);
554 dev_err(dev, "Failed to request DCVDD: %d\n", ret);
555 goto err_devs;
556 }
557
558 ret = regulator_bulk_enable(madera->num_core_supplies,
559 madera->core_supplies);
560 if (ret) {
561 dev_err(dev, "Failed to enable core supplies: %d\n", ret);
562 goto err_dcvdd;
563 }
564
565 if (madera->reset_errata)
566 madera_disable_hard_reset(madera);
567
568 ret = regulator_enable(madera->dcvdd);
569 if (ret) {
570 dev_err(dev, "Failed to enable DCVDD: %d\n", ret);
571 goto err_enable;
572 }
573
574 if (madera->reset_errata)
575 usleep_range(ERRATA_DCVDD_MIN_US, ERRATA_DCVDD_MAX_US);
576 else
577 madera_disable_hard_reset(madera);
578
579 regcache_cache_only(madera->regmap, false);
580 regcache_cache_only(madera->regmap_32bit, false);
581
582 ret = madera_wait_for_boot_noack(madera);
583 if (ret) {
584 dev_err(madera->dev, "Device failed initial boot: %d\n", ret);
585 goto err_reset;
586 }
587
588 /*
589 * Now we can power up and verify that this is a chip we know about
590 * before we start doing any writes to its registers.
591 */
592 ret = regmap_read(madera->regmap, MADERA_SOFTWARE_RESET, &hwid);
593 if (ret) {
594 dev_err(dev, "Failed to read ID register: %d\n", ret);
595 goto err_reset;
596 }
597
598 switch (hwid) {
599 case CS47L15_SILICON_ID:
600 if (IS_ENABLED(CONFIG_MFD_CS47L15)) {
601 switch (madera->type) {
602 case CS47L15:
603 patch_fn = &cs47l15_patch;
604 mfd_devs = cs47l15_devs;
605 n_devs = ARRAY_SIZE(cs47l15_devs);
606 break;
607 default:
608 break;
609 }
610 }
611 break;
612 case CS47L35_SILICON_ID:
613 if (IS_ENABLED(CONFIG_MFD_CS47L35)) {
614 switch (madera->type) {
615 case CS47L35:
616 patch_fn = cs47l35_patch;
617 mfd_devs = cs47l35_devs;
618 n_devs = ARRAY_SIZE(cs47l35_devs);
619 break;
620 default:
621 break;
622 }
623 }
624 break;
625 case CS47L85_SILICON_ID:
626 if (IS_ENABLED(CONFIG_MFD_CS47L85)) {
627 switch (madera->type) {
628 case CS47L85:
629 case WM1840:
630 patch_fn = cs47l85_patch;
631 mfd_devs = cs47l85_devs;
632 n_devs = ARRAY_SIZE(cs47l85_devs);
633 break;
634 default:
635 break;
636 }
637 }
638 break;
639 case CS47L90_SILICON_ID:
640 if (IS_ENABLED(CONFIG_MFD_CS47L90)) {
641 switch (madera->type) {
642 case CS47L90:
643 case CS47L91:
644 patch_fn = cs47l90_patch;
645 mfd_devs = cs47l90_devs;
646 n_devs = ARRAY_SIZE(cs47l90_devs);
647 break;
648 default:
649 break;
650 }
651 }
652 break;
653 case CS47L92_SILICON_ID:
654 if (IS_ENABLED(CONFIG_MFD_CS47L92)) {
655 switch (madera->type) {
656 case CS42L92:
657 case CS47L92:
658 case CS47L93:
659 patch_fn = cs47l92_patch;
660 mfd_devs = cs47l92_devs;
661 n_devs = ARRAY_SIZE(cs47l92_devs);
662 break;
663 default:
664 break;
665 }
666 }
667 break;
668 default:
669 dev_err(madera->dev, "Unknown device ID: %x\n", hwid);
670 ret = -EINVAL;
671 goto err_reset;
672 }
673
674 if (!n_devs) {
675 dev_err(madera->dev, "Device ID 0x%x not a %s\n", hwid,
676 madera->type_name);
677 ret = -ENODEV;
678 goto err_reset;
679 }
680
681 /*
682 * It looks like a device we support. If we don't have a hard reset
683 * we can now attempt a soft reset.
684 */
685 if (!madera->pdata.reset || madera->reset_errata) {
686 ret = madera_soft_reset(madera);
687 if (ret)
688 goto err_reset;
689 }
690
691 ret = madera_wait_for_boot(madera);
692 if (ret) {
693 dev_err(madera->dev, "Failed to clear boot done: %d\n", ret);
694 goto err_reset;
695 }
696
697 ret = regmap_read(madera->regmap, MADERA_HARDWARE_REVISION,
698 &madera->rev);
699 if (ret) {
700 dev_err(dev, "Failed to read revision register: %d\n", ret);
701 goto err_reset;
702 }
703 madera->rev &= MADERA_HW_REVISION_MASK;
704
705 dev_info(dev, "%s silicon revision %d\n", madera->type_name,
706 madera->rev);
707
708 /* Apply hardware patch */
709 if (patch_fn) {
710 ret = patch_fn(madera);
711 if (ret) {
712 dev_err(madera->dev, "Failed to apply patch %d\n", ret);
713 goto err_reset;
714 }
715 }
716
717 /* Init 32k clock sourced from MCLK2 */
718 ret = clk_prepare_enable(madera->mclk[MADERA_MCLK2].clk);
719 if (ret) {
720 dev_err(madera->dev, "Failed to enable 32k clock: %d\n", ret);
721 goto err_reset;
722 }
723
724 ret = regmap_update_bits(madera->regmap,
725 MADERA_CLOCK_32K_1,
726 MADERA_CLK_32K_ENA_MASK | MADERA_CLK_32K_SRC_MASK,
727 MADERA_CLK_32K_ENA | MADERA_32KZ_MCLK2);
728 if (ret) {
729 dev_err(madera->dev, "Failed to init 32k clock: %d\n", ret);
730 goto err_clock;
731 }
732
733 pm_runtime_set_active(madera->dev);
734 pm_runtime_enable(madera->dev);
735 pm_runtime_set_autosuspend_delay(madera->dev, 100);
736 pm_runtime_use_autosuspend(madera->dev);
737
738 /* No devm_ because we need to control shutdown order of children */
739 ret = mfd_add_devices(madera->dev, PLATFORM_DEVID_NONE,
740 mfd_devs, n_devs,
741 NULL, 0, NULL);
742 if (ret) {
743 dev_err(madera->dev, "Failed to add subdevices: %d\n", ret);
744 goto err_pm_runtime;
745 }
746
747 return 0;
748
749err_pm_runtime:
750 pm_runtime_disable(madera->dev);
751err_clock:
752 clk_disable_unprepare(madera->mclk[MADERA_MCLK2].clk);
753err_reset:
754 madera_enable_hard_reset(madera);
755 regulator_disable(madera->dcvdd);
756err_enable:
757 regulator_bulk_disable(madera->num_core_supplies,
758 madera->core_supplies);
759err_dcvdd:
760 regulator_put(madera->dcvdd);
761err_devs:
762 mfd_remove_devices(dev);
763
764 return ret;
765}
766EXPORT_SYMBOL_GPL(madera_dev_init);
767
768int madera_dev_exit(struct madera *madera)
769{
770 /* Prevent any IRQs being serviced while we clean up */
771 disable_irq(madera->irq);
772
773 pm_runtime_get_sync(madera->dev);
774
775 mfd_remove_devices(madera->dev);
776
777 pm_runtime_disable(madera->dev);
778
779 regulator_disable(madera->dcvdd);
780 regulator_put(madera->dcvdd);
781
782 mfd_remove_devices_late(madera->dev);
783
784 pm_runtime_set_suspended(madera->dev);
785 pm_runtime_put_noidle(madera->dev);
786
787 clk_disable_unprepare(madera->mclk[MADERA_MCLK2].clk);
788
789 madera_enable_hard_reset(madera);
790
791 regulator_bulk_disable(madera->num_core_supplies,
792 madera->core_supplies);
793 return 0;
794}
795EXPORT_SYMBOL_GPL(madera_dev_exit);
796
797MODULE_DESCRIPTION("Madera core MFD driver");
798MODULE_AUTHOR("Richard Fitzgerald <rf@opensource.cirrus.com>");
799MODULE_LICENSE("GPL v2");