xref: /openbmc/linux/arch/arm/common/scoop.c (revision e23feb16)
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 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 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		= 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);
285