xref: /openbmc/linux/drivers/mfd/madera-core.c (revision cce8e04c)
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");
617