Commit | Line | Data |
---|---|---|
efeb87d8 | 1 | // SPDX-License-Identifier: GPL-2.0+ |
059c53b3 MV |
2 | /* |
3 | * Renesas R-Car GyroADC driver | |
4 | * | |
5 | * Copyright 2016 Marek Vasut <marek.vasut@gmail.com> | |
059c53b3 MV |
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; | |
1a732f42 | 67 | struct clk *clk; |
059c53b3 MV |
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 | { | |
1a732f42 | 77 | const unsigned long clk_mhz = clk_get_rate(priv->clk) / 1000000; |
059c53b3 MV |
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 | ||
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 | ||
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 | ||
162 | static int rcar_gyroadc_set_power(struct rcar_gyroadc *priv, bool on) | |
163 | { | |
164 | struct device *dev = priv->dev; | |
059c53b3 MV |
165 | |
166 | if (on) { | |
db9c6c2e | 167 | return pm_runtime_resume_and_get(dev); |
059c53b3 MV |
168 | } else { |
169 | pm_runtime_mark_last_busy(dev); | |
db9c6c2e | 170 | return pm_runtime_put_autosuspend(dev); |
059c53b3 | 171 | } |
059c53b3 MV |
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, 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 | ||
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 = { | |
059c53b3 MV |
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[] = { | |
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; | |
17fa2dcb | 324 | unsigned int adcmode = -1, childmode; |
059c53b3 MV |
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) { | |
1fc378fa RH |
332 | dev_err(dev, "Ignoring unsupported ADC \"%pOFn\".", |
333 | child); | |
059c53b3 MV |
334 | continue; |
335 | } | |
336 | ||
2a357345 | 337 | childmode = (uintptr_t)of_id->data; |
059c53b3 MV |
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; | |
17fa2dcb | 354 | default: |
da4410d4 | 355 | goto err_e_inval; |
059c53b3 MV |
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", ®); | |
368 | if (ret) { | |
369 | dev_err(dev, | |
1fc378fa RH |
370 | "Failed to get child reg property of ADC \"%pOFn\".\n", |
371 | child); | |
da4410d4 | 372 | goto err_of_node_put; |
059c53b3 MV |
373 | } |
374 | ||
375 | /* Channel number is too high. */ | |
376 | if (reg >= num_channels) { | |
377 | dev_err(dev, | |
1fc378fa RH |
378 | "Only %i channels supported with %pOFn, but reg = <%i>.\n", |
379 | num_channels, child, reg); | |
da4410d4 | 380 | goto err_e_inval; |
059c53b3 MV |
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); | |
da4410d4 | 389 | goto err_e_inval; |
059c53b3 MV |
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); | |
da4410d4 TJ |
399 | ret = PTR_ERR(vref); |
400 | goto err_of_node_put; | |
059c53b3 MV |
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 | */ | |
da4410d4 TJ |
424 | if (childmode == RCAR_GYROADC_MODE_SELECT_1_MB88101A) { |
425 | of_node_put(child); | |
059c53b3 | 426 | break; |
da4410d4 | 427 | } |
059c53b3 MV |
428 | } |
429 | ||
430 | if (first) { | |
431 | dev_err(dev, "No valid ADC channels found, aborting.\n"); | |
432 | return -EINVAL; | |
433 | } | |
434 | ||
435 | return 0; | |
da4410d4 TJ |
436 | |
437 | err_e_inval: | |
438 | ret = -EINVAL; | |
439 | err_of_node_put: | |
440 | of_node_put(child); | |
441 | return ret; | |
059c53b3 MV |
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(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(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 | { | |
059c53b3 MV |
485 | struct device *dev = &pdev->dev; |
486 | struct rcar_gyroadc *priv; | |
487 | struct iio_dev *indio_dev; | |
059c53b3 MV |
488 | int ret; |
489 | ||
490 | indio_dev = devm_iio_device_alloc(dev, sizeof(*priv)); | |
5c25531d | 491 | if (!indio_dev) |
059c53b3 | 492 | return -ENOMEM; |
059c53b3 MV |
493 | |
494 | priv = iio_priv(indio_dev); | |
495 | priv->dev = dev; | |
496 | ||
6c78cc9c | 497 | priv->regs = devm_platform_ioremap_resource(pdev, 0); |
059c53b3 MV |
498 | if (IS_ERR(priv->regs)) |
499 | return PTR_ERR(priv->regs); | |
500 | ||
1a732f42 | 501 | priv->clk = devm_clk_get(dev, "fck"); |
6d2710ce KK |
502 | if (IS_ERR(priv->clk)) |
503 | return dev_err_probe(dev, PTR_ERR(priv->clk), | |
504 | "Failed to get IF clock\n"); | |
059c53b3 MV |
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 | ||
835122a3 | 514 | priv->model = (uintptr_t)of_device_get_match_data(&pdev->dev); |
059c53b3 MV |
515 | |
516 | platform_set_drvdata(pdev, indio_dev); | |
517 | ||
518 | indio_dev->name = DRIVER_NAME; | |
059c53b3 MV |
519 | indio_dev->info = &rcar_gyroadc_iio_info; |
520 | indio_dev->modes = INDIO_DIRECT_MODE; | |
521 | ||
1a732f42 | 522 | ret = clk_prepare_enable(priv->clk); |
059c53b3 MV |
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 | ||
db9c6c2e JC |
532 | ret = pm_runtime_resume_and_get(dev); |
533 | if (ret) | |
534 | goto err_power_up; | |
535 | ||
059c53b3 MV |
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); | |
db9c6c2e | 552 | err_power_up: |
059c53b3 MV |
553 | pm_runtime_disable(dev); |
554 | pm_runtime_set_suspended(dev); | |
1a732f42 | 555 | clk_disable_unprepare(priv->clk); |
059c53b3 MV |
556 | err_clk_if_enable: |
557 | rcar_gyroadc_deinit_supplies(indio_dev); | |
558 | ||
559 | return ret; | |
560 | } | |
561 | ||
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); | |
1a732f42 | 574 | clk_disable_unprepare(priv->clk); |
059c53b3 MV |
575 | rcar_gyroadc_deinit_supplies(indio_dev); |
576 | ||
577 | return 0; | |
578 | } | |
579 | ||
059c53b3 MV |
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 | ||
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 | } | |
059c53b3 MV |
599 | |
600 | static const struct dev_pm_ops rcar_gyroadc_pm_ops = { | |
25d87707 | 601 | RUNTIME_PM_OPS(rcar_gyroadc_suspend, rcar_gyroadc_resume, NULL) |
059c53b3 MV |
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, | |
25d87707 | 610 | .pm = pm_ptr(&rcar_gyroadc_pm_ops), |
059c53b3 MV |
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"); |