0c616d5fcb0f7bf3a6811ea08f7fd2dcc63c819b
[linux-3.10.git] / arch / arm / common / scoop.c
1 /*
2  * Support code for the SCOOP interface found on various Sharp PDAs
3  *
4  * Copyright (c) 2004 Richard Purdie
5  *
6  *      Based on code written by Sharp/Lineo for 2.4 kernels
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License version 2 as
10  * published by the Free Software Foundation.
11  *
12  */
13
14 #include <linux/device.h>
15 #include <linux/gpio.h>
16 #include <linux/string.h>
17 #include <linux/slab.h>
18 #include <linux/platform_device.h>
19 #include <linux/export.h>
20 #include <linux/io.h>
21 #include <asm/hardware/scoop.h>
22
23 /* PCMCIA to Scoop linkage
24
25    There is no easy way to link multiple scoop devices into one
26    single entity for the pxa2xx_pcmcia device so this structure
27    is used which is setup by the platform code.
28
29    This file is never modular so this symbol is always
30    accessile to the board support files.
31 */
32 struct scoop_pcmcia_config *platform_scoop_config;
33 EXPORT_SYMBOL(platform_scoop_config);
34
35 struct  scoop_dev {
36         void __iomem *base;
37         struct gpio_chip gpio;
38         spinlock_t scoop_lock;
39         unsigned short suspend_clr;
40         unsigned short suspend_set;
41         u32 scoop_gpwr;
42 };
43
44 void reset_scoop(struct device *dev)
45 {
46         struct scoop_dev *sdev = dev_get_drvdata(dev);
47
48         iowrite16(0x0100, sdev->base + SCOOP_MCR);  /* 00 */
49         iowrite16(0x0000, sdev->base + SCOOP_CDR);  /* 04 */
50         iowrite16(0x0000, sdev->base + SCOOP_CCR);  /* 10 */
51         iowrite16(0x0000, sdev->base + SCOOP_IMR);  /* 18 */
52         iowrite16(0x00FF, sdev->base + SCOOP_IRM);  /* 14 */
53         iowrite16(0x0000, sdev->base + SCOOP_ISR);  /* 1C */
54         iowrite16(0x0000, sdev->base + SCOOP_IRM);
55 }
56
57 static void __scoop_gpio_set(struct scoop_dev *sdev,
58                         unsigned offset, int value)
59 {
60         unsigned short gpwr;
61
62         gpwr = ioread16(sdev->base + SCOOP_GPWR);
63         if (value)
64                 gpwr |= 1 << (offset + 1);
65         else
66                 gpwr &= ~(1 << (offset + 1));
67         iowrite16(gpwr, sdev->base + SCOOP_GPWR);
68 }
69
70 static void scoop_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
71 {
72         struct scoop_dev *sdev = container_of(chip, struct scoop_dev, gpio);
73         unsigned long flags;
74
75         spin_lock_irqsave(&sdev->scoop_lock, flags);
76
77         __scoop_gpio_set(sdev, offset, value);
78
79         spin_unlock_irqrestore(&sdev->scoop_lock, flags);
80 }
81
82 static int scoop_gpio_get(struct gpio_chip *chip, unsigned offset)
83 {
84         struct scoop_dev *sdev = container_of(chip, struct scoop_dev, gpio);
85
86         /* XXX: I'm unsure, but it seems so */
87         return ioread16(sdev->base + SCOOP_GPRR) & (1 << (offset + 1));
88 }
89
90 static int scoop_gpio_direction_input(struct gpio_chip *chip,
91                         unsigned offset)
92 {
93         struct scoop_dev *sdev = container_of(chip, struct scoop_dev, gpio);
94         unsigned long flags;
95         unsigned short gpcr;
96
97         spin_lock_irqsave(&sdev->scoop_lock, flags);
98
99         gpcr = ioread16(sdev->base + SCOOP_GPCR);
100         gpcr &= ~(1 << (offset + 1));
101         iowrite16(gpcr, sdev->base + SCOOP_GPCR);
102
103         spin_unlock_irqrestore(&sdev->scoop_lock, flags);
104
105         return 0;
106 }
107
108 static int scoop_gpio_direction_output(struct gpio_chip *chip,
109                         unsigned offset, int value)
110 {
111         struct scoop_dev *sdev = container_of(chip, struct scoop_dev, gpio);
112         unsigned long flags;
113         unsigned short gpcr;
114
115         spin_lock_irqsave(&sdev->scoop_lock, flags);
116
117         __scoop_gpio_set(sdev, offset, value);
118
119         gpcr = ioread16(sdev->base + SCOOP_GPCR);
120         gpcr |= 1 << (offset + 1);
121         iowrite16(gpcr, sdev->base + SCOOP_GPCR);
122
123         spin_unlock_irqrestore(&sdev->scoop_lock, flags);
124
125         return 0;
126 }
127
128 unsigned short read_scoop_reg(struct device *dev, unsigned short reg)
129 {
130         struct scoop_dev *sdev = dev_get_drvdata(dev);
131         return ioread16(sdev->base + reg);
132 }
133
134 void write_scoop_reg(struct device *dev, unsigned short reg, unsigned short data)
135 {
136         struct scoop_dev *sdev = dev_get_drvdata(dev);
137         iowrite16(data, sdev->base + reg);
138 }
139
140 EXPORT_SYMBOL(reset_scoop);
141 EXPORT_SYMBOL(read_scoop_reg);
142 EXPORT_SYMBOL(write_scoop_reg);
143
144 #ifdef CONFIG_PM
145 static void check_scoop_reg(struct scoop_dev *sdev)
146 {
147         unsigned short mcr;
148
149         mcr = ioread16(sdev->base + SCOOP_MCR);
150         if ((mcr & 0x100) == 0)
151                 iowrite16(0x0101, sdev->base + SCOOP_MCR);
152 }
153
154 static int scoop_suspend(struct platform_device *dev, pm_message_t state)
155 {
156         struct scoop_dev *sdev = platform_get_drvdata(dev);
157
158         check_scoop_reg(sdev);
159         sdev->scoop_gpwr = ioread16(sdev->base + SCOOP_GPWR);
160         iowrite16((sdev->scoop_gpwr & ~sdev->suspend_clr) | sdev->suspend_set, sdev->base + SCOOP_GPWR);
161
162         return 0;
163 }
164
165 static int scoop_resume(struct platform_device *dev)
166 {
167         struct scoop_dev *sdev = platform_get_drvdata(dev);
168
169         check_scoop_reg(sdev);
170         iowrite16(sdev->scoop_gpwr, sdev->base + SCOOP_GPWR);
171
172         return 0;
173 }
174 #else
175 #define scoop_suspend   NULL
176 #define scoop_resume    NULL
177 #endif
178
179 static int __devinit scoop_probe(struct platform_device *pdev)
180 {
181         struct scoop_dev *devptr;
182         struct scoop_config *inf;
183         struct resource *mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
184         int ret;
185         int temp;
186
187         if (!mem)
188                 return -EINVAL;
189
190         devptr = kzalloc(sizeof(struct scoop_dev), GFP_KERNEL);
191         if (!devptr)
192                 return -ENOMEM;
193
194         spin_lock_init(&devptr->scoop_lock);
195
196         inf = pdev->dev.platform_data;
197         devptr->base = ioremap(mem->start, resource_size(mem));
198
199         if (!devptr->base) {
200                 ret = -ENOMEM;
201                 goto err_ioremap;
202         }
203
204         platform_set_drvdata(pdev, devptr);
205
206         printk("Sharp Scoop Device found at 0x%08x -> 0x%8p\n",(unsigned int)mem->start, devptr->base);
207
208         iowrite16(0x0140, devptr->base + SCOOP_MCR);
209         reset_scoop(&pdev->dev);
210         iowrite16(0x0000, devptr->base + SCOOP_CPR);
211         iowrite16(inf->io_dir & 0xffff, devptr->base + SCOOP_GPCR);
212         iowrite16(inf->io_out & 0xffff, devptr->base + SCOOP_GPWR);
213
214         devptr->suspend_clr = inf->suspend_clr;
215         devptr->suspend_set = inf->suspend_set;
216
217         devptr->gpio.base = -1;
218
219         if (inf->gpio_base != 0) {
220                 devptr->gpio.label = dev_name(&pdev->dev);
221                 devptr->gpio.base = inf->gpio_base;
222                 devptr->gpio.ngpio = 12; /* PA11 = 0, PA12 = 1, etc. up to PA22 = 11 */
223                 devptr->gpio.set = scoop_gpio_set;
224                 devptr->gpio.get = scoop_gpio_get;
225                 devptr->gpio.direction_input = scoop_gpio_direction_input;
226                 devptr->gpio.direction_output = scoop_gpio_direction_output;
227
228                 ret = gpiochip_add(&devptr->gpio);
229                 if (ret)
230                         goto err_gpio;
231         }
232
233         return 0;
234
235         if (devptr->gpio.base != -1)
236                 temp = gpiochip_remove(&devptr->gpio);
237 err_gpio:
238         platform_set_drvdata(pdev, NULL);
239 err_ioremap:
240         iounmap(devptr->base);
241         kfree(devptr);
242
243         return ret;
244 }
245
246 static int __devexit scoop_remove(struct platform_device *pdev)
247 {
248         struct scoop_dev *sdev = platform_get_drvdata(pdev);
249         int ret;
250
251         if (!sdev)
252                 return -EINVAL;
253
254         if (sdev->gpio.base != -1) {
255                 ret = gpiochip_remove(&sdev->gpio);
256                 if (ret) {
257                         dev_err(&pdev->dev, "Can't remove gpio chip: %d\n", ret);
258                         return ret;
259                 }
260         }
261
262         platform_set_drvdata(pdev, NULL);
263         iounmap(sdev->base);
264         kfree(sdev);
265
266         return 0;
267 }
268
269 static struct platform_driver scoop_driver = {
270         .probe          = scoop_probe,
271         .remove         = __devexit_p(scoop_remove),
272         .suspend        = scoop_suspend,
273         .resume         = scoop_resume,
274         .driver         = {
275                 .name   = "sharp-scoop",
276         },
277 };
278
279 static int __init scoop_init(void)
280 {
281         return platform_driver_register(&scoop_driver);
282 }
283
284 subsys_initcall(scoop_init);