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