1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * Renesas R-Car GyroADC driver
4 *
5 * Copyright 2016 Marek Vasut <marek.vasut@gmail.com>
6 */
7
8#include <linux/module.h>
9#include <linux/platform_device.h>
10#include <linux/delay.h>
11#include <linux/kernel.h>
12#include <linux/slab.h>
13#include <linux/io.h>
14#include <linux/clk.h>
15#include <linux/of.h>
16#include <linux/of_irq.h>
17#include <linux/regulator/consumer.h>
18#include <linux/of_platform.h>
19#include <linux/err.h>
20#include <linux/pm_runtime.h>
21
22#include <linux/iio/iio.h>
23#include <linux/iio/sysfs.h>
24#include <linux/iio/trigger.h>
25
26#define DRIVER_NAME				"rcar-gyroadc"
27
28/* GyroADC registers. */
29#define RCAR_GYROADC_MODE_SELECT		0x00
30#define RCAR_GYROADC_MODE_SELECT_1_MB88101A	0x0
31#define RCAR_GYROADC_MODE_SELECT_2_ADCS7476	0x1
32#define RCAR_GYROADC_MODE_SELECT_3_MAX1162	0x3
33
34#define RCAR_GYROADC_START_STOP			0x04
35#define RCAR_GYROADC_START_STOP_START		BIT(0)
36
37#define RCAR_GYROADC_CLOCK_LENGTH		0x08
38#define RCAR_GYROADC_1_25MS_LENGTH		0x0c
39
40#define RCAR_GYROADC_REALTIME_DATA(ch)		(0x10 + ((ch) * 4))
41#define RCAR_GYROADC_100MS_ADDED_DATA(ch)	(0x30 + ((ch) * 4))
42#define RCAR_GYROADC_10MS_AVG_DATA(ch)		(0x50 + ((ch) * 4))
43
44#define RCAR_GYROADC_FIFO_STATUS		0x70
45#define RCAR_GYROADC_FIFO_STATUS_EMPTY(ch)	BIT(0 + (4 * (ch)))
46#define RCAR_GYROADC_FIFO_STATUS_FULL(ch)	BIT(1 + (4 * (ch)))
47#define RCAR_GYROADC_FIFO_STATUS_ERROR(ch)	BIT(2 + (4 * (ch)))
48
49#define RCAR_GYROADC_INTR			0x74
50#define RCAR_GYROADC_INTR_INT			BIT(0)
51
52#define RCAR_GYROADC_INTENR			0x78
53#define RCAR_GYROADC_INTENR_INTEN		BIT(0)
54
55#define RCAR_GYROADC_SAMPLE_RATE		800	/* Hz */
56
57#define RCAR_GYROADC_RUNTIME_PM_DELAY_MS	2000
58
59enum rcar_gyroadc_model {
60	RCAR_GYROADC_MODEL_DEFAULT,
61	RCAR_GYROADC_MODEL_R8A7792,
62};
63
64struct rcar_gyroadc {
65	struct device			*dev;
66	void __iomem			*regs;
67	struct clk			*clk;
68	struct regulator		*vref[8];
69	unsigned int			num_channels;
70	enum rcar_gyroadc_model		model;
71	unsigned int			mode;
72	unsigned int			sample_width;
73};
74
75static void rcar_gyroadc_hw_init(struct rcar_gyroadc *priv)
76{
77	const unsigned long clk_mhz = clk_get_rate(priv->clk) / 1000000;
78	const unsigned long clk_mul =
79		(priv->mode == RCAR_GYROADC_MODE_SELECT_1_MB88101A) ? 10 : 5;
80	unsigned long clk_len = clk_mhz * clk_mul;
81
82	/*
83	 * According to the R-Car Gen2 datasheet Rev. 1.01, Sept 08 2014,
84	 * page 77-7, clock length must be even number. If it's odd number,
85	 * add one.
86	 */
87	if (clk_len & 1)
88		clk_len++;
89
90	/* Stop the GyroADC. */
91	writel(0, priv->regs + RCAR_GYROADC_START_STOP);
92
93	/* Disable IRQ on V2H. */
94	if (priv->model == RCAR_GYROADC_MODEL_R8A7792)
95		writel(0, priv->regs + RCAR_GYROADC_INTENR);
96
97	/* Set mode and timing. */
98	writel(priv->mode, priv->regs + RCAR_GYROADC_MODE_SELECT);
99	writel(clk_len, priv->regs + RCAR_GYROADC_CLOCK_LENGTH);
100	writel(clk_mhz * 1250, priv->regs + RCAR_GYROADC_1_25MS_LENGTH);
101}
102
103static void rcar_gyroadc_hw_start(struct rcar_gyroadc *priv)
104{
105	/* Start sampling. */
106	writel(RCAR_GYROADC_START_STOP_START,
107	       priv->regs + RCAR_GYROADC_START_STOP);
108
109	/*
110	 * Wait for the first conversion to complete. This is longer than
111	 * the 1.25 mS in the datasheet because 1.25 mS is not enough for
112	 * the hardware to deliver the first sample and the hardware does
113	 * then return zeroes instead of valid data.
114	 */
115	mdelay(3);
116}
117
118static void rcar_gyroadc_hw_stop(struct rcar_gyroadc *priv)
119{
120	/* Stop the GyroADC. */
121	writel(0, priv->regs + RCAR_GYROADC_START_STOP);
122}
123
124#define RCAR_GYROADC_CHAN(_idx) {				\
125	.type			= IIO_VOLTAGE,			\
126	.indexed		= 1,				\
127	.channel		= (_idx),			\
128	.info_mask_separate	= BIT(IIO_CHAN_INFO_RAW) |	\
129				  BIT(IIO_CHAN_INFO_SCALE),	\
130	.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
131}
132
133static const struct iio_chan_spec rcar_gyroadc_iio_channels_1[] = {
134	RCAR_GYROADC_CHAN(0),
135	RCAR_GYROADC_CHAN(1),
136	RCAR_GYROADC_CHAN(2),
137	RCAR_GYROADC_CHAN(3),
138};
139
140static const struct iio_chan_spec rcar_gyroadc_iio_channels_2[] = {
141	RCAR_GYROADC_CHAN(0),
142	RCAR_GYROADC_CHAN(1),
143	RCAR_GYROADC_CHAN(2),
144	RCAR_GYROADC_CHAN(3),
145	RCAR_GYROADC_CHAN(4),
146	RCAR_GYROADC_CHAN(5),
147	RCAR_GYROADC_CHAN(6),
148	RCAR_GYROADC_CHAN(7),
149};
150
151static const struct iio_chan_spec rcar_gyroadc_iio_channels_3[] = {
152	RCAR_GYROADC_CHAN(0),
153	RCAR_GYROADC_CHAN(1),
154	RCAR_GYROADC_CHAN(2),
155	RCAR_GYROADC_CHAN(3),
156	RCAR_GYROADC_CHAN(4),
157	RCAR_GYROADC_CHAN(5),
158	RCAR_GYROADC_CHAN(6),
159	RCAR_GYROADC_CHAN(7),
160};
161
162static int rcar_gyroadc_set_power(struct rcar_gyroadc *priv, bool on)
163{
164	struct device *dev = priv->dev;
165
166	if (on) {
167		return pm_runtime_resume_and_get(dev);
168	} else {
169		pm_runtime_mark_last_busy(dev);
170		return pm_runtime_put_autosuspend(dev);
171	}
172}
173
174static int rcar_gyroadc_read_raw(struct iio_dev *indio_dev,
175				 struct iio_chan_spec const *chan,
176				 int *val, int *val2, long mask)
177{
178	struct rcar_gyroadc *priv = iio_priv(indio_dev);
179	struct regulator *consumer;
180	unsigned int datareg = RCAR_GYROADC_REALTIME_DATA(chan->channel);
181	unsigned int vref;
182	int ret;
183
184	/*
185	 * MB88101 is special in that it has only single regulator for
186	 * all four channels.
187	 */
188	if (priv->mode == RCAR_GYROADC_MODE_SELECT_1_MB88101A)
189		consumer = priv->vref[0];
190	else
191		consumer = priv->vref[chan->channel];
192
193	switch (mask) {
194	case IIO_CHAN_INFO_RAW:
195		if (chan->type != IIO_VOLTAGE)
196			return -EINVAL;
197
198		/* Channel not connected. */
199		if (!consumer)
200			return -EINVAL;
201
202		ret = iio_device_claim_direct_mode(indio_dev);
203		if (ret)
204			return ret;
205
206		ret = rcar_gyroadc_set_power(priv, true);
207		if (ret < 0) {
208			iio_device_release_direct_mode(indio_dev);
209			return ret;
210		}
211
212		*val = readl(priv->regs + datareg);
213		*val &= BIT(priv->sample_width) - 1;
214
215		ret = rcar_gyroadc_set_power(priv, false);
216		iio_device_release_direct_mode(indio_dev);
217		if (ret < 0)
218			return ret;
219
220		return IIO_VAL_INT;
221	case IIO_CHAN_INFO_SCALE:
222		/* Channel not connected. */
223		if (!consumer)
224			return -EINVAL;
225
226		vref = regulator_get_voltage(consumer);
227		*val = vref / 1000;
228		*val2 = 1 << priv->sample_width;
229
230		return IIO_VAL_FRACTIONAL;
231	case IIO_CHAN_INFO_SAMP_FREQ:
232		*val = RCAR_GYROADC_SAMPLE_RATE;
233
234		return IIO_VAL_INT;
235	default:
236		return -EINVAL;
237	}
238}
239
240static int rcar_gyroadc_reg_access(struct iio_dev *indio_dev,
241				   unsigned int reg, unsigned int writeval,
242				   unsigned int *readval)
243{
244	struct rcar_gyroadc *priv = iio_priv(indio_dev);
245	unsigned int maxreg = RCAR_GYROADC_FIFO_STATUS;
246
247	if (readval == NULL)
248		return -EINVAL;
249
250	if (reg % 4)
251		return -EINVAL;
252
253	/* Handle the V2H case with extra interrupt block. */
254	if (priv->model == RCAR_GYROADC_MODEL_R8A7792)
255		maxreg = RCAR_GYROADC_INTENR;
256
257	if (reg > maxreg)
258		return -EINVAL;
259
260	*readval = readl(priv->regs + reg);
261
262	return 0;
263}
264
265static const struct iio_info rcar_gyroadc_iio_info = {
266	.read_raw		= rcar_gyroadc_read_raw,
267	.debugfs_reg_access	= rcar_gyroadc_reg_access,
268};
269
270static const struct of_device_id rcar_gyroadc_match[] = {
271	{
272		/* R-Car compatible GyroADC */
273		.compatible	= "renesas,rcar-gyroadc",
274		.data		= (void *)RCAR_GYROADC_MODEL_DEFAULT,
275	}, {
276		/* R-Car V2H specialty with interrupt registers. */
277		.compatible	= "renesas,r8a7792-gyroadc",
278		.data		= (void *)RCAR_GYROADC_MODEL_R8A7792,
279	}, {
280		/* sentinel */
281	}
282};
283
284MODULE_DEVICE_TABLE(of, rcar_gyroadc_match);
285
286static const struct of_device_id rcar_gyroadc_child_match[] __maybe_unused = {
287	/* Mode 1 ADCs */
288	{
289		.compatible	= "fujitsu,mb88101a",
290		.data		= (void *)RCAR_GYROADC_MODE_SELECT_1_MB88101A,
291	},
292	/* Mode 2 ADCs */
293	{
294		.compatible	= "ti,adcs7476",
295		.data		= (void *)RCAR_GYROADC_MODE_SELECT_2_ADCS7476,
296	}, {
297		.compatible	= "ti,adc121",
298		.data		= (void *)RCAR_GYROADC_MODE_SELECT_2_ADCS7476,
299	}, {
300		.compatible	= "adi,ad7476",
301		.data		= (void *)RCAR_GYROADC_MODE_SELECT_2_ADCS7476,
302	},
303	/* Mode 3 ADCs */
304	{
305		.compatible	= "maxim,max1162",
306		.data		= (void *)RCAR_GYROADC_MODE_SELECT_3_MAX1162,
307	}, {
308		.compatible	= "maxim,max11100",
309		.data		= (void *)RCAR_GYROADC_MODE_SELECT_3_MAX1162,
310	},
311	{ /* sentinel */ }
312};
313
314static int rcar_gyroadc_parse_subdevs(struct iio_dev *indio_dev)
315{
316	const struct of_device_id *of_id;
317	const struct iio_chan_spec *channels;
318	struct rcar_gyroadc *priv = iio_priv(indio_dev);
319	struct device *dev = priv->dev;
320	struct device_node *np = dev->of_node;
321	struct device_node *child;
322	struct regulator *vref;
323	unsigned int reg;
324	unsigned int adcmode = -1, childmode;
325	unsigned int sample_width;
326	unsigned int num_channels;
327	int ret, first = 1;
328
329	for_each_child_of_node(np, child) {
330		of_id = of_match_node(rcar_gyroadc_child_match, child);
331		if (!of_id) {
332			dev_err(dev, "Ignoring unsupported ADC \"%pOFn\".",
333				child);
334			continue;
335		}
336
337		childmode = (uintptr_t)of_id->data;
338		switch (childmode) {
339		case RCAR_GYROADC_MODE_SELECT_1_MB88101A:
340			sample_width = 12;
341			channels = rcar_gyroadc_iio_channels_1;
342			num_channels = ARRAY_SIZE(rcar_gyroadc_iio_channels_1);
343			break;
344		case RCAR_GYROADC_MODE_SELECT_2_ADCS7476:
345			sample_width = 15;
346			channels = rcar_gyroadc_iio_channels_2;
347			num_channels = ARRAY_SIZE(rcar_gyroadc_iio_channels_2);
348			break;
349		case RCAR_GYROADC_MODE_SELECT_3_MAX1162:
350			sample_width = 16;
351			channels = rcar_gyroadc_iio_channels_3;
352			num_channels = ARRAY_SIZE(rcar_gyroadc_iio_channels_3);
353			break;
354		default:
355			goto err_e_inval;
356		}
357
358		/*
359		 * MB88101 is special in that it's only a single chip taking
360		 * up all the CHS lines. Thus, the DT binding is also special
361		 * and has no reg property. If we run into such ADC, handle
362		 * it here.
363		 */
364		if (childmode == RCAR_GYROADC_MODE_SELECT_1_MB88101A) {
365			reg = 0;
366		} else {
367			ret = of_property_read_u32(child, "reg", &reg);
368			if (ret) {
369				dev_err(dev,
370					"Failed to get child reg property of ADC \"%pOFn\".\n",
371					child);
372				goto err_of_node_put;
373			}
374
375			/* Channel number is too high. */
376			if (reg >= num_channels) {
377				dev_err(dev,
378					"Only %i channels supported with %pOFn, but reg = <%i>.\n",
379					num_channels, child, reg);
380				goto err_e_inval;
381			}
382		}
383
384		/* Child node selected different mode than the rest. */
385		if (!first && (adcmode != childmode)) {
386			dev_err(dev,
387				"Channel %i uses different ADC mode than the rest.\n",
388				reg);
389			goto err_e_inval;
390		}
391
392		/* Channel is valid, grab the regulator. */
393		dev->of_node = child;
394		vref = devm_regulator_get(dev, "vref");
395		dev->of_node = np;
396		if (IS_ERR(vref)) {
397			dev_dbg(dev, "Channel %i 'vref' supply not connected.\n",
398				reg);
399			ret = PTR_ERR(vref);
400			goto err_of_node_put;
401		}
402
403		priv->vref[reg] = vref;
404
405		if (!first)
406			continue;
407
408		/* First child node which passed sanity tests. */
409		adcmode = childmode;
410		first = 0;
411
412		priv->num_channels = num_channels;
413		priv->mode = childmode;
414		priv->sample_width = sample_width;
415
416		indio_dev->channels = channels;
417		indio_dev->num_channels = num_channels;
418
419		/*
420		 * MB88101 is special and we only have one such device
421		 * attached to the GyroADC at a time, so if we found it,
422		 * we can stop parsing here.
423		 */
424		if (childmode == RCAR_GYROADC_MODE_SELECT_1_MB88101A) {
425			of_node_put(child);
426			break;
427		}
428	}
429
430	if (first) {
431		dev_err(dev, "No valid ADC channels found, aborting.\n");
432		return -EINVAL;
433	}
434
435	return 0;
436
437err_e_inval:
438	ret = -EINVAL;
439err_of_node_put:
440	of_node_put(child);
441	return ret;
442}
443
444static void rcar_gyroadc_deinit_supplies(struct iio_dev *indio_dev)
445{
446	struct rcar_gyroadc *priv = iio_priv(indio_dev);
447	unsigned int i;
448
449	for (i = 0; i < priv->num_channels; i++) {
450		if (!priv->vref[i])
451			continue;
452
453		regulator_disable(priv->vref[i]);
454	}
455}
456
457static int rcar_gyroadc_init_supplies(struct iio_dev *indio_dev)
458{
459	struct rcar_gyroadc *priv = iio_priv(indio_dev);
460	struct device *dev = priv->dev;
461	unsigned int i;
462	int ret;
463
464	for (i = 0; i < priv->num_channels; i++) {
465		if (!priv->vref[i])
466			continue;
467
468		ret = regulator_enable(priv->vref[i]);
469		if (ret) {
470			dev_err(dev, "Failed to enable regulator %i (ret=%i)\n",
471				i, ret);
472			goto err;
473		}
474	}
475
476	return 0;
477
478err:
479	rcar_gyroadc_deinit_supplies(indio_dev);
480	return ret;
481}
482
483static int rcar_gyroadc_probe(struct platform_device *pdev)
484{
485	struct device *dev = &pdev->dev;
486	struct rcar_gyroadc *priv;
487	struct iio_dev *indio_dev;
488	int ret;
489
490	indio_dev = devm_iio_device_alloc(dev, sizeof(*priv));
491	if (!indio_dev)
492		return -ENOMEM;
493
494	priv = iio_priv(indio_dev);
495	priv->dev = dev;
496
497	priv->regs = devm_platform_ioremap_resource(pdev, 0);
498	if (IS_ERR(priv->regs))
499		return PTR_ERR(priv->regs);
500
501	priv->clk = devm_clk_get(dev, "fck");
502	if (IS_ERR(priv->clk))
503		return dev_err_probe(dev, PTR_ERR(priv->clk),
504				     "Failed to get IF clock\n");
505
506	ret = rcar_gyroadc_parse_subdevs(indio_dev);
507	if (ret)
508		return ret;
509
510	ret = rcar_gyroadc_init_supplies(indio_dev);
511	if (ret)
512		return ret;
513
514	priv->model = (uintptr_t)of_device_get_match_data(&pdev->dev);
515
516	platform_set_drvdata(pdev, indio_dev);
517
518	indio_dev->name = DRIVER_NAME;
519	indio_dev->info = &rcar_gyroadc_iio_info;
520	indio_dev->modes = INDIO_DIRECT_MODE;
521
522	ret = clk_prepare_enable(priv->clk);
523	if (ret) {
524		dev_err(dev, "Could not prepare or enable the IF clock.\n");
525		goto err_clk_if_enable;
526	}
527
528	pm_runtime_set_autosuspend_delay(dev, RCAR_GYROADC_RUNTIME_PM_DELAY_MS);
529	pm_runtime_use_autosuspend(dev);
530	pm_runtime_enable(dev);
531
532	ret = pm_runtime_resume_and_get(dev);
533	if (ret)
534		goto err_power_up;
535
536	rcar_gyroadc_hw_init(priv);
537	rcar_gyroadc_hw_start(priv);
538
539	ret = iio_device_register(indio_dev);
540	if (ret) {
541		dev_err(dev, "Couldn't register IIO device.\n");
542		goto err_iio_device_register;
543	}
544
545	pm_runtime_put_sync(dev);
546
547	return 0;
548
549err_iio_device_register:
550	rcar_gyroadc_hw_stop(priv);
551	pm_runtime_put_sync(dev);
552err_power_up:
553	pm_runtime_disable(dev);
554	pm_runtime_set_suspended(dev);
555	clk_disable_unprepare(priv->clk);
556err_clk_if_enable:
557	rcar_gyroadc_deinit_supplies(indio_dev);
558
559	return ret;
560}
561
562static void rcar_gyroadc_remove(struct platform_device *pdev)
563{
564	struct iio_dev *indio_dev = platform_get_drvdata(pdev);
565	struct rcar_gyroadc *priv = iio_priv(indio_dev);
566	struct device *dev = priv->dev;
567
568	iio_device_unregister(indio_dev);
569	pm_runtime_get_sync(dev);
570	rcar_gyroadc_hw_stop(priv);
571	pm_runtime_put_sync(dev);
572	pm_runtime_disable(dev);
573	pm_runtime_set_suspended(dev);
574	clk_disable_unprepare(priv->clk);
575	rcar_gyroadc_deinit_supplies(indio_dev);
576}
577
578static int rcar_gyroadc_suspend(struct device *dev)
579{
580	struct iio_dev *indio_dev = dev_get_drvdata(dev);
581	struct rcar_gyroadc *priv = iio_priv(indio_dev);
582
583	rcar_gyroadc_hw_stop(priv);
584
585	return 0;
586}
587
588static int rcar_gyroadc_resume(struct device *dev)
589{
590	struct iio_dev *indio_dev = dev_get_drvdata(dev);
591	struct rcar_gyroadc *priv = iio_priv(indio_dev);
592
593	rcar_gyroadc_hw_start(priv);
594
595	return 0;
596}
597
598static const struct dev_pm_ops rcar_gyroadc_pm_ops = {
599	RUNTIME_PM_OPS(rcar_gyroadc_suspend, rcar_gyroadc_resume, NULL)
600};
601
602static struct platform_driver rcar_gyroadc_driver = {
603	.probe          = rcar_gyroadc_probe,
604	.remove_new     = rcar_gyroadc_remove,
605	.driver         = {
606		.name		= DRIVER_NAME,
607		.of_match_table	= rcar_gyroadc_match,
608		.pm		= pm_ptr(&rcar_gyroadc_pm_ops),
609	},
610};
611
612module_platform_driver(rcar_gyroadc_driver);
613
614MODULE_AUTHOR("Marek Vasut <marek.vasut@gmail.com>");
615MODULE_DESCRIPTION("Renesas R-Car GyroADC driver");
616MODULE_LICENSE("GPL");
617