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