1
2
3
4
5
6
7
8
9
10
11#include <linux/kernel.h>
12#include <linux/spinlock.h>
13#include <linux/module.h>
14#include <linux/platform_device.h>
15#include <linux/gpio.h>
16#include <linux/io.h>
17#include <linux/cs5535.h>
18#include <asm/msr.h>
19
20#define DRV_NAME "cs5535-gpio"
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39#define GPIO_DEFAULT_MASK 0x0F7FFFFF
40
41static ulong mask = GPIO_DEFAULT_MASK;
42module_param_named(mask, mask, ulong, 0444);
43MODULE_PARM_DESC(mask, "GPIO channel mask.");
44
45static struct cs5535_gpio_chip {
46 struct gpio_chip chip;
47 resource_size_t base;
48
49 struct platform_device *pdev;
50 spinlock_t lock;
51} cs5535_gpio_chip;
52
53
54
55
56
57
58
59static void errata_outl(struct cs5535_gpio_chip *chip, u32 val,
60 unsigned int reg)
61{
62 unsigned long addr = chip->base + 0x80 + reg;
63
64
65
66
67
68
69
70
71
72
73 if (reg != GPIO_POSITIVE_EDGE_STS && reg != GPIO_NEGATIVE_EDGE_STS) {
74 if (val & 0xffff)
75 val |= (inl(addr) & 0xffff);
76 else
77 val |= (inl(addr) ^ (val >> 16));
78 }
79 outl(val, addr);
80}
81
82static void __cs5535_gpio_set(struct cs5535_gpio_chip *chip, unsigned offset,
83 unsigned int reg)
84{
85 if (offset < 16)
86
87 outl(1 << offset, chip->base + reg);
88 else
89
90 errata_outl(chip, 1 << (offset - 16), reg);
91}
92
93void cs5535_gpio_set(unsigned offset, unsigned int reg)
94{
95 struct cs5535_gpio_chip *chip = &cs5535_gpio_chip;
96 unsigned long flags;
97
98 spin_lock_irqsave(&chip->lock, flags);
99 __cs5535_gpio_set(chip, offset, reg);
100 spin_unlock_irqrestore(&chip->lock, flags);
101}
102EXPORT_SYMBOL_GPL(cs5535_gpio_set);
103
104static void __cs5535_gpio_clear(struct cs5535_gpio_chip *chip, unsigned offset,
105 unsigned int reg)
106{
107 if (offset < 16)
108
109 outl(1 << (offset + 16), chip->base + reg);
110 else
111
112 errata_outl(chip, 1 << offset, reg);
113}
114
115void cs5535_gpio_clear(unsigned offset, unsigned int reg)
116{
117 struct cs5535_gpio_chip *chip = &cs5535_gpio_chip;
118 unsigned long flags;
119
120 spin_lock_irqsave(&chip->lock, flags);
121 __cs5535_gpio_clear(chip, offset, reg);
122 spin_unlock_irqrestore(&chip->lock, flags);
123}
124EXPORT_SYMBOL_GPL(cs5535_gpio_clear);
125
126int cs5535_gpio_isset(unsigned offset, unsigned int reg)
127{
128 struct cs5535_gpio_chip *chip = &cs5535_gpio_chip;
129 unsigned long flags;
130 long val;
131
132 spin_lock_irqsave(&chip->lock, flags);
133 if (offset < 16)
134
135 val = inl(chip->base + reg);
136 else {
137
138 val = inl(chip->base + 0x80 + reg);
139 offset -= 16;
140 }
141 spin_unlock_irqrestore(&chip->lock, flags);
142
143 return (val & (1 << offset)) ? 1 : 0;
144}
145EXPORT_SYMBOL_GPL(cs5535_gpio_isset);
146
147int cs5535_gpio_set_irq(unsigned group, unsigned irq)
148{
149 uint32_t lo, hi;
150
151 if (group > 7 || irq > 15)
152 return -EINVAL;
153
154 rdmsr(MSR_PIC_ZSEL_HIGH, lo, hi);
155
156 lo &= ~(0xF << (group * 4));
157 lo |= (irq & 0xF) << (group * 4);
158
159 wrmsr(MSR_PIC_ZSEL_HIGH, lo, hi);
160 return 0;
161}
162EXPORT_SYMBOL_GPL(cs5535_gpio_set_irq);
163
164void cs5535_gpio_setup_event(unsigned offset, int pair, int pme)
165{
166 struct cs5535_gpio_chip *chip = &cs5535_gpio_chip;
167 uint32_t shift = (offset % 8) * 4;
168 unsigned long flags;
169 uint32_t val;
170
171 if (offset >= 24)
172 offset = GPIO_MAP_W;
173 else if (offset >= 16)
174 offset = GPIO_MAP_Z;
175 else if (offset >= 8)
176 offset = GPIO_MAP_Y;
177 else
178 offset = GPIO_MAP_X;
179
180 spin_lock_irqsave(&chip->lock, flags);
181 val = inl(chip->base + offset);
182
183
184 val &= ~(0xF << shift);
185
186
187 val |= ((pair & 7) << shift);
188
189
190 if (pme)
191 val |= (1 << (shift + 3));
192
193 outl(val, chip->base + offset);
194 spin_unlock_irqrestore(&chip->lock, flags);
195}
196EXPORT_SYMBOL_GPL(cs5535_gpio_setup_event);
197
198
199
200
201
202static int chip_gpio_request(struct gpio_chip *c, unsigned offset)
203{
204 struct cs5535_gpio_chip *chip = (struct cs5535_gpio_chip *) c;
205 unsigned long flags;
206
207 spin_lock_irqsave(&chip->lock, flags);
208
209
210 if ((mask & (1 << offset)) == 0) {
211 dev_info(&chip->pdev->dev,
212 "pin %u is not available (check mask)\n", offset);
213 spin_unlock_irqrestore(&chip->lock, flags);
214 return -EINVAL;
215 }
216
217
218 __cs5535_gpio_clear(chip, offset, GPIO_OUTPUT_AUX1);
219 __cs5535_gpio_clear(chip, offset, GPIO_OUTPUT_AUX2);
220
221
222 __cs5535_gpio_clear(chip, offset, GPIO_INPUT_AUX1);
223
224 spin_unlock_irqrestore(&chip->lock, flags);
225
226 return 0;
227}
228
229static int chip_gpio_get(struct gpio_chip *chip, unsigned offset)
230{
231 return cs5535_gpio_isset(offset, GPIO_READ_BACK);
232}
233
234static void chip_gpio_set(struct gpio_chip *chip, unsigned offset, int val)
235{
236 if (val)
237 cs5535_gpio_set(offset, GPIO_OUTPUT_VAL);
238 else
239 cs5535_gpio_clear(offset, GPIO_OUTPUT_VAL);
240}
241
242static int chip_direction_input(struct gpio_chip *c, unsigned offset)
243{
244 struct cs5535_gpio_chip *chip = (struct cs5535_gpio_chip *) c;
245 unsigned long flags;
246
247 spin_lock_irqsave(&chip->lock, flags);
248 __cs5535_gpio_set(chip, offset, GPIO_INPUT_ENABLE);
249 __cs5535_gpio_clear(chip, offset, GPIO_OUTPUT_ENABLE);
250 spin_unlock_irqrestore(&chip->lock, flags);
251
252 return 0;
253}
254
255static int chip_direction_output(struct gpio_chip *c, unsigned offset, int val)
256{
257 struct cs5535_gpio_chip *chip = (struct cs5535_gpio_chip *) c;
258 unsigned long flags;
259
260 spin_lock_irqsave(&chip->lock, flags);
261
262 __cs5535_gpio_set(chip, offset, GPIO_INPUT_ENABLE);
263 __cs5535_gpio_set(chip, offset, GPIO_OUTPUT_ENABLE);
264 if (val)
265 __cs5535_gpio_set(chip, offset, GPIO_OUTPUT_VAL);
266 else
267 __cs5535_gpio_clear(chip, offset, GPIO_OUTPUT_VAL);
268
269 spin_unlock_irqrestore(&chip->lock, flags);
270
271 return 0;
272}
273
274static const char * const cs5535_gpio_names[] = {
275 "GPIO0", "GPIO1", "GPIO2", "GPIO3",
276 "GPIO4", "GPIO5", "GPIO6", "GPIO7",
277 "GPIO8", "GPIO9", "GPIO10", "GPIO11",
278 "GPIO12", "GPIO13", "GPIO14", "GPIO15",
279 "GPIO16", "GPIO17", "GPIO18", "GPIO19",
280 "GPIO20", "GPIO21", "GPIO22", NULL,
281 "GPIO24", "GPIO25", "GPIO26", "GPIO27",
282 "GPIO28", NULL, NULL, NULL,
283};
284
285static struct cs5535_gpio_chip cs5535_gpio_chip = {
286 .chip = {
287 .owner = THIS_MODULE,
288 .label = DRV_NAME,
289
290 .base = 0,
291 .ngpio = 32,
292 .names = cs5535_gpio_names,
293 .request = chip_gpio_request,
294
295 .get = chip_gpio_get,
296 .set = chip_gpio_set,
297
298 .direction_input = chip_direction_input,
299 .direction_output = chip_direction_output,
300 },
301};
302
303static int __devinit cs5535_gpio_probe(struct platform_device *pdev)
304{
305 struct resource *res;
306 int err = -EIO;
307 ulong mask_orig = mask;
308
309
310
311
312
313
314
315
316 res = platform_get_resource(pdev, IORESOURCE_IO, 0);
317 if (!res) {
318 dev_err(&pdev->dev, "can't fetch device resource info\n");
319 goto done;
320 }
321
322 if (!request_region(res->start, resource_size(res), pdev->name)) {
323 dev_err(&pdev->dev, "can't request region\n");
324 goto done;
325 }
326
327
328 cs5535_gpio_chip.base = res->start;
329 cs5535_gpio_chip.pdev = pdev;
330 spin_lock_init(&cs5535_gpio_chip.lock);
331
332 dev_info(&pdev->dev, "reserved resource region %pR\n", res);
333
334
335 mask &= 0x1F7FFFFF;
336
337
338
339 mask &= ~(1 << 28);
340
341 if (mask_orig != mask)
342 dev_info(&pdev->dev, "mask changed from 0x%08lX to 0x%08lX\n",
343 mask_orig, mask);
344
345
346 err = gpiochip_add(&cs5535_gpio_chip.chip);
347 if (err)
348 goto release_region;
349
350 dev_info(&pdev->dev, "GPIO support successfully loaded.\n");
351 return 0;
352
353release_region:
354 release_region(res->start, resource_size(res));
355done:
356 return err;
357}
358
359static int __devexit cs5535_gpio_remove(struct platform_device *pdev)
360{
361 struct resource *r;
362 int err;
363
364 err = gpiochip_remove(&cs5535_gpio_chip.chip);
365 if (err) {
366
367 dev_err(&pdev->dev, "unable to remove gpio_chip?\n");
368 return err;
369 }
370
371 r = platform_get_resource(pdev, IORESOURCE_IO, 0);
372 release_region(r->start, resource_size(r));
373 return 0;
374}
375
376static struct platform_driver cs5535_gpio_drv = {
377 .driver = {
378 .name = DRV_NAME,
379 .owner = THIS_MODULE,
380 },
381 .probe = cs5535_gpio_probe,
382 .remove = __devexit_p(cs5535_gpio_remove),
383};
384
385static int __init cs5535_gpio_init(void)
386{
387 return platform_driver_register(&cs5535_gpio_drv);
388}
389
390static void __exit cs5535_gpio_exit(void)
391{
392 platform_driver_unregister(&cs5535_gpio_drv);
393}
394
395module_init(cs5535_gpio_init);
396module_exit(cs5535_gpio_exit);
397
398MODULE_AUTHOR("Andres Salomon <dilinger@queued.net>");
399MODULE_DESCRIPTION("AMD CS5535/CS5536 GPIO driver");
400MODULE_LICENSE("GPL");
401MODULE_ALIAS("platform:" DRV_NAME);
402