Commit | Line | Data |
---|---|---|
5e53a69b PR |
1 | /* |
2 | * TI ADC MFD driver | |
3 | * | |
4 | * Copyright (C) 2012 Texas Instruments Incorporated - http://www.ti.com/ | |
5 | * | |
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. | |
9 | * | |
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. | |
14 | */ | |
15 | ||
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> | |
23 | #include <linux/io.h> | |
24 | #include <linux/iio/iio.h> | |
6f39ac4e PR |
25 | #include <linux/of.h> |
26 | #include <linux/of_device.h> | |
c80df483 PA |
27 | #include <linux/iio/machine.h> |
28 | #include <linux/iio/driver.h> | |
5e53a69b PR |
29 | |
30 | #include <linux/mfd/ti_am335x_tscadc.h> | |
5e53a69b PR |
31 | |
32 | struct tiadc_device { | |
33 | struct ti_tscadc_dev *mfd_tscadc; | |
34 | int channels; | |
18926ede SAS |
35 | u8 channel_line[8]; |
36 | u8 channel_step[8]; | |
5e53a69b PR |
37 | }; |
38 | ||
39 | static unsigned int tiadc_readl(struct tiadc_device *adc, unsigned int reg) | |
40 | { | |
41 | return readl(adc->mfd_tscadc->tscadc_base + reg); | |
42 | } | |
43 | ||
44 | static void tiadc_writel(struct tiadc_device *adc, unsigned int reg, | |
45 | unsigned int val) | |
46 | { | |
47 | writel(val, adc->mfd_tscadc->tscadc_base + reg); | |
48 | } | |
49 | ||
abeccee4 PR |
50 | static u32 get_adc_step_mask(struct tiadc_device *adc_dev) |
51 | { | |
52 | u32 step_en; | |
53 | ||
54 | step_en = ((1 << adc_dev->channels) - 1); | |
55 | step_en <<= TOTAL_STEPS - adc_dev->channels + 1; | |
56 | return step_en; | |
57 | } | |
58 | ||
5e53a69b PR |
59 | static void tiadc_step_config(struct tiadc_device *adc_dev) |
60 | { | |
61 | unsigned int stepconfig; | |
18926ede | 62 | int i, steps; |
5e53a69b PR |
63 | |
64 | /* | |
65 | * There are 16 configurable steps and 8 analog input | |
66 | * lines available which are shared between Touchscreen and ADC. | |
67 | * | |
68 | * Steps backwards i.e. from 16 towards 0 are used by ADC | |
69 | * depending on number of input lines needed. | |
70 | * Channel would represent which analog input | |
71 | * needs to be given to ADC to digitalize data. | |
72 | */ | |
73 | ||
74 | steps = TOTAL_STEPS - adc_dev->channels; | |
5e53a69b PR |
75 | stepconfig = STEPCONFIG_AVG_16 | STEPCONFIG_FIFO1; |
76 | ||
18926ede SAS |
77 | for (i = 0; i < adc_dev->channels; i++) { |
78 | int chan; | |
79 | ||
80 | chan = adc_dev->channel_line[i]; | |
81 | tiadc_writel(adc_dev, REG_STEPCONFIG(steps), | |
82 | stepconfig | STEPCONFIG_INP(chan)); | |
83 | tiadc_writel(adc_dev, REG_STEPDELAY(steps), | |
5e53a69b | 84 | STEPCONFIG_OPENDLY); |
18926ede SAS |
85 | adc_dev->channel_step[i] = steps; |
86 | steps++; | |
5e53a69b | 87 | } |
b1451e54 | 88 | |
5e53a69b PR |
89 | } |
90 | ||
c80df483 PA |
91 | static const char * const chan_name_ain[] = { |
92 | "AIN0", | |
93 | "AIN1", | |
94 | "AIN2", | |
95 | "AIN3", | |
96 | "AIN4", | |
97 | "AIN5", | |
98 | "AIN6", | |
99 | "AIN7", | |
100 | }; | |
101 | ||
5e53a69b PR |
102 | static int tiadc_channel_init(struct iio_dev *indio_dev, int channels) |
103 | { | |
c80df483 | 104 | struct tiadc_device *adc_dev = iio_priv(indio_dev); |
5e53a69b | 105 | struct iio_chan_spec *chan_array; |
c80df483 | 106 | struct iio_chan_spec *chan; |
5e53a69b PR |
107 | int i; |
108 | ||
109 | indio_dev->num_channels = channels; | |
c80df483 | 110 | chan_array = kcalloc(channels, |
5e53a69b | 111 | sizeof(struct iio_chan_spec), GFP_KERNEL); |
5e53a69b PR |
112 | if (chan_array == NULL) |
113 | return -ENOMEM; | |
114 | ||
c80df483 PA |
115 | chan = chan_array; |
116 | for (i = 0; i < channels; i++, chan++) { | |
117 | ||
5e53a69b PR |
118 | chan->type = IIO_VOLTAGE; |
119 | chan->indexed = 1; | |
18926ede | 120 | chan->channel = adc_dev->channel_line[i]; |
6c572522 | 121 | chan->info_mask_separate = BIT(IIO_CHAN_INFO_RAW); |
18926ede | 122 | chan->datasheet_name = chan_name_ain[chan->channel]; |
c80df483 PA |
123 | chan->scan_type.sign = 'u'; |
124 | chan->scan_type.realbits = 12; | |
0f6fc7d5 | 125 | chan->scan_type.storagebits = 16; |
5e53a69b PR |
126 | } |
127 | ||
128 | indio_dev->channels = chan_array; | |
129 | ||
c80df483 | 130 | return 0; |
5e53a69b PR |
131 | } |
132 | ||
133 | static void tiadc_channels_remove(struct iio_dev *indio_dev) | |
134 | { | |
135 | kfree(indio_dev->channels); | |
136 | } | |
137 | ||
138 | static int tiadc_read_raw(struct iio_dev *indio_dev, | |
139 | struct iio_chan_spec const *chan, | |
140 | int *val, int *val2, long mask) | |
141 | { | |
142 | struct tiadc_device *adc_dev = iio_priv(indio_dev); | |
b1451e54 PR |
143 | int i, map_val; |
144 | unsigned int fifo1count, read, stepid; | |
18926ede | 145 | u32 step = UINT_MAX; |
1460c152 | 146 | bool found = false; |
b1451e54 PR |
147 | u32 step_en; |
148 | unsigned long timeout = jiffies + usecs_to_jiffies | |
149 | (IDLE_TIMEOUT * adc_dev->channels); | |
150 | step_en = get_adc_step_mask(adc_dev); | |
151 | am335x_tsc_se_set(adc_dev->mfd_tscadc, step_en); | |
152 | ||
153 | /* Wait for ADC sequencer to complete sampling */ | |
154 | while (tiadc_readl(adc_dev, REG_ADCFSM) & SEQ_STATUS) { | |
155 | if (time_after(jiffies, timeout)) | |
156 | return -EAGAIN; | |
157 | } | |
158 | map_val = chan->channel + TOTAL_CHANNELS; | |
5e53a69b PR |
159 | |
160 | /* | |
161 | * When the sub-system is first enabled, | |
162 | * the sequencer will always start with the | |
163 | * lowest step (1) and continue until step (16). | |
164 | * For ex: If we have enabled 4 ADC channels and | |
165 | * currently use only 1 out of them, the | |
166 | * sequencer still configures all the 4 steps, | |
167 | * leading to 3 unwanted data. | |
168 | * Hence we need to flush out this data. | |
169 | */ | |
170 | ||
18926ede SAS |
171 | for (i = 0; i < ARRAY_SIZE(adc_dev->channel_step); i++) { |
172 | if (chan->channel == adc_dev->channel_line[i]) { | |
173 | step = adc_dev->channel_step[i]; | |
174 | break; | |
175 | } | |
176 | } | |
177 | if (WARN_ON_ONCE(step == UINT_MAX)) | |
178 | return -EINVAL; | |
179 | ||
5e53a69b PR |
180 | fifo1count = tiadc_readl(adc_dev, REG_FIFO1CNT); |
181 | for (i = 0; i < fifo1count; i++) { | |
18926ede | 182 | read = tiadc_readl(adc_dev, REG_FIFO1); |
b1451e54 PR |
183 | stepid = read & FIFOREAD_CHNLID_MASK; |
184 | stepid = stepid >> 0x10; | |
185 | ||
186 | if (stepid == map_val) { | |
187 | read = read & FIFOREAD_DATA_MASK; | |
1460c152 | 188 | found = true; |
0f6fc7d5 | 189 | *val = (u16) read; |
1460c152 | 190 | } |
5e53a69b | 191 | } |
b1451e54 | 192 | |
1460c152 SAS |
193 | if (found == false) |
194 | return -EBUSY; | |
5e53a69b PR |
195 | return IIO_VAL_INT; |
196 | } | |
197 | ||
198 | static const struct iio_info tiadc_info = { | |
199 | .read_raw = &tiadc_read_raw, | |
bc93aa76 | 200 | .driver_module = THIS_MODULE, |
5e53a69b PR |
201 | }; |
202 | ||
fc52692c | 203 | static int tiadc_probe(struct platform_device *pdev) |
5e53a69b PR |
204 | { |
205 | struct iio_dev *indio_dev; | |
206 | struct tiadc_device *adc_dev; | |
6f39ac4e | 207 | struct device_node *node = pdev->dev.of_node; |
18926ede SAS |
208 | struct property *prop; |
209 | const __be32 *cur; | |
5e53a69b | 210 | int err; |
18926ede SAS |
211 | u32 val; |
212 | int channels = 0; | |
5e53a69b | 213 | |
0ead4fb2 SAS |
214 | if (!node) { |
215 | dev_err(&pdev->dev, "Could not find valid DT data.\n"); | |
5e53a69b PR |
216 | return -EINVAL; |
217 | } | |
218 | ||
a0648130 SK |
219 | indio_dev = devm_iio_device_alloc(&pdev->dev, |
220 | sizeof(struct tiadc_device)); | |
5e53a69b PR |
221 | if (indio_dev == NULL) { |
222 | dev_err(&pdev->dev, "failed to allocate iio device\n"); | |
a0648130 | 223 | return -ENOMEM; |
5e53a69b PR |
224 | } |
225 | adc_dev = iio_priv(indio_dev); | |
226 | ||
6f39ac4e PR |
227 | adc_dev->mfd_tscadc = ti_tscadc_dev_get(pdev); |
228 | ||
18926ede SAS |
229 | of_property_for_each_u32(node, "ti,adc-channels", prop, cur, val) { |
230 | adc_dev->channel_line[channels] = val; | |
231 | channels++; | |
232 | } | |
233 | adc_dev->channels = channels; | |
5e53a69b PR |
234 | |
235 | indio_dev->dev.parent = &pdev->dev; | |
236 | indio_dev->name = dev_name(&pdev->dev); | |
237 | indio_dev->modes = INDIO_DIRECT_MODE; | |
238 | indio_dev->info = &tiadc_info; | |
239 | ||
240 | tiadc_step_config(adc_dev); | |
241 | ||
242 | err = tiadc_channel_init(indio_dev, adc_dev->channels); | |
243 | if (err < 0) | |
a0648130 | 244 | return err; |
5e53a69b PR |
245 | |
246 | err = iio_device_register(indio_dev); | |
247 | if (err) | |
248 | goto err_free_channels; | |
249 | ||
250 | platform_set_drvdata(pdev, indio_dev); | |
251 | ||
252 | return 0; | |
253 | ||
254 | err_free_channels: | |
255 | tiadc_channels_remove(indio_dev); | |
5e53a69b PR |
256 | return err; |
257 | } | |
258 | ||
fc52692c | 259 | static int tiadc_remove(struct platform_device *pdev) |
5e53a69b PR |
260 | { |
261 | struct iio_dev *indio_dev = platform_get_drvdata(pdev); | |
abeccee4 PR |
262 | struct tiadc_device *adc_dev = iio_priv(indio_dev); |
263 | u32 step_en; | |
5e53a69b PR |
264 | |
265 | iio_device_unregister(indio_dev); | |
266 | tiadc_channels_remove(indio_dev); | |
267 | ||
abeccee4 PR |
268 | step_en = get_adc_step_mask(adc_dev); |
269 | am335x_tsc_se_clr(adc_dev->mfd_tscadc, step_en); | |
270 | ||
5e53a69b PR |
271 | return 0; |
272 | } | |
273 | ||
274 | #ifdef CONFIG_PM | |
275 | static int tiadc_suspend(struct device *dev) | |
276 | { | |
277 | struct iio_dev *indio_dev = dev_get_drvdata(dev); | |
278 | struct tiadc_device *adc_dev = iio_priv(indio_dev); | |
a9bce1b0 | 279 | struct ti_tscadc_dev *tscadc_dev; |
5e53a69b PR |
280 | unsigned int idle; |
281 | ||
a9bce1b0 | 282 | tscadc_dev = ti_tscadc_dev_get(to_platform_device(dev)); |
5e53a69b PR |
283 | if (!device_may_wakeup(tscadc_dev->dev)) { |
284 | idle = tiadc_readl(adc_dev, REG_CTRL); | |
285 | idle &= ~(CNTRLREG_TSCSSENB); | |
286 | tiadc_writel(adc_dev, REG_CTRL, (idle | | |
287 | CNTRLREG_POWERDOWN)); | |
288 | } | |
289 | ||
290 | return 0; | |
291 | } | |
292 | ||
293 | static int tiadc_resume(struct device *dev) | |
294 | { | |
295 | struct iio_dev *indio_dev = dev_get_drvdata(dev); | |
296 | struct tiadc_device *adc_dev = iio_priv(indio_dev); | |
297 | unsigned int restore; | |
298 | ||
299 | /* Make sure ADC is powered up */ | |
300 | restore = tiadc_readl(adc_dev, REG_CTRL); | |
301 | restore &= ~(CNTRLREG_POWERDOWN); | |
302 | tiadc_writel(adc_dev, REG_CTRL, restore); | |
303 | ||
304 | tiadc_step_config(adc_dev); | |
305 | ||
306 | return 0; | |
307 | } | |
308 | ||
309 | static const struct dev_pm_ops tiadc_pm_ops = { | |
310 | .suspend = tiadc_suspend, | |
311 | .resume = tiadc_resume, | |
312 | }; | |
313 | #define TIADC_PM_OPS (&tiadc_pm_ops) | |
314 | #else | |
315 | #define TIADC_PM_OPS NULL | |
316 | #endif | |
317 | ||
6f39ac4e PR |
318 | static const struct of_device_id ti_adc_dt_ids[] = { |
319 | { .compatible = "ti,am3359-adc", }, | |
320 | { } | |
321 | }; | |
322 | MODULE_DEVICE_TABLE(of, ti_adc_dt_ids); | |
323 | ||
5e53a69b PR |
324 | static struct platform_driver tiadc_driver = { |
325 | .driver = { | |
9f99928f | 326 | .name = "TI-am335x-adc", |
5e53a69b PR |
327 | .owner = THIS_MODULE, |
328 | .pm = TIADC_PM_OPS, | |
6f39ac4e | 329 | .of_match_table = of_match_ptr(ti_adc_dt_ids), |
5e53a69b PR |
330 | }, |
331 | .probe = tiadc_probe, | |
fc52692c | 332 | .remove = tiadc_remove, |
5e53a69b | 333 | }; |
5e53a69b PR |
334 | module_platform_driver(tiadc_driver); |
335 | ||
336 | MODULE_DESCRIPTION("TI ADC controller driver"); | |
337 | MODULE_AUTHOR("Rachna Patil <rachna@ti.com>"); | |
338 | MODULE_LICENSE("GPL"); |