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 | |
75 | static void rcar_gyroadc_hw_init(struct rcar_gyroadc *priv) |
76 | { |
77 | const unsigned long clk_mhz = clk_get_rate(clk: 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(val: 0, addr: priv->regs + RCAR_GYROADC_START_STOP); |
92 | |
93 | /* Disable IRQ on V2H. */ |
94 | if (priv->model == RCAR_GYROADC_MODEL_R8A7792) |
95 | writel(val: 0, addr: priv->regs + RCAR_GYROADC_INTENR); |
96 | |
97 | /* Set mode and timing. */ |
98 | writel(val: priv->mode, addr: priv->regs + RCAR_GYROADC_MODE_SELECT); |
99 | writel(val: clk_len, addr: priv->regs + RCAR_GYROADC_CLOCK_LENGTH); |
100 | writel(val: clk_mhz * 1250, addr: priv->regs + RCAR_GYROADC_1_25MS_LENGTH); |
101 | } |
102 | |
103 | static void rcar_gyroadc_hw_start(struct rcar_gyroadc *priv) |
104 | { |
105 | /* Start sampling. */ |
106 | writel(RCAR_GYROADC_START_STOP_START, |
107 | addr: 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 | |
118 | static void rcar_gyroadc_hw_stop(struct rcar_gyroadc *priv) |
119 | { |
120 | /* Stop the GyroADC. */ |
121 | writel(val: 0, addr: 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 | |
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 | |
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, on: true); |
207 | if (ret < 0) { |
208 | iio_device_release_direct_mode(indio_dev); |
209 | return ret; |
210 | } |
211 | |
212 | *val = readl(addr: priv->regs + datareg); |
213 | *val &= BIT(priv->sample_width) - 1; |
214 | |
215 | ret = rcar_gyroadc_set_power(priv, on: 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(regulator: 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 | |
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(addr: 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 | |
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(matches: rcar_gyroadc_child_match, node: 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(np: child, propname: "reg" , out_value: ®); |
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, id: "vref" ); |
395 | dev->of_node = np; |
396 | if (IS_ERR(ptr: vref)) { |
397 | dev_dbg(dev, "Channel %i 'vref' supply not connected.\n" , |
398 | reg); |
399 | ret = PTR_ERR(ptr: 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(node: 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(node: child); |
441 | return ret; |
442 | } |
443 | |
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(regulator: priv->vref[i]); |
454 | } |
455 | } |
456 | |
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(regulator: 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 | |
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(parent: dev, sizeof_priv: 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, index: 0); |
498 | if (IS_ERR(ptr: priv->regs)) |
499 | return PTR_ERR(ptr: priv->regs); |
500 | |
501 | priv->clk = devm_clk_get(dev, id: "fck" ); |
502 | if (IS_ERR(ptr: priv->clk)) |
503 | return dev_err_probe(dev, err: PTR_ERR(ptr: priv->clk), |
504 | fmt: "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(dev: &pdev->dev); |
515 | |
516 | platform_set_drvdata(pdev, data: 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(clk: 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(clk: priv->clk); |
556 | err_clk_if_enable: |
557 | rcar_gyroadc_deinit_supplies(indio_dev); |
558 | |
559 | return ret; |
560 | } |
561 | |
562 | static 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(clk: priv->clk); |
575 | rcar_gyroadc_deinit_supplies(indio_dev); |
576 | } |
577 | |
578 | static 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 | |
588 | static 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 | |
598 | static const struct dev_pm_ops rcar_gyroadc_pm_ops = { |
599 | RUNTIME_PM_OPS(rcar_gyroadc_suspend, rcar_gyroadc_resume, NULL) |
600 | }; |
601 | |
602 | static 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 | |
612 | module_platform_driver(rcar_gyroadc_driver); |
613 | |
614 | MODULE_AUTHOR("Marek Vasut <marek.vasut@gmail.com>" ); |
615 | MODULE_DESCRIPTION("Renesas R-Car GyroADC driver" ); |
616 | MODULE_LICENSE("GPL" ); |
617 | |