GNU Linux-libre 4.9.282-gnu1
[releases.git] / drivers / iio / adc / cc10001_adc.c
1 /*
2  * Copyright (c) 2014-2015 Imagination Technologies Ltd.
3  *
4  * This program is free software; you can redistribute it and/or modify it
5  * under the terms of the GNU General Public License version 2 as published by
6  * the Free Software Foundation.
7  *
8  */
9
10 #include <linux/clk.h>
11 #include <linux/delay.h>
12 #include <linux/err.h>
13 #include <linux/kernel.h>
14 #include <linux/module.h>
15 #include <linux/of.h>
16 #include <linux/of_device.h>
17 #include <linux/platform_device.h>
18 #include <linux/regulator/consumer.h>
19 #include <linux/slab.h>
20
21 #include <linux/iio/buffer.h>
22 #include <linux/iio/iio.h>
23 #include <linux/iio/sysfs.h>
24 #include <linux/iio/trigger.h>
25 #include <linux/iio/trigger_consumer.h>
26 #include <linux/iio/triggered_buffer.h>
27
28 /* Registers */
29 #define CC10001_ADC_CONFIG              0x00
30 #define CC10001_ADC_START_CONV          BIT(4)
31 #define CC10001_ADC_MODE_SINGLE_CONV    BIT(5)
32
33 #define CC10001_ADC_DDATA_OUT           0x04
34 #define CC10001_ADC_EOC                 0x08
35 #define CC10001_ADC_EOC_SET             BIT(0)
36
37 #define CC10001_ADC_CHSEL_SAMPLED       0x0c
38 #define CC10001_ADC_POWER_DOWN          0x10
39 #define CC10001_ADC_POWER_DOWN_SET      BIT(0)
40
41 #define CC10001_ADC_DEBUG               0x14
42 #define CC10001_ADC_DATA_COUNT          0x20
43
44 #define CC10001_ADC_DATA_MASK           GENMASK(9, 0)
45 #define CC10001_ADC_NUM_CHANNELS        8
46 #define CC10001_ADC_CH_MASK             GENMASK(2, 0)
47
48 #define CC10001_INVALID_SAMPLED         0xffff
49 #define CC10001_MAX_POLL_COUNT          20
50
51 /*
52  * As per device specification, wait six clock cycles after power-up to
53  * activate START. Since adding two more clock cycles delay does not
54  * impact the performance too much, we are adding two additional cycles delay
55  * intentionally here.
56  */
57 #define CC10001_WAIT_CYCLES             8
58
59 struct cc10001_adc_device {
60         void __iomem *reg_base;
61         struct clk *adc_clk;
62         struct regulator *reg;
63         u16 *buf;
64
65         bool shared;
66         struct mutex lock;
67         unsigned int start_delay_ns;
68         unsigned int eoc_delay_ns;
69 };
70
71 static inline void cc10001_adc_write_reg(struct cc10001_adc_device *adc_dev,
72                                          u32 reg, u32 val)
73 {
74         writel(val, adc_dev->reg_base + reg);
75 }
76
77 static inline u32 cc10001_adc_read_reg(struct cc10001_adc_device *adc_dev,
78                                        u32 reg)
79 {
80         return readl(adc_dev->reg_base + reg);
81 }
82
83 static void cc10001_adc_power_up(struct cc10001_adc_device *adc_dev)
84 {
85         cc10001_adc_write_reg(adc_dev, CC10001_ADC_POWER_DOWN, 0);
86         ndelay(adc_dev->start_delay_ns);
87 }
88
89 static void cc10001_adc_power_down(struct cc10001_adc_device *adc_dev)
90 {
91         cc10001_adc_write_reg(adc_dev, CC10001_ADC_POWER_DOWN,
92                               CC10001_ADC_POWER_DOWN_SET);
93 }
94
95 static void cc10001_adc_start(struct cc10001_adc_device *adc_dev,
96                               unsigned int channel)
97 {
98         u32 val;
99
100         /* Channel selection and mode of operation */
101         val = (channel & CC10001_ADC_CH_MASK) | CC10001_ADC_MODE_SINGLE_CONV;
102         cc10001_adc_write_reg(adc_dev, CC10001_ADC_CONFIG, val);
103
104         udelay(1);
105         val = cc10001_adc_read_reg(adc_dev, CC10001_ADC_CONFIG);
106         val = val | CC10001_ADC_START_CONV;
107         cc10001_adc_write_reg(adc_dev, CC10001_ADC_CONFIG, val);
108 }
109
110 static u16 cc10001_adc_poll_done(struct iio_dev *indio_dev,
111                                  unsigned int channel,
112                                  unsigned int delay)
113 {
114         struct cc10001_adc_device *adc_dev = iio_priv(indio_dev);
115         unsigned int poll_count = 0;
116
117         while (!(cc10001_adc_read_reg(adc_dev, CC10001_ADC_EOC) &
118                         CC10001_ADC_EOC_SET)) {
119
120                 ndelay(delay);
121                 if (poll_count++ == CC10001_MAX_POLL_COUNT)
122                         return CC10001_INVALID_SAMPLED;
123         }
124
125         poll_count = 0;
126         while ((cc10001_adc_read_reg(adc_dev, CC10001_ADC_CHSEL_SAMPLED) &
127                         CC10001_ADC_CH_MASK) != channel) {
128
129                 ndelay(delay);
130                 if (poll_count++ == CC10001_MAX_POLL_COUNT)
131                         return CC10001_INVALID_SAMPLED;
132         }
133
134         /* Read the 10 bit output register */
135         return cc10001_adc_read_reg(adc_dev, CC10001_ADC_DDATA_OUT) &
136                                CC10001_ADC_DATA_MASK;
137 }
138
139 static irqreturn_t cc10001_adc_trigger_h(int irq, void *p)
140 {
141         struct cc10001_adc_device *adc_dev;
142         struct iio_poll_func *pf = p;
143         struct iio_dev *indio_dev;
144         unsigned int delay_ns;
145         unsigned int channel;
146         unsigned int scan_idx;
147         bool sample_invalid;
148         u16 *data;
149         int i;
150
151         indio_dev = pf->indio_dev;
152         adc_dev = iio_priv(indio_dev);
153         data = adc_dev->buf;
154
155         mutex_lock(&adc_dev->lock);
156
157         if (!adc_dev->shared)
158                 cc10001_adc_power_up(adc_dev);
159
160         /* Calculate delay step for eoc and sampled data */
161         delay_ns = adc_dev->eoc_delay_ns / CC10001_MAX_POLL_COUNT;
162
163         i = 0;
164         sample_invalid = false;
165         for_each_set_bit(scan_idx, indio_dev->active_scan_mask,
166                                   indio_dev->masklength) {
167
168                 channel = indio_dev->channels[scan_idx].channel;
169                 cc10001_adc_start(adc_dev, channel);
170
171                 data[i] = cc10001_adc_poll_done(indio_dev, channel, delay_ns);
172                 if (data[i] == CC10001_INVALID_SAMPLED) {
173                         dev_warn(&indio_dev->dev,
174                                  "invalid sample on channel %d\n", channel);
175                         sample_invalid = true;
176                         goto done;
177                 }
178                 i++;
179         }
180
181 done:
182         if (!adc_dev->shared)
183                 cc10001_adc_power_down(adc_dev);
184
185         mutex_unlock(&adc_dev->lock);
186
187         if (!sample_invalid)
188                 iio_push_to_buffers_with_timestamp(indio_dev, data,
189                                                    iio_get_time_ns(indio_dev));
190         iio_trigger_notify_done(indio_dev->trig);
191
192         return IRQ_HANDLED;
193 }
194
195 static u16 cc10001_adc_read_raw_voltage(struct iio_dev *indio_dev,
196                                         struct iio_chan_spec const *chan)
197 {
198         struct cc10001_adc_device *adc_dev = iio_priv(indio_dev);
199         unsigned int delay_ns;
200         u16 val;
201
202         if (!adc_dev->shared)
203                 cc10001_adc_power_up(adc_dev);
204
205         /* Calculate delay step for eoc and sampled data */
206         delay_ns = adc_dev->eoc_delay_ns / CC10001_MAX_POLL_COUNT;
207
208         cc10001_adc_start(adc_dev, chan->channel);
209
210         val = cc10001_adc_poll_done(indio_dev, chan->channel, delay_ns);
211
212         if (!adc_dev->shared)
213                 cc10001_adc_power_down(adc_dev);
214
215         return val;
216 }
217
218 static int cc10001_adc_read_raw(struct iio_dev *indio_dev,
219                                  struct iio_chan_spec const *chan,
220                                  int *val, int *val2, long mask)
221 {
222         struct cc10001_adc_device *adc_dev = iio_priv(indio_dev);
223         int ret;
224
225         switch (mask) {
226         case IIO_CHAN_INFO_RAW:
227                 if (iio_buffer_enabled(indio_dev))
228                         return -EBUSY;
229                 mutex_lock(&adc_dev->lock);
230                 *val = cc10001_adc_read_raw_voltage(indio_dev, chan);
231                 mutex_unlock(&adc_dev->lock);
232
233                 if (*val == CC10001_INVALID_SAMPLED)
234                         return -EIO;
235                 return IIO_VAL_INT;
236
237         case IIO_CHAN_INFO_SCALE:
238                 ret = regulator_get_voltage(adc_dev->reg);
239                 if (ret < 0)
240                         return ret;
241
242                 *val = ret / 1000;
243                 *val2 = chan->scan_type.realbits;
244                 return IIO_VAL_FRACTIONAL_LOG2;
245
246         default:
247                 return -EINVAL;
248         }
249 }
250
251 static int cc10001_update_scan_mode(struct iio_dev *indio_dev,
252                                     const unsigned long *scan_mask)
253 {
254         struct cc10001_adc_device *adc_dev = iio_priv(indio_dev);
255
256         kfree(adc_dev->buf);
257         adc_dev->buf = kmalloc(indio_dev->scan_bytes, GFP_KERNEL);
258         if (!adc_dev->buf)
259                 return -ENOMEM;
260
261         return 0;
262 }
263
264 static const struct iio_info cc10001_adc_info = {
265         .driver_module = THIS_MODULE,
266         .read_raw = &cc10001_adc_read_raw,
267         .update_scan_mode = &cc10001_update_scan_mode,
268 };
269
270 static int cc10001_adc_channel_init(struct iio_dev *indio_dev,
271                                     unsigned long channel_map)
272 {
273         struct iio_chan_spec *chan_array, *timestamp;
274         unsigned int bit, idx = 0;
275
276         indio_dev->num_channels = bitmap_weight(&channel_map,
277                                                 CC10001_ADC_NUM_CHANNELS) + 1;
278
279         chan_array = devm_kcalloc(&indio_dev->dev, indio_dev->num_channels,
280                                   sizeof(struct iio_chan_spec),
281                                   GFP_KERNEL);
282         if (!chan_array)
283                 return -ENOMEM;
284
285         for_each_set_bit(bit, &channel_map, CC10001_ADC_NUM_CHANNELS) {
286                 struct iio_chan_spec *chan = &chan_array[idx];
287
288                 chan->type = IIO_VOLTAGE;
289                 chan->indexed = 1;
290                 chan->channel = bit;
291                 chan->scan_index = idx;
292                 chan->scan_type.sign = 'u';
293                 chan->scan_type.realbits = 10;
294                 chan->scan_type.storagebits = 16;
295                 chan->info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE);
296                 chan->info_mask_separate = BIT(IIO_CHAN_INFO_RAW);
297                 idx++;
298         }
299
300         timestamp = &chan_array[idx];
301         timestamp->type = IIO_TIMESTAMP;
302         timestamp->channel = -1;
303         timestamp->scan_index = idx;
304         timestamp->scan_type.sign = 's';
305         timestamp->scan_type.realbits = 64;
306         timestamp->scan_type.storagebits = 64;
307
308         indio_dev->channels = chan_array;
309
310         return 0;
311 }
312
313 static int cc10001_adc_probe(struct platform_device *pdev)
314 {
315         struct device_node *node = pdev->dev.of_node;
316         struct cc10001_adc_device *adc_dev;
317         unsigned long adc_clk_rate;
318         struct resource *res;
319         struct iio_dev *indio_dev;
320         unsigned long channel_map;
321         int ret;
322
323         indio_dev = devm_iio_device_alloc(&pdev->dev, sizeof(*adc_dev));
324         if (indio_dev == NULL)
325                 return -ENOMEM;
326
327         adc_dev = iio_priv(indio_dev);
328
329         channel_map = GENMASK(CC10001_ADC_NUM_CHANNELS - 1, 0);
330         if (!of_property_read_u32(node, "adc-reserved-channels", &ret)) {
331                 adc_dev->shared = true;
332                 channel_map &= ~ret;
333         }
334
335         adc_dev->reg = devm_regulator_get(&pdev->dev, "vref");
336         if (IS_ERR(adc_dev->reg))
337                 return PTR_ERR(adc_dev->reg);
338
339         ret = regulator_enable(adc_dev->reg);
340         if (ret)
341                 return ret;
342
343         indio_dev->dev.parent = &pdev->dev;
344         indio_dev->name = dev_name(&pdev->dev);
345         indio_dev->info = &cc10001_adc_info;
346         indio_dev->modes = INDIO_DIRECT_MODE;
347
348         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
349         adc_dev->reg_base = devm_ioremap_resource(&pdev->dev, res);
350         if (IS_ERR(adc_dev->reg_base)) {
351                 ret = PTR_ERR(adc_dev->reg_base);
352                 goto err_disable_reg;
353         }
354
355         adc_dev->adc_clk = devm_clk_get(&pdev->dev, "adc");
356         if (IS_ERR(adc_dev->adc_clk)) {
357                 dev_err(&pdev->dev, "failed to get the clock\n");
358                 ret = PTR_ERR(adc_dev->adc_clk);
359                 goto err_disable_reg;
360         }
361
362         ret = clk_prepare_enable(adc_dev->adc_clk);
363         if (ret) {
364                 dev_err(&pdev->dev, "failed to enable the clock\n");
365                 goto err_disable_reg;
366         }
367
368         adc_clk_rate = clk_get_rate(adc_dev->adc_clk);
369         if (!adc_clk_rate) {
370                 ret = -EINVAL;
371                 dev_err(&pdev->dev, "null clock rate!\n");
372                 goto err_disable_clk;
373         }
374
375         adc_dev->eoc_delay_ns = NSEC_PER_SEC / adc_clk_rate;
376         adc_dev->start_delay_ns = adc_dev->eoc_delay_ns * CC10001_WAIT_CYCLES;
377
378         /*
379          * There is only one register to power-up/power-down the AUX ADC.
380          * If the ADC is shared among multiple CPUs, always power it up here.
381          * If the ADC is used only by the MIPS, power-up/power-down at runtime.
382          */
383         if (adc_dev->shared)
384                 cc10001_adc_power_up(adc_dev);
385
386         /* Setup the ADC channels available on the device */
387         ret = cc10001_adc_channel_init(indio_dev, channel_map);
388         if (ret < 0)
389                 goto err_disable_clk;
390
391         mutex_init(&adc_dev->lock);
392
393         ret = iio_triggered_buffer_setup(indio_dev, NULL,
394                                          &cc10001_adc_trigger_h, NULL);
395         if (ret < 0)
396                 goto err_disable_clk;
397
398         ret = iio_device_register(indio_dev);
399         if (ret < 0)
400                 goto err_cleanup_buffer;
401
402         platform_set_drvdata(pdev, indio_dev);
403
404         return 0;
405
406 err_cleanup_buffer:
407         iio_triggered_buffer_cleanup(indio_dev);
408 err_disable_clk:
409         clk_disable_unprepare(adc_dev->adc_clk);
410 err_disable_reg:
411         regulator_disable(adc_dev->reg);
412         return ret;
413 }
414
415 static int cc10001_adc_remove(struct platform_device *pdev)
416 {
417         struct iio_dev *indio_dev = platform_get_drvdata(pdev);
418         struct cc10001_adc_device *adc_dev = iio_priv(indio_dev);
419
420         cc10001_adc_power_down(adc_dev);
421         iio_device_unregister(indio_dev);
422         iio_triggered_buffer_cleanup(indio_dev);
423         clk_disable_unprepare(adc_dev->adc_clk);
424         regulator_disable(adc_dev->reg);
425
426         return 0;
427 }
428
429 static const struct of_device_id cc10001_adc_dt_ids[] = {
430         { .compatible = "cosmic,10001-adc", },
431         { }
432 };
433 MODULE_DEVICE_TABLE(of, cc10001_adc_dt_ids);
434
435 static struct platform_driver cc10001_adc_driver = {
436         .driver = {
437                 .name   = "cc10001-adc",
438                 .of_match_table = cc10001_adc_dt_ids,
439         },
440         .probe  = cc10001_adc_probe,
441         .remove = cc10001_adc_remove,
442 };
443 module_platform_driver(cc10001_adc_driver);
444
445 MODULE_AUTHOR("Phani Movva <Phani.Movva@imgtec.com>");
446 MODULE_DESCRIPTION("Cosmic Circuits ADC driver");
447 MODULE_LICENSE("GPL v2");