4 * Copyright (C) 2012 Texas Instruments Incorporated - http://www.ti.com/
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License as
8 * published by the Free Software Foundation version 2.
10 * This program is distributed "as is" WITHOUT ANY WARRANTY of any
11 * kind, whether express or implied; without even the implied warranty
12 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
16 #include <linux/init.h>
17 #include <linux/kernel.h>
18 #include <linux/err.h>
19 #include <linux/module.h>
20 #include <linux/slab.h>
21 #include <linux/interrupt.h>
22 #include <linux/platform_device.h>
24 #include <linux/iio/iio.h>
26 #include <linux/of_device.h>
27 #include <linux/iio/machine.h>
28 #include <linux/iio/driver.h>
30 #include <linux/mfd/ti_am335x_tscadc.h>
31 #include <linux/iio/buffer.h>
32 #include <linux/iio/kfifo_buf.h>
35 struct ti_tscadc_dev
*mfd_tscadc
;
39 int buffer_en_ch_steps
;
43 static unsigned int tiadc_readl(struct tiadc_device
*adc
, unsigned int reg
)
45 return readl(adc
->mfd_tscadc
->tscadc_base
+ reg
);
48 static void tiadc_writel(struct tiadc_device
*adc
, unsigned int reg
,
51 writel(val
, adc
->mfd_tscadc
->tscadc_base
+ reg
);
54 static u32
get_adc_step_mask(struct tiadc_device
*adc_dev
)
58 step_en
= ((1 << adc_dev
->channels
) - 1);
59 step_en
<<= TOTAL_STEPS
- adc_dev
->channels
+ 1;
63 static u32
get_adc_step_bit(struct tiadc_device
*adc_dev
, int chan
)
65 return 1 << adc_dev
->channel_step
[chan
];
68 static void tiadc_step_config(struct iio_dev
*indio_dev
)
70 struct tiadc_device
*adc_dev
= iio_priv(indio_dev
);
71 unsigned int stepconfig
;
75 * There are 16 configurable steps and 8 analog input
76 * lines available which are shared between Touchscreen and ADC.
78 * Steps backwards i.e. from 16 towards 0 are used by ADC
79 * depending on number of input lines needed.
80 * Channel would represent which analog input
81 * needs to be given to ADC to digitalize data.
84 steps
= TOTAL_STEPS
- adc_dev
->channels
;
85 if (iio_buffer_enabled(indio_dev
))
86 stepconfig
= STEPCONFIG_AVG_16
| STEPCONFIG_FIFO1
87 | STEPCONFIG_MODE_SWCNT
;
89 stepconfig
= STEPCONFIG_AVG_16
| STEPCONFIG_FIFO1
;
91 for (i
= 0; i
< adc_dev
->channels
; i
++) {
94 chan
= adc_dev
->channel_line
[i
];
95 tiadc_writel(adc_dev
, REG_STEPCONFIG(steps
),
96 stepconfig
| STEPCONFIG_INP(chan
));
97 tiadc_writel(adc_dev
, REG_STEPDELAY(steps
),
99 adc_dev
->channel_step
[i
] = steps
;
104 static irqreturn_t
tiadc_irq_h(int irq
, void *private)
106 struct iio_dev
*indio_dev
= private;
107 struct tiadc_device
*adc_dev
= iio_priv(indio_dev
);
108 unsigned int status
, config
;
109 status
= tiadc_readl(adc_dev
, REG_IRQSTATUS
);
112 * ADC and touchscreen share the IRQ line.
113 * FIFO0 interrupts are used by TSC. Handle FIFO1 IRQs here only
115 if (status
& IRQENB_FIFO1OVRRUN
) {
116 /* FIFO Overrun. Clear flag. Disable/Enable ADC to recover */
117 config
= tiadc_readl(adc_dev
, REG_CTRL
);
118 config
&= ~(CNTRLREG_TSCSSENB
);
119 tiadc_writel(adc_dev
, REG_CTRL
, config
);
120 tiadc_writel(adc_dev
, REG_IRQSTATUS
, IRQENB_FIFO1OVRRUN
121 | IRQENB_FIFO1UNDRFLW
| IRQENB_FIFO1THRES
);
122 tiadc_writel(adc_dev
, REG_CTRL
, (config
| CNTRLREG_TSCSSENB
));
124 } else if (status
& IRQENB_FIFO1THRES
) {
125 /* Disable irq and wake worker thread */
126 tiadc_writel(adc_dev
, REG_IRQCLR
, IRQENB_FIFO1THRES
);
127 return IRQ_WAKE_THREAD
;
133 static irqreturn_t
tiadc_worker_h(int irq
, void *private)
135 struct iio_dev
*indio_dev
= private;
136 struct tiadc_device
*adc_dev
= iio_priv(indio_dev
);
137 int i
, k
, fifo1count
, read
;
138 u16
*data
= adc_dev
->data
;
140 fifo1count
= tiadc_readl(adc_dev
, REG_FIFO1CNT
);
141 for (k
= 0; k
< fifo1count
; k
= k
+ i
) {
142 for (i
= 0; i
< (indio_dev
->scan_bytes
)/2; i
++) {
143 read
= tiadc_readl(adc_dev
, REG_FIFO1
);
144 data
[i
] = read
& FIFOREAD_DATA_MASK
;
146 iio_push_to_buffers(indio_dev
, (u8
*) data
);
149 tiadc_writel(adc_dev
, REG_IRQSTATUS
, IRQENB_FIFO1THRES
);
150 tiadc_writel(adc_dev
, REG_IRQENABLE
, IRQENB_FIFO1THRES
);
155 static int tiadc_buffer_preenable(struct iio_dev
*indio_dev
)
157 struct tiadc_device
*adc_dev
= iio_priv(indio_dev
);
158 int i
, fifo1count
, read
;
160 tiadc_writel(adc_dev
, REG_IRQCLR
, (IRQENB_FIFO1THRES
|
162 IRQENB_FIFO1UNDRFLW
));
164 /* Flush FIFO. Needed in corner cases in simultaneous tsc/adc use */
165 fifo1count
= tiadc_readl(adc_dev
, REG_FIFO1CNT
);
166 for (i
= 0; i
< fifo1count
; i
++)
167 read
= tiadc_readl(adc_dev
, REG_FIFO1
);
172 static int tiadc_buffer_postenable(struct iio_dev
*indio_dev
)
174 struct tiadc_device
*adc_dev
= iio_priv(indio_dev
);
175 struct iio_buffer
*buffer
= indio_dev
->buffer
;
176 unsigned int enb
= 0;
179 tiadc_step_config(indio_dev
);
180 for_each_set_bit(bit
, buffer
->scan_mask
, adc_dev
->channels
)
181 enb
|= (get_adc_step_bit(adc_dev
, bit
) << 1);
182 adc_dev
->buffer_en_ch_steps
= enb
;
184 am335x_tsc_se_set(adc_dev
->mfd_tscadc
, enb
);
186 tiadc_writel(adc_dev
, REG_IRQSTATUS
, IRQENB_FIFO1THRES
187 | IRQENB_FIFO1OVRRUN
| IRQENB_FIFO1UNDRFLW
);
188 tiadc_writel(adc_dev
, REG_IRQENABLE
, IRQENB_FIFO1THRES
189 | IRQENB_FIFO1OVRRUN
);
194 static int tiadc_buffer_predisable(struct iio_dev
*indio_dev
)
196 struct tiadc_device
*adc_dev
= iio_priv(indio_dev
);
197 int fifo1count
, i
, read
;
199 tiadc_writel(adc_dev
, REG_IRQCLR
, (IRQENB_FIFO1THRES
|
200 IRQENB_FIFO1OVRRUN
| IRQENB_FIFO1UNDRFLW
));
201 am335x_tsc_se_clr(adc_dev
->mfd_tscadc
, adc_dev
->buffer_en_ch_steps
);
203 /* Flush FIFO of leftover data in the time it takes to disable adc */
204 fifo1count
= tiadc_readl(adc_dev
, REG_FIFO1CNT
);
205 for (i
= 0; i
< fifo1count
; i
++)
206 read
= tiadc_readl(adc_dev
, REG_FIFO1
);
211 static int tiadc_buffer_postdisable(struct iio_dev
*indio_dev
)
213 tiadc_step_config(indio_dev
);
218 static const struct iio_buffer_setup_ops tiadc_buffer_setup_ops
= {
219 .preenable
= &tiadc_buffer_preenable
,
220 .postenable
= &tiadc_buffer_postenable
,
221 .predisable
= &tiadc_buffer_predisable
,
222 .postdisable
= &tiadc_buffer_postdisable
,
225 static int tiadc_iio_buffered_hardware_setup(struct iio_dev
*indio_dev
,
226 irqreturn_t (*pollfunc_bh
)(int irq
, void *p
),
227 irqreturn_t (*pollfunc_th
)(int irq
, void *p
),
230 const struct iio_buffer_setup_ops
*setup_ops
)
232 struct iio_buffer
*buffer
;
235 buffer
= iio_kfifo_allocate(indio_dev
);
239 iio_device_attach_buffer(indio_dev
, buffer
);
241 ret
= request_threaded_irq(irq
, pollfunc_th
, pollfunc_bh
,
242 flags
, indio_dev
->name
, indio_dev
);
244 goto error_kfifo_free
;
246 indio_dev
->setup_ops
= setup_ops
;
247 indio_dev
->modes
|= INDIO_BUFFER_HARDWARE
;
249 ret
= iio_buffer_register(indio_dev
,
251 indio_dev
->num_channels
);
258 free_irq(irq
, indio_dev
);
260 iio_kfifo_free(indio_dev
->buffer
);
264 static void tiadc_iio_buffered_hardware_remove(struct iio_dev
*indio_dev
)
266 struct tiadc_device
*adc_dev
= iio_priv(indio_dev
);
268 free_irq(adc_dev
->mfd_tscadc
->irq
, indio_dev
);
269 iio_kfifo_free(indio_dev
->buffer
);
270 iio_buffer_unregister(indio_dev
);
274 static const char * const chan_name_ain
[] = {
285 static int tiadc_channel_init(struct iio_dev
*indio_dev
, int channels
)
287 struct tiadc_device
*adc_dev
= iio_priv(indio_dev
);
288 struct iio_chan_spec
*chan_array
;
289 struct iio_chan_spec
*chan
;
292 indio_dev
->num_channels
= channels
;
293 chan_array
= kcalloc(channels
,
294 sizeof(struct iio_chan_spec
), GFP_KERNEL
);
295 if (chan_array
== NULL
)
299 for (i
= 0; i
< channels
; i
++, chan
++) {
301 chan
->type
= IIO_VOLTAGE
;
303 chan
->channel
= adc_dev
->channel_line
[i
];
304 chan
->info_mask_separate
= BIT(IIO_CHAN_INFO_RAW
);
305 chan
->datasheet_name
= chan_name_ain
[chan
->channel
];
306 chan
->scan_index
= i
;
307 chan
->scan_type
.sign
= 'u';
308 chan
->scan_type
.realbits
= 12;
309 chan
->scan_type
.storagebits
= 16;
312 indio_dev
->channels
= chan_array
;
317 static void tiadc_channels_remove(struct iio_dev
*indio_dev
)
319 kfree(indio_dev
->channels
);
322 static int tiadc_read_raw(struct iio_dev
*indio_dev
,
323 struct iio_chan_spec
const *chan
,
324 int *val
, int *val2
, long mask
)
326 struct tiadc_device
*adc_dev
= iio_priv(indio_dev
);
328 unsigned int fifo1count
, read
, stepid
;
331 unsigned long timeout
= jiffies
+ usecs_to_jiffies
332 (IDLE_TIMEOUT
* adc_dev
->channels
);
334 if (iio_buffer_enabled(indio_dev
))
337 step_en
= get_adc_step_mask(adc_dev
);
338 am335x_tsc_se_set(adc_dev
->mfd_tscadc
, step_en
);
340 /* Wait for ADC sequencer to complete sampling */
341 while (tiadc_readl(adc_dev
, REG_ADCFSM
) & SEQ_STATUS
) {
342 if (time_after(jiffies
, timeout
))
345 map_val
= chan
->channel
+ TOTAL_CHANNELS
;
348 * When the sub-system is first enabled,
349 * the sequencer will always start with the
350 * lowest step (1) and continue until step (16).
351 * For ex: If we have enabled 4 ADC channels and
352 * currently use only 1 out of them, the
353 * sequencer still configures all the 4 steps,
354 * leading to 3 unwanted data.
355 * Hence we need to flush out this data.
358 fifo1count
= tiadc_readl(adc_dev
, REG_FIFO1CNT
);
359 for (i
= 0; i
< fifo1count
; i
++) {
360 read
= tiadc_readl(adc_dev
, REG_FIFO1
);
361 stepid
= read
& FIFOREAD_CHNLID_MASK
;
362 stepid
= stepid
>> 0x10;
364 if (stepid
== map_val
) {
365 read
= read
& FIFOREAD_DATA_MASK
;
376 static const struct iio_info tiadc_info
= {
377 .read_raw
= &tiadc_read_raw
,
378 .driver_module
= THIS_MODULE
,
381 static int tiadc_probe(struct platform_device
*pdev
)
383 struct iio_dev
*indio_dev
;
384 struct tiadc_device
*adc_dev
;
385 struct device_node
*node
= pdev
->dev
.of_node
;
386 struct property
*prop
;
393 dev_err(&pdev
->dev
, "Could not find valid DT data.\n");
397 indio_dev
= devm_iio_device_alloc(&pdev
->dev
,
398 sizeof(struct tiadc_device
));
399 if (indio_dev
== NULL
) {
400 dev_err(&pdev
->dev
, "failed to allocate iio device\n");
403 adc_dev
= iio_priv(indio_dev
);
405 adc_dev
->mfd_tscadc
= ti_tscadc_dev_get(pdev
);
407 of_property_for_each_u32(node
, "ti,adc-channels", prop
, cur
, val
) {
408 adc_dev
->channel_line
[channels
] = val
;
411 adc_dev
->channels
= channels
;
413 indio_dev
->dev
.parent
= &pdev
->dev
;
414 indio_dev
->name
= dev_name(&pdev
->dev
);
415 indio_dev
->modes
= INDIO_DIRECT_MODE
;
416 indio_dev
->info
= &tiadc_info
;
418 tiadc_step_config(indio_dev
);
419 tiadc_writel(adc_dev
, REG_FIFO1THR
, FIFO1_THRESHOLD
);
421 err
= tiadc_channel_init(indio_dev
, adc_dev
->channels
);
425 err
= tiadc_iio_buffered_hardware_setup(indio_dev
,
428 adc_dev
->mfd_tscadc
->irq
,
430 &tiadc_buffer_setup_ops
);
433 goto err_free_channels
;
435 err
= iio_device_register(indio_dev
);
437 goto err_buffer_unregister
;
439 platform_set_drvdata(pdev
, indio_dev
);
443 err_buffer_unregister
:
444 tiadc_iio_buffered_hardware_remove(indio_dev
);
446 tiadc_channels_remove(indio_dev
);
450 static int tiadc_remove(struct platform_device
*pdev
)
452 struct iio_dev
*indio_dev
= platform_get_drvdata(pdev
);
453 struct tiadc_device
*adc_dev
= iio_priv(indio_dev
);
456 iio_device_unregister(indio_dev
);
457 tiadc_iio_buffered_hardware_remove(indio_dev
);
458 tiadc_channels_remove(indio_dev
);
460 step_en
= get_adc_step_mask(adc_dev
);
461 am335x_tsc_se_clr(adc_dev
->mfd_tscadc
, step_en
);
467 static int tiadc_suspend(struct device
*dev
)
469 struct iio_dev
*indio_dev
= dev_get_drvdata(dev
);
470 struct tiadc_device
*adc_dev
= iio_priv(indio_dev
);
471 struct ti_tscadc_dev
*tscadc_dev
;
474 tscadc_dev
= ti_tscadc_dev_get(to_platform_device(dev
));
475 if (!device_may_wakeup(tscadc_dev
->dev
)) {
476 idle
= tiadc_readl(adc_dev
, REG_CTRL
);
477 idle
&= ~(CNTRLREG_TSCSSENB
);
478 tiadc_writel(adc_dev
, REG_CTRL
, (idle
|
479 CNTRLREG_POWERDOWN
));
485 static int tiadc_resume(struct device
*dev
)
487 struct iio_dev
*indio_dev
= dev_get_drvdata(dev
);
488 struct tiadc_device
*adc_dev
= iio_priv(indio_dev
);
489 unsigned int restore
;
491 /* Make sure ADC is powered up */
492 restore
= tiadc_readl(adc_dev
, REG_CTRL
);
493 restore
&= ~(CNTRLREG_POWERDOWN
);
494 tiadc_writel(adc_dev
, REG_CTRL
, restore
);
496 tiadc_step_config(indio_dev
);
501 static const struct dev_pm_ops tiadc_pm_ops
= {
502 .suspend
= tiadc_suspend
,
503 .resume
= tiadc_resume
,
505 #define TIADC_PM_OPS (&tiadc_pm_ops)
507 #define TIADC_PM_OPS NULL
510 static const struct of_device_id ti_adc_dt_ids
[] = {
511 { .compatible
= "ti,am3359-adc", },
514 MODULE_DEVICE_TABLE(of
, ti_adc_dt_ids
);
516 static struct platform_driver tiadc_driver
= {
518 .name
= "TI-am335x-adc",
519 .owner
= THIS_MODULE
,
521 .of_match_table
= ti_adc_dt_ids
,
523 .probe
= tiadc_probe
,
524 .remove
= tiadc_remove
,
526 module_platform_driver(tiadc_driver
);
528 MODULE_DESCRIPTION("TI ADC controller driver");
529 MODULE_AUTHOR("Rachna Patil <rachna@ti.com>");
530 MODULE_LICENSE("GPL");