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