]>
Commit | Line | Data |
---|---|---|
1 | /* NXP PCF50633 ADC Driver | |
2 | * | |
3 | * (C) 2006-2008 by Openmoko, Inc. | |
4 | * Author: Balaji Rao <balajirrao@openmoko.org> | |
5 | * All rights reserved. | |
6 | * | |
7 | * Broken down from monstrous PCF50633 driver mainly by | |
8 | * Harald Welte, Andy Green and Werner Almesberger | |
9 | * | |
10 | * This program is free software; you can redistribute it and/or modify it | |
11 | * under the terms of the GNU General Public License as published by the | |
12 | * Free Software Foundation; either version 2 of the License, or (at your | |
13 | * option) any later version. | |
14 | * | |
15 | * NOTE: This driver does not yet support subtractive ADC mode, which means | |
16 | * you can do only one measurement per read request. | |
17 | */ | |
18 | ||
19 | #include <linux/kernel.h> | |
20 | #include <linux/slab.h> | |
21 | #include <linux/module.h> | |
22 | #include <linux/init.h> | |
23 | #include <linux/device.h> | |
24 | #include <linux/platform_device.h> | |
25 | #include <linux/completion.h> | |
26 | ||
27 | #include <linux/mfd/pcf50633/core.h> | |
28 | #include <linux/mfd/pcf50633/adc.h> | |
29 | ||
30 | struct pcf50633_adc_request { | |
31 | int mux; | |
32 | int avg; | |
33 | void (*callback)(struct pcf50633 *, void *, int); | |
34 | void *callback_param; | |
35 | }; | |
36 | ||
37 | struct pcf50633_adc_sync_request { | |
38 | int result; | |
39 | struct completion completion; | |
40 | }; | |
41 | ||
42 | #define PCF50633_MAX_ADC_FIFO_DEPTH 8 | |
43 | ||
44 | struct pcf50633_adc { | |
45 | struct pcf50633 *pcf; | |
46 | ||
47 | /* Private stuff */ | |
48 | struct pcf50633_adc_request *queue[PCF50633_MAX_ADC_FIFO_DEPTH]; | |
49 | int queue_head; | |
50 | int queue_tail; | |
51 | struct mutex queue_mutex; | |
52 | }; | |
53 | ||
54 | static inline struct pcf50633_adc *__to_adc(struct pcf50633 *pcf) | |
55 | { | |
56 | return platform_get_drvdata(pcf->adc_pdev); | |
57 | } | |
58 | ||
59 | static void adc_setup(struct pcf50633 *pcf, int channel, int avg) | |
60 | { | |
61 | channel &= PCF50633_ADCC1_ADCMUX_MASK; | |
62 | ||
63 | /* kill ratiometric, but enable ACCSW biasing */ | |
64 | pcf50633_reg_write(pcf, PCF50633_REG_ADCC2, 0x00); | |
65 | pcf50633_reg_write(pcf, PCF50633_REG_ADCC3, 0x01); | |
66 | ||
67 | /* start ADC conversion on selected channel */ | |
68 | pcf50633_reg_write(pcf, PCF50633_REG_ADCC1, channel | avg | | |
69 | PCF50633_ADCC1_ADCSTART | PCF50633_ADCC1_RES_10BIT); | |
70 | } | |
71 | ||
72 | static void trigger_next_adc_job_if_any(struct pcf50633 *pcf) | |
73 | { | |
74 | struct pcf50633_adc *adc = __to_adc(pcf); | |
75 | int head; | |
76 | ||
77 | head = adc->queue_head; | |
78 | ||
79 | if (!adc->queue[head]) | |
80 | return; | |
81 | ||
82 | adc_setup(pcf, adc->queue[head]->mux, adc->queue[head]->avg); | |
83 | } | |
84 | ||
85 | static int | |
86 | adc_enqueue_request(struct pcf50633 *pcf, struct pcf50633_adc_request *req) | |
87 | { | |
88 | struct pcf50633_adc *adc = __to_adc(pcf); | |
89 | int head, tail; | |
90 | ||
91 | mutex_lock(&adc->queue_mutex); | |
92 | ||
93 | head = adc->queue_head; | |
94 | tail = adc->queue_tail; | |
95 | ||
96 | if (adc->queue[tail]) { | |
97 | mutex_unlock(&adc->queue_mutex); | |
98 | dev_err(pcf->dev, "ADC queue is full, dropping request\n"); | |
99 | return -EBUSY; | |
100 | } | |
101 | ||
102 | adc->queue[tail] = req; | |
103 | if (head == tail) | |
104 | trigger_next_adc_job_if_any(pcf); | |
105 | adc->queue_tail = (tail + 1) & (PCF50633_MAX_ADC_FIFO_DEPTH - 1); | |
106 | ||
107 | mutex_unlock(&adc->queue_mutex); | |
108 | ||
109 | return 0; | |
110 | } | |
111 | ||
112 | static void pcf50633_adc_sync_read_callback(struct pcf50633 *pcf, void *param, | |
113 | int result) | |
114 | { | |
115 | struct pcf50633_adc_sync_request *req = param; | |
116 | ||
117 | req->result = result; | |
118 | complete(&req->completion); | |
119 | } | |
120 | ||
121 | int pcf50633_adc_sync_read(struct pcf50633 *pcf, int mux, int avg) | |
122 | { | |
123 | struct pcf50633_adc_sync_request req; | |
124 | int ret; | |
125 | ||
126 | init_completion(&req.completion); | |
127 | ||
128 | ret = pcf50633_adc_async_read(pcf, mux, avg, | |
129 | pcf50633_adc_sync_read_callback, &req); | |
130 | if (ret) | |
131 | return ret; | |
132 | ||
133 | wait_for_completion(&req.completion); | |
134 | ||
135 | return req.result; | |
136 | } | |
137 | EXPORT_SYMBOL_GPL(pcf50633_adc_sync_read); | |
138 | ||
139 | int pcf50633_adc_async_read(struct pcf50633 *pcf, int mux, int avg, | |
140 | void (*callback)(struct pcf50633 *, void *, int), | |
141 | void *callback_param) | |
142 | { | |
143 | struct pcf50633_adc_request *req; | |
144 | ||
145 | /* req is freed when the result is ready, in interrupt handler */ | |
146 | req = kmalloc(sizeof(*req), GFP_KERNEL); | |
147 | if (!req) | |
148 | return -ENOMEM; | |
149 | ||
150 | req->mux = mux; | |
151 | req->avg = avg; | |
152 | req->callback = callback; | |
153 | req->callback_param = callback_param; | |
154 | ||
155 | return adc_enqueue_request(pcf, req); | |
156 | } | |
157 | EXPORT_SYMBOL_GPL(pcf50633_adc_async_read); | |
158 | ||
159 | static int adc_result(struct pcf50633 *pcf) | |
160 | { | |
161 | u8 adcs1, adcs3; | |
162 | u16 result; | |
163 | ||
164 | adcs1 = pcf50633_reg_read(pcf, PCF50633_REG_ADCS1); | |
165 | adcs3 = pcf50633_reg_read(pcf, PCF50633_REG_ADCS3); | |
166 | result = (adcs1 << 2) | (adcs3 & PCF50633_ADCS3_ADCDAT1L_MASK); | |
167 | ||
168 | dev_dbg(pcf->dev, "adc result = %d\n", result); | |
169 | ||
170 | return result; | |
171 | } | |
172 | ||
173 | static void pcf50633_adc_irq(int irq, void *data) | |
174 | { | |
175 | struct pcf50633_adc *adc = data; | |
176 | struct pcf50633 *pcf = adc->pcf; | |
177 | struct pcf50633_adc_request *req; | |
178 | int head, res; | |
179 | ||
180 | mutex_lock(&adc->queue_mutex); | |
181 | head = adc->queue_head; | |
182 | ||
183 | req = adc->queue[head]; | |
184 | if (WARN_ON(!req)) { | |
185 | dev_err(pcf->dev, "pcf50633-adc irq: ADC queue empty!\n"); | |
186 | mutex_unlock(&adc->queue_mutex); | |
187 | return; | |
188 | } | |
189 | adc->queue[head] = NULL; | |
190 | adc->queue_head = (head + 1) & | |
191 | (PCF50633_MAX_ADC_FIFO_DEPTH - 1); | |
192 | ||
193 | res = adc_result(pcf); | |
194 | trigger_next_adc_job_if_any(pcf); | |
195 | ||
196 | mutex_unlock(&adc->queue_mutex); | |
197 | ||
198 | req->callback(pcf, req->callback_param, res); | |
199 | kfree(req); | |
200 | } | |
201 | ||
202 | static int pcf50633_adc_probe(struct platform_device *pdev) | |
203 | { | |
204 | struct pcf50633_adc *adc; | |
205 | ||
206 | adc = kzalloc(sizeof(*adc), GFP_KERNEL); | |
207 | if (!adc) | |
208 | return -ENOMEM; | |
209 | ||
210 | adc->pcf = dev_to_pcf50633(pdev->dev.parent); | |
211 | platform_set_drvdata(pdev, adc); | |
212 | ||
213 | pcf50633_register_irq(adc->pcf, PCF50633_IRQ_ADCRDY, | |
214 | pcf50633_adc_irq, adc); | |
215 | ||
216 | mutex_init(&adc->queue_mutex); | |
217 | ||
218 | return 0; | |
219 | } | |
220 | ||
221 | static int pcf50633_adc_remove(struct platform_device *pdev) | |
222 | { | |
223 | struct pcf50633_adc *adc = platform_get_drvdata(pdev); | |
224 | int i, head; | |
225 | ||
226 | pcf50633_free_irq(adc->pcf, PCF50633_IRQ_ADCRDY); | |
227 | ||
228 | mutex_lock(&adc->queue_mutex); | |
229 | head = adc->queue_head; | |
230 | ||
231 | if (WARN_ON(adc->queue[head])) | |
232 | dev_err(adc->pcf->dev, | |
233 | "adc driver removed with request pending\n"); | |
234 | ||
235 | for (i = 0; i < PCF50633_MAX_ADC_FIFO_DEPTH; i++) | |
236 | kfree(adc->queue[i]); | |
237 | ||
238 | mutex_unlock(&adc->queue_mutex); | |
239 | kfree(adc); | |
240 | ||
241 | return 0; | |
242 | } | |
243 | ||
244 | static struct platform_driver pcf50633_adc_driver = { | |
245 | .driver = { | |
246 | .name = "pcf50633-adc", | |
247 | }, | |
248 | .probe = pcf50633_adc_probe, | |
249 | .remove = pcf50633_adc_remove, | |
250 | }; | |
251 | ||
252 | module_platform_driver(pcf50633_adc_driver); | |
253 | ||
254 | MODULE_AUTHOR("Balaji Rao <balajirrao@openmoko.org>"); | |
255 | MODULE_DESCRIPTION("PCF50633 adc driver"); | |
256 | MODULE_LICENSE("GPL"); | |
257 | MODULE_ALIAS("platform:pcf50633-adc"); | |
258 |