1 /* arch/arm/plat-samsung/adc.c
3 * Copyright (c) 2008 Simtec Electronics
4 * http://armlinux.simtec.co.uk/
5 * Ben Dooks <ben@simtec.co.uk>, <ben-linux@fluff.org>
7 * Samsung ADC device core
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License.
14 #include <linux/module.h>
15 #include <linux/kernel.h>
16 #include <linux/platform_device.h>
17 #include <linux/sched.h>
18 #include <linux/list.h>
19 #include <linux/slab.h>
20 #include <linux/err.h>
21 #include <linux/clk.h>
22 #include <linux/interrupt.h>
25 #include <plat/regs-adc.h>
28 /* This driver is designed to control the usage of the ADC block between
29 * the touchscreen and any other drivers that may need to use it, such as
32 * Priority will be given to the touchscreen driver, but as this itself is
33 * rate limited it should not starve other requests which are processed in
34 * order that they are received.
36 * Each user registers to get a client block which uniquely identifies it
37 * and stores information such as the necessary functions to callback when
46 struct s3c_adc_client
{
47 struct platform_device
*pdev
;
48 struct list_head pend
;
49 wait_queue_head_t
*wait
;
51 unsigned int nr_samples
;
54 unsigned char channel
;
56 void (*select_cb
)(struct s3c_adc_client
*c
, unsigned selected
);
57 void (*convert_cb
)(struct s3c_adc_client
*c
,
58 unsigned val1
, unsigned val2
,
59 unsigned *samples_left
);
63 struct platform_device
*pdev
;
64 struct platform_device
*owner
;
66 struct s3c_adc_client
*cur
;
67 struct s3c_adc_client
*ts_pend
;
71 unsigned int prescale
;
76 static struct adc_device
*adc_dev
;
78 static LIST_HEAD(adc_pending
); /* protected by adc_device.lock */
80 #define adc_dbg(_adc, msg...) dev_dbg(&(_adc)->pdev->dev, msg)
82 static inline void s3c_adc_convert(struct adc_device
*adc
)
84 unsigned con
= readl(adc
->regs
+ S3C2410_ADCCON
);
86 con
|= S3C2410_ADCCON_ENABLE_START
;
87 writel(con
, adc
->regs
+ S3C2410_ADCCON
);
90 static inline void s3c_adc_select(struct adc_device
*adc
,
91 struct s3c_adc_client
*client
)
93 unsigned con
= readl(adc
->regs
+ S3C2410_ADCCON
);
95 client
->select_cb(client
, 1);
97 con
&= ~S3C2410_ADCCON_MUXMASK
;
98 con
&= ~S3C2410_ADCCON_STDBM
;
99 con
&= ~S3C2410_ADCCON_STARTMASK
;
102 con
|= S3C2410_ADCCON_SELMUX(client
->channel
);
104 writel(con
, adc
->regs
+ S3C2410_ADCCON
);
107 static void s3c_adc_dbgshow(struct adc_device
*adc
)
109 adc_dbg(adc
, "CON=%08x, TSC=%08x, DLY=%08x\n",
110 readl(adc
->regs
+ S3C2410_ADCCON
),
111 readl(adc
->regs
+ S3C2410_ADCTSC
),
112 readl(adc
->regs
+ S3C2410_ADCDLY
));
115 static void s3c_adc_try(struct adc_device
*adc
)
117 struct s3c_adc_client
*next
= adc
->ts_pend
;
119 if (!next
&& !list_empty(&adc_pending
)) {
120 next
= list_first_entry(&adc_pending
,
121 struct s3c_adc_client
, pend
);
122 list_del(&next
->pend
);
127 adc_dbg(adc
, "new client is %p\n", next
);
129 s3c_adc_select(adc
, next
);
130 s3c_adc_convert(adc
);
131 s3c_adc_dbgshow(adc
);
135 int s3c_adc_start(struct s3c_adc_client
*client
,
136 unsigned int channel
, unsigned int nr_samples
)
138 struct adc_device
*adc
= adc_dev
;
142 printk(KERN_ERR
"%s: failed to find adc\n", __func__
);
146 if (client
->is_ts
&& adc
->ts_pend
)
149 spin_lock_irqsave(&adc
->lock
, flags
);
151 client
->channel
= channel
;
152 client
->nr_samples
= nr_samples
;
155 adc
->ts_pend
= client
;
157 list_add_tail(&client
->pend
, &adc_pending
);
162 spin_unlock_irqrestore(&adc
->lock
, flags
);
166 EXPORT_SYMBOL_GPL(s3c_adc_start
);
168 static void s3c_convert_done(struct s3c_adc_client
*client
,
169 unsigned v
, unsigned u
, unsigned *left
)
172 wake_up(client
->wait
);
175 int s3c_adc_read(struct s3c_adc_client
*client
, unsigned int ch
)
177 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wake
);
180 client
->convert_cb
= s3c_convert_done
;
181 client
->wait
= &wake
;
184 ret
= s3c_adc_start(client
, ch
, 1);
188 ret
= wait_event_timeout(wake
, client
->result
>= 0, HZ
/ 2);
189 if (client
->result
< 0) {
194 client
->convert_cb
= NULL
;
195 return client
->result
;
200 EXPORT_SYMBOL_GPL(s3c_adc_read
);
202 static void s3c_adc_default_select(struct s3c_adc_client
*client
,
207 struct s3c_adc_client
*s3c_adc_register(struct platform_device
*pdev
,
208 void (*select
)(struct s3c_adc_client
*client
,
209 unsigned int selected
),
210 void (*conv
)(struct s3c_adc_client
*client
,
211 unsigned d0
, unsigned d1
,
212 unsigned *samples_left
),
215 struct s3c_adc_client
*client
;
220 select
= s3c_adc_default_select
;
223 return ERR_PTR(-EINVAL
);
225 client
= kzalloc(sizeof(struct s3c_adc_client
), GFP_KERNEL
);
227 dev_err(&pdev
->dev
, "no memory for adc client\n");
228 return ERR_PTR(-ENOMEM
);
232 client
->is_ts
= is_ts
;
233 client
->select_cb
= select
;
234 client
->convert_cb
= conv
;
238 EXPORT_SYMBOL_GPL(s3c_adc_register
);
240 void s3c_adc_release(struct s3c_adc_client
*client
)
244 spin_lock_irqsave(&adc_dev
->lock
, flags
);
246 /* We should really check that nothing is in progress. */
247 if (adc_dev
->cur
== client
)
249 if (adc_dev
->ts_pend
== client
)
250 adc_dev
->ts_pend
= NULL
;
252 struct list_head
*p
, *n
;
253 struct s3c_adc_client
*tmp
;
255 list_for_each_safe(p
, n
, &adc_pending
) {
256 tmp
= list_entry(p
, struct s3c_adc_client
, pend
);
258 list_del(&tmp
->pend
);
262 if (adc_dev
->cur
== NULL
)
263 s3c_adc_try(adc_dev
);
265 spin_unlock_irqrestore(&adc_dev
->lock
, flags
);
268 EXPORT_SYMBOL_GPL(s3c_adc_release
);
270 static irqreturn_t
s3c_adc_irq(int irq
, void *pw
)
272 struct adc_device
*adc
= pw
;
273 struct s3c_adc_client
*client
= adc
->cur
;
274 enum s3c_cpu_type cpu
= platform_get_device_id(adc
->pdev
)->driver_data
;
275 unsigned data0
, data1
;
278 dev_warn(&adc
->pdev
->dev
, "%s: no adc pending\n", __func__
);
282 data0
= readl(adc
->regs
+ S3C2410_ADCDAT0
);
283 data1
= readl(adc
->regs
+ S3C2410_ADCDAT1
);
284 adc_dbg(adc
, "read %d: 0x%04x, 0x%04x\n", client
->nr_samples
, data0
, data1
);
286 client
->nr_samples
--;
288 if (cpu
== TYPE_S3C64XX
) {
289 /* S3C64XX ADC resolution is 12-bit */
297 if (client
->convert_cb
)
298 (client
->convert_cb
)(client
, data0
, data1
, &client
->nr_samples
);
300 if (client
->nr_samples
> 0) {
301 /* fire another conversion for this */
303 client
->select_cb(client
, 1);
304 s3c_adc_convert(adc
);
306 spin_lock(&adc
->lock
);
307 (client
->select_cb
)(client
, 0);
311 spin_unlock(&adc
->lock
);
315 if (cpu
== TYPE_S3C64XX
) {
316 /* Clear ADC interrupt */
317 writel(0, adc
->regs
+ S3C64XX_ADCCLRINT
);
322 static int s3c_adc_probe(struct platform_device
*pdev
)
324 struct device
*dev
= &pdev
->dev
;
325 struct adc_device
*adc
;
326 struct resource
*regs
;
330 adc
= kzalloc(sizeof(struct adc_device
), GFP_KERNEL
);
332 dev_err(dev
, "failed to allocate adc_device\n");
336 spin_lock_init(&adc
->lock
);
339 adc
->prescale
= S3C2410_ADCCON_PRSCVL(49);
341 adc
->irq
= platform_get_irq(pdev
, 1);
343 dev_err(dev
, "failed to get adc irq\n");
348 ret
= request_irq(adc
->irq
, s3c_adc_irq
, 0, dev_name(dev
), adc
);
350 dev_err(dev
, "failed to attach adc irq\n");
354 adc
->clk
= clk_get(dev
, "adc");
355 if (IS_ERR(adc
->clk
)) {
356 dev_err(dev
, "failed to get adc clock\n");
357 ret
= PTR_ERR(adc
->clk
);
361 regs
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
363 dev_err(dev
, "failed to find registers\n");
368 adc
->regs
= ioremap(regs
->start
, resource_size(regs
));
370 dev_err(dev
, "failed to map registers\n");
375 clk_enable(adc
->clk
);
377 tmp
= adc
->prescale
| S3C2410_ADCCON_PRSCEN
;
378 if (platform_get_device_id(pdev
)->driver_data
== TYPE_S3C64XX
) {
379 /* Enable 12-bit ADC resolution */
380 tmp
|= S3C64XX_ADCCON_RESSEL
;
382 writel(tmp
, adc
->regs
+ S3C2410_ADCCON
);
384 dev_info(dev
, "attached adc driver\n");
386 platform_set_drvdata(pdev
, adc
);
395 free_irq(adc
->irq
, adc
);
402 static int __devexit
s3c_adc_remove(struct platform_device
*pdev
)
404 struct adc_device
*adc
= platform_get_drvdata(pdev
);
407 free_irq(adc
->irq
, adc
);
408 clk_disable(adc
->clk
);
416 static int s3c_adc_suspend(struct platform_device
*pdev
, pm_message_t state
)
418 struct adc_device
*adc
= platform_get_drvdata(pdev
);
422 spin_lock_irqsave(&adc
->lock
, flags
);
424 con
= readl(adc
->regs
+ S3C2410_ADCCON
);
425 con
|= S3C2410_ADCCON_STDBM
;
426 writel(con
, adc
->regs
+ S3C2410_ADCCON
);
428 disable_irq(adc
->irq
);
429 spin_unlock_irqrestore(&adc
->lock
, flags
);
430 clk_disable(adc
->clk
);
435 static int s3c_adc_resume(struct platform_device
*pdev
)
437 struct adc_device
*adc
= platform_get_drvdata(pdev
);
440 clk_enable(adc
->clk
);
441 enable_irq(adc
->irq
);
443 writel(adc
->prescale
| S3C2410_ADCCON_PRSCEN
,
444 adc
->regs
+ S3C2410_ADCCON
);
450 #define s3c_adc_suspend NULL
451 #define s3c_adc_resume NULL
454 static struct platform_device_id s3c_adc_driver_ids
[] = {
456 .name
= "s3c24xx-adc",
457 .driver_data
= TYPE_S3C24XX
,
459 .name
= "s3c64xx-adc",
460 .driver_data
= TYPE_S3C64XX
,
464 MODULE_DEVICE_TABLE(platform
, s3c_adc_driver_ids
);
466 static struct platform_driver s3c_adc_driver
= {
467 .id_table
= s3c_adc_driver_ids
,
470 .owner
= THIS_MODULE
,
472 .probe
= s3c_adc_probe
,
473 .remove
= __devexit_p(s3c_adc_remove
),
474 .suspend
= s3c_adc_suspend
,
475 .resume
= s3c_adc_resume
,
478 static int __init
adc_init(void)
482 ret
= platform_driver_register(&s3c_adc_driver
);
484 printk(KERN_ERR
"%s: failed to add adc driver\n", __func__
);
489 arch_initcall(adc_init
);