include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit...
[linux-2.6.git] / arch / arm / mach-pxa / corgi_ssp.c
1 /*
2  *  SSP control code for Sharp Corgi devices
3  *
4  *  Copyright (c) 2004-2005 Richard Purdie
5  *
6  *  This program is free software; you can redistribute it and/or modify
7  *  it under the terms of the GNU General Public License version 2 as
8  *  published by the Free Software Foundation.
9  *
10  */
11
12 #include <linux/module.h>
13 #include <linux/init.h>
14 #include <linux/kernel.h>
15 #include <linux/sched.h>
16 #include <linux/delay.h>
17 #include <linux/platform_device.h>
18 #include <mach/hardware.h>
19 #include <asm/mach-types.h>
20
21 #include <mach/ssp.h>
22 #include <mach/pxa2xx-gpio.h>
23 #include <mach/regs-ssp.h>
24 #include "sharpsl.h"
25
26 static DEFINE_SPINLOCK(corgi_ssp_lock);
27 static struct ssp_dev corgi_ssp_dev;
28 static struct ssp_state corgi_ssp_state;
29 static struct corgissp_machinfo *ssp_machinfo;
30
31 /*
32  * There are three devices connected to the SSP interface:
33  *   1. A touchscreen controller (TI ADS7846 compatible)
34  *   2. An LCD controller (with some Backlight functionality)
35  *   3. A battery monitoring IC (Maxim MAX1111)
36  *
37  * Each device uses a different speed/mode of communication.
38  *
39  * The touchscreen is very sensitive and the most frequently used
40  * so the port is left configured for this.
41  *
42  * Devices are selected using Chip Selects on GPIOs.
43  */
44
45 /*
46  *  ADS7846 Routines
47  */
48 unsigned long corgi_ssp_ads7846_putget(ulong data)
49 {
50         unsigned long flag;
51         u32 ret = 0;
52
53         spin_lock_irqsave(&corgi_ssp_lock, flag);
54         if (ssp_machinfo->cs_ads7846 >= 0)
55                 GPCR(ssp_machinfo->cs_ads7846) = GPIO_bit(ssp_machinfo->cs_ads7846);
56
57         ssp_write_word(&corgi_ssp_dev,data);
58         ssp_read_word(&corgi_ssp_dev, &ret);
59
60         if (ssp_machinfo->cs_ads7846 >= 0)
61                 GPSR(ssp_machinfo->cs_ads7846) = GPIO_bit(ssp_machinfo->cs_ads7846);
62         spin_unlock_irqrestore(&corgi_ssp_lock, flag);
63
64         return ret;
65 }
66
67 /*
68  * NOTE: These functions should always be called in interrupt context
69  * and use the _lock and _unlock functions. They are very time sensitive.
70  */
71 void corgi_ssp_ads7846_lock(void)
72 {
73         spin_lock(&corgi_ssp_lock);
74         if (ssp_machinfo->cs_ads7846 >= 0)
75                 GPCR(ssp_machinfo->cs_ads7846) = GPIO_bit(ssp_machinfo->cs_ads7846);
76 }
77
78 void corgi_ssp_ads7846_unlock(void)
79 {
80         if (ssp_machinfo->cs_ads7846 >= 0)
81                 GPSR(ssp_machinfo->cs_ads7846) = GPIO_bit(ssp_machinfo->cs_ads7846);
82         spin_unlock(&corgi_ssp_lock);
83 }
84
85 void corgi_ssp_ads7846_put(ulong data)
86 {
87         ssp_write_word(&corgi_ssp_dev,data);
88 }
89
90 unsigned long corgi_ssp_ads7846_get(void)
91 {
92         u32 ret = 0;
93         ssp_read_word(&corgi_ssp_dev, &ret);
94         return ret;
95 }
96
97 EXPORT_SYMBOL(corgi_ssp_ads7846_putget);
98 EXPORT_SYMBOL(corgi_ssp_ads7846_lock);
99 EXPORT_SYMBOL(corgi_ssp_ads7846_unlock);
100 EXPORT_SYMBOL(corgi_ssp_ads7846_put);
101 EXPORT_SYMBOL(corgi_ssp_ads7846_get);
102
103
104 /*
105  *  LCD/Backlight Routines
106  */
107 unsigned long corgi_ssp_dac_put(ulong data)
108 {
109         unsigned long flag, sscr1 = SSCR1_SPH;
110         u32 tmp;
111
112         spin_lock_irqsave(&corgi_ssp_lock, flag);
113
114         if (machine_is_spitz() || machine_is_akita() || machine_is_borzoi())
115                 sscr1 = 0;
116
117         ssp_disable(&corgi_ssp_dev);
118         ssp_config(&corgi_ssp_dev, (SSCR0_Motorola | (SSCR0_DSS & 0x07 )), sscr1, 0, SSCR0_SerClkDiv(ssp_machinfo->clk_lcdcon));
119         ssp_enable(&corgi_ssp_dev);
120
121         if (ssp_machinfo->cs_lcdcon >= 0)
122                 GPCR(ssp_machinfo->cs_lcdcon) = GPIO_bit(ssp_machinfo->cs_lcdcon);
123         ssp_write_word(&corgi_ssp_dev,data);
124         /* Read null data back from device to prevent SSP overflow */
125         ssp_read_word(&corgi_ssp_dev, &tmp);
126         if (ssp_machinfo->cs_lcdcon >= 0)
127                 GPSR(ssp_machinfo->cs_lcdcon) = GPIO_bit(ssp_machinfo->cs_lcdcon);
128
129         ssp_disable(&corgi_ssp_dev);
130         ssp_config(&corgi_ssp_dev, (SSCR0_National | (SSCR0_DSS & 0x0b )), 0, 0, SSCR0_SerClkDiv(ssp_machinfo->clk_ads7846));
131         ssp_enable(&corgi_ssp_dev);
132
133         spin_unlock_irqrestore(&corgi_ssp_lock, flag);
134
135         return 0;
136 }
137
138 void corgi_ssp_lcdtg_send(u8 adrs, u8 data)
139 {
140         corgi_ssp_dac_put(((adrs & 0x07) << 5) | (data & 0x1f));
141 }
142
143 void corgi_ssp_blduty_set(int duty)
144 {
145         corgi_ssp_lcdtg_send(0x02,duty);
146 }
147
148 EXPORT_SYMBOL(corgi_ssp_lcdtg_send);
149 EXPORT_SYMBOL(corgi_ssp_blduty_set);
150
151 /*
152  *  Max1111 Routines
153  */
154 int corgi_ssp_max1111_get(ulong data)
155 {
156         unsigned long flag;
157         long voltage = 0, voltage1 = 0, voltage2 = 0;
158
159         spin_lock_irqsave(&corgi_ssp_lock, flag);
160         if (ssp_machinfo->cs_max1111 >= 0)
161                 GPCR(ssp_machinfo->cs_max1111) = GPIO_bit(ssp_machinfo->cs_max1111);
162         ssp_disable(&corgi_ssp_dev);
163         ssp_config(&corgi_ssp_dev, (SSCR0_Motorola | (SSCR0_DSS & 0x07 )), 0, 0, SSCR0_SerClkDiv(ssp_machinfo->clk_max1111));
164         ssp_enable(&corgi_ssp_dev);
165
166         udelay(1);
167
168         /* TB1/RB1 */
169         ssp_write_word(&corgi_ssp_dev,data);
170         ssp_read_word(&corgi_ssp_dev, (u32*)&voltage1); /* null read */
171
172         /* TB12/RB2 */
173         ssp_write_word(&corgi_ssp_dev,0);
174         ssp_read_word(&corgi_ssp_dev, (u32*)&voltage1);
175
176         /* TB13/RB3*/
177         ssp_write_word(&corgi_ssp_dev,0);
178         ssp_read_word(&corgi_ssp_dev, (u32*)&voltage2);
179
180         ssp_disable(&corgi_ssp_dev);
181         ssp_config(&corgi_ssp_dev, (SSCR0_National | (SSCR0_DSS & 0x0b )), 0, 0, SSCR0_SerClkDiv(ssp_machinfo->clk_ads7846));
182         ssp_enable(&corgi_ssp_dev);
183         if (ssp_machinfo->cs_max1111 >= 0)
184                 GPSR(ssp_machinfo->cs_max1111) = GPIO_bit(ssp_machinfo->cs_max1111);
185         spin_unlock_irqrestore(&corgi_ssp_lock, flag);
186
187         if (voltage1 & 0xc0 || voltage2 & 0x3f)
188                 voltage = -1;
189         else
190                 voltage = ((voltage1 << 2) & 0xfc) | ((voltage2 >> 6) & 0x03);
191
192         return voltage;
193 }
194
195 EXPORT_SYMBOL(corgi_ssp_max1111_get);
196
197 /*
198  *  Support Routines
199  */
200
201 void __init corgi_ssp_set_machinfo(struct corgissp_machinfo *machinfo)
202 {
203         ssp_machinfo = machinfo;
204 }
205
206 static int __devinit corgi_ssp_probe(struct platform_device *dev)
207 {
208         int ret;
209
210         /* Chip Select - Disable All */
211         if (ssp_machinfo->cs_lcdcon >= 0)
212                 pxa_gpio_mode(ssp_machinfo->cs_lcdcon  | GPIO_OUT | GPIO_DFLT_HIGH);
213         if (ssp_machinfo->cs_max1111 >= 0)
214                 pxa_gpio_mode(ssp_machinfo->cs_max1111 | GPIO_OUT | GPIO_DFLT_HIGH);
215         if (ssp_machinfo->cs_ads7846 >= 0)
216                 pxa_gpio_mode(ssp_machinfo->cs_ads7846 | GPIO_OUT | GPIO_DFLT_HIGH);
217
218         ret = ssp_init(&corgi_ssp_dev, ssp_machinfo->port, 0);
219
220         if (ret)
221                 printk(KERN_ERR "Unable to register SSP handler!\n");
222         else {
223                 ssp_disable(&corgi_ssp_dev);
224                 ssp_config(&corgi_ssp_dev, (SSCR0_National | (SSCR0_DSS & 0x0b )), 0, 0, SSCR0_SerClkDiv(ssp_machinfo->clk_ads7846));
225                 ssp_enable(&corgi_ssp_dev);
226         }
227
228         return ret;
229 }
230
231 static int corgi_ssp_remove(struct platform_device *dev)
232 {
233         ssp_exit(&corgi_ssp_dev);
234         return 0;
235 }
236
237 static int corgi_ssp_suspend(struct platform_device *dev, pm_message_t state)
238 {
239         ssp_flush(&corgi_ssp_dev);
240         ssp_save_state(&corgi_ssp_dev,&corgi_ssp_state);
241
242         return 0;
243 }
244
245 static int corgi_ssp_resume(struct platform_device *dev)
246 {
247         if (ssp_machinfo->cs_lcdcon >= 0)
248                 GPSR(ssp_machinfo->cs_lcdcon) = GPIO_bit(ssp_machinfo->cs_lcdcon);  /* High - Disable LCD Control/Timing Gen */
249         if (ssp_machinfo->cs_max1111 >= 0)
250                 GPSR(ssp_machinfo->cs_max1111) = GPIO_bit(ssp_machinfo->cs_max1111); /* High - Disable MAX1111*/
251         if (ssp_machinfo->cs_ads7846 >= 0)
252                 GPSR(ssp_machinfo->cs_ads7846) = GPIO_bit(ssp_machinfo->cs_ads7846); /* High - Disable ADS7846*/
253         ssp_restore_state(&corgi_ssp_dev,&corgi_ssp_state);
254         ssp_enable(&corgi_ssp_dev);
255
256         return 0;
257 }
258
259 static struct platform_driver corgissp_driver = {
260         .probe          = corgi_ssp_probe,
261         .remove         = corgi_ssp_remove,
262         .suspend        = corgi_ssp_suspend,
263         .resume         = corgi_ssp_resume,
264         .driver         = {
265                 .name   = "corgi-ssp",
266         },
267 };
268
269 int __init corgi_ssp_init(void)
270 {
271         return platform_driver_register(&corgissp_driver);
272 }
273
274 arch_initcall(corgi_ssp_init);