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