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 regulator *vref;
322 unsigned int reg;
323 unsigned int adcmode = -1, childmode;
324 unsigned int sample_width;
325 unsigned int num_channels;
326 int ret, first = 1;
327
328 for_each_available_child_of_node_scoped(np, child) {
329 of_id = of_match_node(rcar_gyroadc_child_match, child);
330 if (!of_id) {
331 dev_err(dev, "Ignoring unsupported ADC \"%pOFn\".",
332 child);
333 continue;
334 }
335
336 childmode = (uintptr_t)of_id->data;
337 switch (childmode) {
338 case RCAR_GYROADC_MODE_SELECT_1_MB88101A:
339 sample_width = 12;
340 channels = rcar_gyroadc_iio_channels_1;
341 num_channels = ARRAY_SIZE(rcar_gyroadc_iio_channels_1);
342 break;
343 case RCAR_GYROADC_MODE_SELECT_2_ADCS7476:
344 sample_width = 15;
345 channels = rcar_gyroadc_iio_channels_2;
346 num_channels = ARRAY_SIZE(rcar_gyroadc_iio_channels_2);
347 break;
348 case RCAR_GYROADC_MODE_SELECT_3_MAX1162:
349 sample_width = 16;
350 channels = rcar_gyroadc_iio_channels_3;
351 num_channels = ARRAY_SIZE(rcar_gyroadc_iio_channels_3);
352 break;
353 default:
354 return -EINVAL;
355 }
356
357 /*
358 * MB88101 is special in that it's only a single chip taking
359 * up all the CHS lines. Thus, the DT binding is also special
360 * and has no reg property. If we run into such ADC, handle
361 * it here.
362 */
363 if (childmode == RCAR_GYROADC_MODE_SELECT_1_MB88101A) {
364 reg = 0;
365 } else {
366 ret = of_property_read_u32(child, "reg", ®);
367 if (ret) {
368 dev_err(dev,
369 "Failed to get child reg property of ADC \"%pOFn\".\n",
370 child);
371 return ret;
372 }
373
374 /* Channel number is too high. */
375 if (reg >= num_channels) {
376 dev_err(dev,
377 "Only %i channels supported with %pOFn, but reg = <%i>.\n",
378 num_channels, child, reg);
379 return -EINVAL;
380 }
381 }
382
383 /* Child node selected different mode than the rest. */
384 if (!first && (adcmode != childmode)) {
385 dev_err(dev,
386 "Channel %i uses different ADC mode than the rest.\n",
387 reg);
388 return -EINVAL;
389 }
390
391 /* Channel is valid, grab the regulator. */
392 dev->of_node = child;
393 vref = devm_regulator_get(dev, "vref");
394 dev->of_node = np;
395 if (IS_ERR(vref)) {
396 dev_dbg(dev, "Channel %i 'vref' supply not connected.\n",
397 reg);
398 return PTR_ERR(vref);
399 }
400
401 priv->vref[reg] = vref;
402
403 if (!first)
404 continue;
405
406 /* First child node which passed sanity tests. */
407 adcmode = childmode;
408 first = 0;
409
410 priv->num_channels = num_channels;
411 priv->mode = childmode;
412 priv->sample_width = sample_width;
413
414 indio_dev->channels = channels;
415 indio_dev->num_channels = num_channels;
416
417 /*
418 * MB88101 is special and we only have one such device
419 * attached to the GyroADC at a time, so if we found it,
420 * we can stop parsing here.
421 */
422 if (childmode == RCAR_GYROADC_MODE_SELECT_1_MB88101A) {
423 break;
424 }
425 }
426
427 if (first) {
428 dev_err(dev, "No valid ADC channels found, aborting.\n");
429 return -EINVAL;
430 }
431
432 return 0;
433 }
434
rcar_gyroadc_deinit_supplies(struct iio_dev * indio_dev)435 static void rcar_gyroadc_deinit_supplies(struct iio_dev *indio_dev)
436 {
437 struct rcar_gyroadc *priv = iio_priv(indio_dev);
438 unsigned int i;
439
440 for (i = 0; i < priv->num_channels; i++) {
441 if (!priv->vref[i])
442 continue;
443
444 regulator_disable(priv->vref[i]);
445 }
446 }
447
rcar_gyroadc_init_supplies(struct iio_dev * indio_dev)448 static int rcar_gyroadc_init_supplies(struct iio_dev *indio_dev)
449 {
450 struct rcar_gyroadc *priv = iio_priv(indio_dev);
451 struct device *dev = priv->dev;
452 unsigned int i;
453 int ret;
454
455 for (i = 0; i < priv->num_channels; i++) {
456 if (!priv->vref[i])
457 continue;
458
459 ret = regulator_enable(priv->vref[i]);
460 if (ret) {
461 dev_err(dev, "Failed to enable regulator %i (ret=%i)\n",
462 i, ret);
463 goto err;
464 }
465 }
466
467 return 0;
468
469 err:
470 rcar_gyroadc_deinit_supplies(indio_dev);
471 return ret;
472 }
473
rcar_gyroadc_probe(struct platform_device * pdev)474 static int rcar_gyroadc_probe(struct platform_device *pdev)
475 {
476 struct device *dev = &pdev->dev;
477 struct rcar_gyroadc *priv;
478 struct iio_dev *indio_dev;
479 int ret;
480
481 indio_dev = devm_iio_device_alloc(dev, sizeof(*priv));
482 if (!indio_dev)
483 return -ENOMEM;
484
485 priv = iio_priv(indio_dev);
486 priv->dev = dev;
487
488 priv->regs = devm_platform_ioremap_resource(pdev, 0);
489 if (IS_ERR(priv->regs))
490 return PTR_ERR(priv->regs);
491
492 priv->clk = devm_clk_get(dev, "fck");
493 if (IS_ERR(priv->clk))
494 return dev_err_probe(dev, PTR_ERR(priv->clk),
495 "Failed to get IF clock\n");
496
497 ret = rcar_gyroadc_parse_subdevs(indio_dev);
498 if (ret)
499 return ret;
500
501 ret = rcar_gyroadc_init_supplies(indio_dev);
502 if (ret)
503 return ret;
504
505 priv->model = (uintptr_t)of_device_get_match_data(&pdev->dev);
506
507 platform_set_drvdata(pdev, indio_dev);
508
509 indio_dev->name = DRIVER_NAME;
510 indio_dev->info = &rcar_gyroadc_iio_info;
511 indio_dev->modes = INDIO_DIRECT_MODE;
512
513 ret = clk_prepare_enable(priv->clk);
514 if (ret) {
515 dev_err(dev, "Could not prepare or enable the IF clock.\n");
516 goto err_clk_if_enable;
517 }
518
519 pm_runtime_set_autosuspend_delay(dev, RCAR_GYROADC_RUNTIME_PM_DELAY_MS);
520 pm_runtime_use_autosuspend(dev);
521 pm_runtime_enable(dev);
522
523 ret = pm_runtime_resume_and_get(dev);
524 if (ret)
525 goto err_power_up;
526
527 rcar_gyroadc_hw_init(priv);
528 rcar_gyroadc_hw_start(priv);
529
530 ret = iio_device_register(indio_dev);
531 if (ret) {
532 dev_err(dev, "Couldn't register IIO device.\n");
533 goto err_iio_device_register;
534 }
535
536 pm_runtime_put_sync(dev);
537
538 return 0;
539
540 err_iio_device_register:
541 rcar_gyroadc_hw_stop(priv);
542 pm_runtime_put_sync(dev);
543 err_power_up:
544 pm_runtime_disable(dev);
545 pm_runtime_set_suspended(dev);
546 clk_disable_unprepare(priv->clk);
547 err_clk_if_enable:
548 rcar_gyroadc_deinit_supplies(indio_dev);
549
550 return ret;
551 }
552
rcar_gyroadc_remove(struct platform_device * pdev)553 static void rcar_gyroadc_remove(struct platform_device *pdev)
554 {
555 struct iio_dev *indio_dev = platform_get_drvdata(pdev);
556 struct rcar_gyroadc *priv = iio_priv(indio_dev);
557 struct device *dev = priv->dev;
558
559 iio_device_unregister(indio_dev);
560 pm_runtime_get_sync(dev);
561 rcar_gyroadc_hw_stop(priv);
562 pm_runtime_put_sync(dev);
563 pm_runtime_disable(dev);
564 pm_runtime_set_suspended(dev);
565 clk_disable_unprepare(priv->clk);
566 rcar_gyroadc_deinit_supplies(indio_dev);
567 }
568
rcar_gyroadc_suspend(struct device * dev)569 static int rcar_gyroadc_suspend(struct device *dev)
570 {
571 struct iio_dev *indio_dev = dev_get_drvdata(dev);
572 struct rcar_gyroadc *priv = iio_priv(indio_dev);
573
574 rcar_gyroadc_hw_stop(priv);
575
576 return 0;
577 }
578
rcar_gyroadc_resume(struct device * dev)579 static int rcar_gyroadc_resume(struct device *dev)
580 {
581 struct iio_dev *indio_dev = dev_get_drvdata(dev);
582 struct rcar_gyroadc *priv = iio_priv(indio_dev);
583
584 rcar_gyroadc_hw_start(priv);
585
586 return 0;
587 }
588
589 static const struct dev_pm_ops rcar_gyroadc_pm_ops = {
590 RUNTIME_PM_OPS(rcar_gyroadc_suspend, rcar_gyroadc_resume, NULL)
591 };
592
593 static struct platform_driver rcar_gyroadc_driver = {
594 .probe = rcar_gyroadc_probe,
595 .remove_new = rcar_gyroadc_remove,
596 .driver = {
597 .name = DRIVER_NAME,
598 .of_match_table = rcar_gyroadc_match,
599 .pm = pm_ptr(&rcar_gyroadc_pm_ops),
600 },
601 };
602
603 module_platform_driver(rcar_gyroadc_driver);
604
605 MODULE_AUTHOR("Marek Vasut <marek.vasut@gmail.com>");
606 MODULE_DESCRIPTION("Renesas R-Car GyroADC driver");
607 MODULE_LICENSE("GPL");
608