xref: /openbmc/linux/drivers/iio/adc/rcar-gyroadc.c (revision 42d35bf6)
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 
59 enum rcar_gyroadc_model {
60 	RCAR_GYROADC_MODEL_DEFAULT,
61 	RCAR_GYROADC_MODEL_R8A7792,
62 };
63 
64 struct 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 
rcar_gyroadc_hw_init(struct rcar_gyroadc * priv)75 static 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 
rcar_gyroadc_hw_start(struct rcar_gyroadc * priv)103 static 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 
rcar_gyroadc_hw_stop(struct rcar_gyroadc * priv)118 static 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 
133 static 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 
140 static 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 
151 static 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 
rcar_gyroadc_set_power(struct rcar_gyroadc * priv,bool on)162 static 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 
rcar_gyroadc_read_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int * val,int * val2,long mask)174 static 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 
rcar_gyroadc_reg_access(struct iio_dev * indio_dev,unsigned int reg,unsigned int writeval,unsigned int * readval)240 static 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 
265 static 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 
270 static 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 
284 MODULE_DEVICE_TABLE(of, rcar_gyroadc_match);
285 
286 static 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 
rcar_gyroadc_parse_subdevs(struct iio_dev * indio_dev)314 static 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 
437 err_e_inval:
438 	ret = -EINVAL;
439 err_of_node_put:
440 	of_node_put(child);
441 	return ret;
442 }
443 
rcar_gyroadc_deinit_supplies(struct iio_dev * indio_dev)444 static 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 
rcar_gyroadc_init_supplies(struct iio_dev * indio_dev)457 static 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 
478 err:
479 	rcar_gyroadc_deinit_supplies(indio_dev);
480 	return ret;
481 }
482 
rcar_gyroadc_probe(struct platform_device * pdev)483 static 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 
549 err_iio_device_register:
550 	rcar_gyroadc_hw_stop(priv);
551 	pm_runtime_put_sync(dev);
552 err_power_up:
553 	pm_runtime_disable(dev);
554 	pm_runtime_set_suspended(dev);
555 	clk_disable_unprepare(priv->clk);
556 err_clk_if_enable:
557 	rcar_gyroadc_deinit_supplies(indio_dev);
558 
559 	return ret;
560 }
561 
rcar_gyroadc_remove(struct platform_device * pdev)562 static int 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 	return 0;
578 }
579 
rcar_gyroadc_suspend(struct device * dev)580 static int rcar_gyroadc_suspend(struct device *dev)
581 {
582 	struct iio_dev *indio_dev = dev_get_drvdata(dev);
583 	struct rcar_gyroadc *priv = iio_priv(indio_dev);
584 
585 	rcar_gyroadc_hw_stop(priv);
586 
587 	return 0;
588 }
589 
rcar_gyroadc_resume(struct device * dev)590 static int rcar_gyroadc_resume(struct device *dev)
591 {
592 	struct iio_dev *indio_dev = dev_get_drvdata(dev);
593 	struct rcar_gyroadc *priv = iio_priv(indio_dev);
594 
595 	rcar_gyroadc_hw_start(priv);
596 
597 	return 0;
598 }
599 
600 static const struct dev_pm_ops rcar_gyroadc_pm_ops = {
601 	RUNTIME_PM_OPS(rcar_gyroadc_suspend, rcar_gyroadc_resume, NULL)
602 };
603 
604 static struct platform_driver rcar_gyroadc_driver = {
605 	.probe          = rcar_gyroadc_probe,
606 	.remove         = rcar_gyroadc_remove,
607 	.driver         = {
608 		.name		= DRIVER_NAME,
609 		.of_match_table	= rcar_gyroadc_match,
610 		.pm		= pm_ptr(&rcar_gyroadc_pm_ops),
611 	},
612 };
613 
614 module_platform_driver(rcar_gyroadc_driver);
615 
616 MODULE_AUTHOR("Marek Vasut <marek.vasut@gmail.com>");
617 MODULE_DESCRIPTION("Renesas R-Car GyroADC driver");
618 MODULE_LICENSE("GPL");
619