Merge git://git.kernel.org/pub/scm/linux/kernel/git/bart/ide-2.6
[linux-2.6] / drivers / char / vr41xx_giu.c
1 /*
2  *  Driver for NEC VR4100 series General-purpose I/O Unit.
3  *
4  *  Copyright (C) 2002 MontaVista Software Inc.
5  *      Author: Yoichi Yuasa <yyuasa@mvista.com or source@mvista.com>
6  *  Copyright (C) 2003-2007  Yoichi Yuasa <yoichi_yuasa@tripeaks.co.jp>
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 as published by
10  *  the Free Software Foundation; either version 2 of the License, or
11  *  (at your option) any later version.
12  *
13  *  This program is distributed in the hope that it will be useful,
14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  *  GNU General Public License for more details.
17  *
18  *  You should have received a copy of the GNU General Public License
19  *  along with this program; if not, write to the Free Software
20  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
21  */
22 #include <linux/errno.h>
23 #include <linux/fs.h>
24 #include <linux/init.h>
25 #include <linux/interrupt.h>
26 #include <linux/irq.h>
27 #include <linux/kernel.h>
28 #include <linux/module.h>
29 #include <linux/platform_device.h>
30 #include <linux/smp_lock.h>
31 #include <linux/spinlock.h>
32 #include <linux/types.h>
33
34 #include <asm/io.h>
35 #include <asm/vr41xx/giu.h>
36 #include <asm/vr41xx/irq.h>
37 #include <asm/vr41xx/vr41xx.h>
38
39 MODULE_AUTHOR("Yoichi Yuasa <yoichi_yuasa@tripeaks.co.jp>");
40 MODULE_DESCRIPTION("NEC VR4100 series General-purpose I/O Unit driver");
41 MODULE_LICENSE("GPL");
42
43 static int major;       /* default is dynamic major device number */
44 module_param(major, int, 0);
45 MODULE_PARM_DESC(major, "Major device number");
46
47 #define GIUIOSELL       0x00
48 #define GIUIOSELH       0x02
49 #define GIUPIODL        0x04
50 #define GIUPIODH        0x06
51 #define GIUINTSTATL     0x08
52 #define GIUINTSTATH     0x0a
53 #define GIUINTENL       0x0c
54 #define GIUINTENH       0x0e
55 #define GIUINTTYPL      0x10
56 #define GIUINTTYPH      0x12
57 #define GIUINTALSELL    0x14
58 #define GIUINTALSELH    0x16
59 #define GIUINTHTSELL    0x18
60 #define GIUINTHTSELH    0x1a
61 #define GIUPODATL       0x1c
62 #define GIUPODATEN      0x1c
63 #define GIUPODATH       0x1e
64  #define PIOEN0         0x0100
65  #define PIOEN1         0x0200
66 #define GIUPODAT        0x1e
67 #define GIUFEDGEINHL    0x20
68 #define GIUFEDGEINHH    0x22
69 #define GIUREDGEINHL    0x24
70 #define GIUREDGEINHH    0x26
71
72 #define GIUUSEUPDN      0x1e0
73 #define GIUTERMUPDN     0x1e2
74
75 #define GPIO_HAS_PULLUPDOWN_IO          0x0001
76 #define GPIO_HAS_OUTPUT_ENABLE          0x0002
77 #define GPIO_HAS_INTERRUPT_EDGE_SELECT  0x0100
78
79 static spinlock_t giu_lock;
80 static unsigned long giu_flags;
81 static unsigned int giu_nr_pins;
82
83 static void __iomem *giu_base;
84
85 #define giu_read(offset)                readw(giu_base + (offset))
86 #define giu_write(offset, value)        writew((value), giu_base + (offset))
87
88 #define GPIO_PIN_OF_IRQ(irq)    ((irq) - GIU_IRQ_BASE)
89 #define GIUINT_HIGH_OFFSET      16
90 #define GIUINT_HIGH_MAX         32
91
92 static inline uint16_t giu_set(uint16_t offset, uint16_t set)
93 {
94         uint16_t data;
95
96         data = giu_read(offset);
97         data |= set;
98         giu_write(offset, data);
99
100         return data;
101 }
102
103 static inline uint16_t giu_clear(uint16_t offset, uint16_t clear)
104 {
105         uint16_t data;
106
107         data = giu_read(offset);
108         data &= ~clear;
109         giu_write(offset, data);
110
111         return data;
112 }
113
114 static void ack_giuint_low(unsigned int irq)
115 {
116         giu_write(GIUINTSTATL, 1 << GPIO_PIN_OF_IRQ(irq));
117 }
118
119 static void mask_giuint_low(unsigned int irq)
120 {
121         giu_clear(GIUINTENL, 1 << GPIO_PIN_OF_IRQ(irq));
122 }
123
124 static void mask_ack_giuint_low(unsigned int irq)
125 {
126         unsigned int pin;
127
128         pin = GPIO_PIN_OF_IRQ(irq);
129         giu_clear(GIUINTENL, 1 << pin);
130         giu_write(GIUINTSTATL, 1 << pin);
131 }
132
133 static void unmask_giuint_low(unsigned int irq)
134 {
135         giu_set(GIUINTENL, 1 << GPIO_PIN_OF_IRQ(irq));
136 }
137
138 static struct irq_chip giuint_low_irq_chip = {
139         .name           = "GIUINTL",
140         .ack            = ack_giuint_low,
141         .mask           = mask_giuint_low,
142         .mask_ack       = mask_ack_giuint_low,
143         .unmask         = unmask_giuint_low,
144 };
145
146 static void ack_giuint_high(unsigned int irq)
147 {
148         giu_write(GIUINTSTATH, 1 << (GPIO_PIN_OF_IRQ(irq) - GIUINT_HIGH_OFFSET));
149 }
150
151 static void mask_giuint_high(unsigned int irq)
152 {
153         giu_clear(GIUINTENH, 1 << (GPIO_PIN_OF_IRQ(irq) - GIUINT_HIGH_OFFSET));
154 }
155
156 static void mask_ack_giuint_high(unsigned int irq)
157 {
158         unsigned int pin;
159
160         pin = GPIO_PIN_OF_IRQ(irq) - GIUINT_HIGH_OFFSET;
161         giu_clear(GIUINTENH, 1 << pin);
162         giu_write(GIUINTSTATH, 1 << pin);
163 }
164
165 static void unmask_giuint_high(unsigned int irq)
166 {
167         giu_set(GIUINTENH, 1 << (GPIO_PIN_OF_IRQ(irq) - GIUINT_HIGH_OFFSET));
168 }
169
170 static struct irq_chip giuint_high_irq_chip = {
171         .name           = "GIUINTH",
172         .ack            = ack_giuint_high,
173         .mask           = mask_giuint_high,
174         .mask_ack       = mask_ack_giuint_high,
175         .unmask         = unmask_giuint_high,
176 };
177
178 static int giu_get_irq(unsigned int irq)
179 {
180         uint16_t pendl, pendh, maskl, maskh;
181         int i;
182
183         pendl = giu_read(GIUINTSTATL);
184         pendh = giu_read(GIUINTSTATH);
185         maskl = giu_read(GIUINTENL);
186         maskh = giu_read(GIUINTENH);
187
188         maskl &= pendl;
189         maskh &= pendh;
190
191         if (maskl) {
192                 for (i = 0; i < 16; i++) {
193                         if (maskl & (1 << i))
194                                 return GIU_IRQ(i);
195                 }
196         } else if (maskh) {
197                 for (i = 0; i < 16; i++) {
198                         if (maskh & (1 << i))
199                                 return GIU_IRQ(i + GIUINT_HIGH_OFFSET);
200                 }
201         }
202
203         printk(KERN_ERR "spurious GIU interrupt: %04x(%04x),%04x(%04x)\n",
204                maskl, pendl, maskh, pendh);
205
206         atomic_inc(&irq_err_count);
207
208         return -EINVAL;
209 }
210
211 void vr41xx_set_irq_trigger(unsigned int pin, irq_trigger_t trigger, irq_signal_t signal)
212 {
213         uint16_t mask;
214
215         if (pin < GIUINT_HIGH_OFFSET) {
216                 mask = 1 << pin;
217                 if (trigger != IRQ_TRIGGER_LEVEL) {
218                         giu_set(GIUINTTYPL, mask);
219                         if (signal == IRQ_SIGNAL_HOLD)
220                                 giu_set(GIUINTHTSELL, mask);
221                         else
222                                 giu_clear(GIUINTHTSELL, mask);
223                         if (giu_flags & GPIO_HAS_INTERRUPT_EDGE_SELECT) {
224                                 switch (trigger) {
225                                 case IRQ_TRIGGER_EDGE_FALLING:
226                                         giu_set(GIUFEDGEINHL, mask);
227                                         giu_clear(GIUREDGEINHL, mask);
228                                         break;
229                                 case IRQ_TRIGGER_EDGE_RISING:
230                                         giu_clear(GIUFEDGEINHL, mask);
231                                         giu_set(GIUREDGEINHL, mask);
232                                         break;
233                                 default:
234                                         giu_set(GIUFEDGEINHL, mask);
235                                         giu_set(GIUREDGEINHL, mask);
236                                         break;
237                                 }
238                         }
239                         set_irq_chip_and_handler(GIU_IRQ(pin),
240                                                  &giuint_low_irq_chip,
241                                                  handle_edge_irq);
242                 } else {
243                         giu_clear(GIUINTTYPL, mask);
244                         giu_clear(GIUINTHTSELL, mask);
245                         set_irq_chip_and_handler(GIU_IRQ(pin),
246                                                  &giuint_low_irq_chip,
247                                                  handle_level_irq);
248                 }
249                 giu_write(GIUINTSTATL, mask);
250         } else if (pin < GIUINT_HIGH_MAX) {
251                 mask = 1 << (pin - GIUINT_HIGH_OFFSET);
252                 if (trigger != IRQ_TRIGGER_LEVEL) {
253                         giu_set(GIUINTTYPH, mask);
254                         if (signal == IRQ_SIGNAL_HOLD)
255                                 giu_set(GIUINTHTSELH, mask);
256                         else
257                                 giu_clear(GIUINTHTSELH, mask);
258                         if (giu_flags & GPIO_HAS_INTERRUPT_EDGE_SELECT) {
259                                 switch (trigger) {
260                                 case IRQ_TRIGGER_EDGE_FALLING:
261                                         giu_set(GIUFEDGEINHH, mask);
262                                         giu_clear(GIUREDGEINHH, mask);
263                                         break;
264                                 case IRQ_TRIGGER_EDGE_RISING:
265                                         giu_clear(GIUFEDGEINHH, mask);
266                                         giu_set(GIUREDGEINHH, mask);
267                                         break;
268                                 default:
269                                         giu_set(GIUFEDGEINHH, mask);
270                                         giu_set(GIUREDGEINHH, mask);
271                                         break;
272                                 }
273                         }
274                         set_irq_chip_and_handler(GIU_IRQ(pin),
275                                                  &giuint_high_irq_chip,
276                                                  handle_edge_irq);
277                 } else {
278                         giu_clear(GIUINTTYPH, mask);
279                         giu_clear(GIUINTHTSELH, mask);
280                         set_irq_chip_and_handler(GIU_IRQ(pin),
281                                                  &giuint_high_irq_chip,
282                                                  handle_level_irq);
283                 }
284                 giu_write(GIUINTSTATH, mask);
285         }
286 }
287 EXPORT_SYMBOL_GPL(vr41xx_set_irq_trigger);
288
289 void vr41xx_set_irq_level(unsigned int pin, irq_level_t level)
290 {
291         uint16_t mask;
292
293         if (pin < GIUINT_HIGH_OFFSET) {
294                 mask = 1 << pin;
295                 if (level == IRQ_LEVEL_HIGH)
296                         giu_set(GIUINTALSELL, mask);
297                 else
298                         giu_clear(GIUINTALSELL, mask);
299                 giu_write(GIUINTSTATL, mask);
300         } else if (pin < GIUINT_HIGH_MAX) {
301                 mask = 1 << (pin - GIUINT_HIGH_OFFSET);
302                 if (level == IRQ_LEVEL_HIGH)
303                         giu_set(GIUINTALSELH, mask);
304                 else
305                         giu_clear(GIUINTALSELH, mask);
306                 giu_write(GIUINTSTATH, mask);
307         }
308 }
309 EXPORT_SYMBOL_GPL(vr41xx_set_irq_level);
310
311 gpio_data_t vr41xx_gpio_get_pin(unsigned int pin)
312 {
313         uint16_t reg, mask;
314
315         if (pin >= giu_nr_pins)
316                 return GPIO_DATA_INVAL;
317
318         if (pin < 16) {
319                 reg = giu_read(GIUPIODL);
320                 mask = (uint16_t)1 << pin;
321         } else if (pin < 32) {
322                 reg = giu_read(GIUPIODH);
323                 mask = (uint16_t)1 << (pin - 16);
324         } else if (pin < 48) {
325                 reg = giu_read(GIUPODATL);
326                 mask = (uint16_t)1 << (pin - 32);
327         } else {
328                 reg = giu_read(GIUPODATH);
329                 mask = (uint16_t)1 << (pin - 48);
330         }
331
332         if (reg & mask)
333                 return GPIO_DATA_HIGH;
334
335         return GPIO_DATA_LOW;
336 }
337 EXPORT_SYMBOL_GPL(vr41xx_gpio_get_pin);
338
339 int vr41xx_gpio_set_pin(unsigned int pin, gpio_data_t data)
340 {
341         uint16_t offset, mask, reg;
342         unsigned long flags;
343
344         if (pin >= giu_nr_pins)
345                 return -EINVAL;
346
347         if (pin < 16) {
348                 offset = GIUPIODL;
349                 mask = (uint16_t)1 << pin;
350         } else if (pin < 32) {
351                 offset = GIUPIODH;
352                 mask = (uint16_t)1 << (pin - 16);
353         } else if (pin < 48) {
354                 offset = GIUPODATL;
355                 mask = (uint16_t)1 << (pin - 32);
356         } else {
357                 offset = GIUPODATH;
358                 mask = (uint16_t)1 << (pin - 48);
359         }
360
361         spin_lock_irqsave(&giu_lock, flags);
362
363         reg = giu_read(offset);
364         if (data == GPIO_DATA_HIGH)
365                 reg |= mask;
366         else
367                 reg &= ~mask;
368         giu_write(offset, reg);
369
370         spin_unlock_irqrestore(&giu_lock, flags);
371
372         return 0;
373 }
374 EXPORT_SYMBOL_GPL(vr41xx_gpio_set_pin);
375
376 int vr41xx_gpio_set_direction(unsigned int pin, gpio_direction_t dir)
377 {
378         uint16_t offset, mask, reg;
379         unsigned long flags;
380
381         if (pin >= giu_nr_pins)
382                 return -EINVAL;
383
384         if (pin < 16) {
385                 offset = GIUIOSELL;
386                 mask = (uint16_t)1 << pin;
387         } else if (pin < 32) {
388                 offset = GIUIOSELH;
389                 mask = (uint16_t)1 << (pin - 16);
390         } else {
391                 if (giu_flags & GPIO_HAS_OUTPUT_ENABLE) {
392                         offset = GIUPODATEN;
393                         mask = (uint16_t)1 << (pin - 32);
394                 } else {
395                         switch (pin) {
396                         case 48:
397                                 offset = GIUPODATH;
398                                 mask = PIOEN0;
399                                 break;
400                         case 49:
401                                 offset = GIUPODATH;
402                                 mask = PIOEN1;
403                                 break;
404                         default:
405                                 return -EINVAL;
406                         }
407                 }
408         }
409
410         spin_lock_irqsave(&giu_lock, flags);
411
412         reg = giu_read(offset);
413         if (dir == GPIO_OUTPUT)
414                 reg |= mask;
415         else
416                 reg &= ~mask;
417         giu_write(offset, reg);
418
419         spin_unlock_irqrestore(&giu_lock, flags);
420
421         return 0;
422 }
423 EXPORT_SYMBOL_GPL(vr41xx_gpio_set_direction);
424
425 int vr41xx_gpio_pullupdown(unsigned int pin, gpio_pull_t pull)
426 {
427         uint16_t reg, mask;
428         unsigned long flags;
429
430         if ((giu_flags & GPIO_HAS_PULLUPDOWN_IO) != GPIO_HAS_PULLUPDOWN_IO)
431                 return -EPERM;
432
433         if (pin >= 15)
434                 return -EINVAL;
435
436         mask = (uint16_t)1 << pin;
437
438         spin_lock_irqsave(&giu_lock, flags);
439
440         if (pull == GPIO_PULL_UP || pull == GPIO_PULL_DOWN) {
441                 reg = giu_read(GIUTERMUPDN);
442                 if (pull == GPIO_PULL_UP)
443                         reg |= mask;
444                 else
445                         reg &= ~mask;
446                 giu_write(GIUTERMUPDN, reg);
447
448                 reg = giu_read(GIUUSEUPDN);
449                 reg |= mask;
450                 giu_write(GIUUSEUPDN, reg);
451         } else {
452                 reg = giu_read(GIUUSEUPDN);
453                 reg &= ~mask;
454                 giu_write(GIUUSEUPDN, reg);
455         }
456
457         spin_unlock_irqrestore(&giu_lock, flags);
458
459         return 0;
460 }
461 EXPORT_SYMBOL_GPL(vr41xx_gpio_pullupdown);
462
463 static ssize_t gpio_read(struct file *file, char __user *buf, size_t len,
464                          loff_t *ppos)
465 {
466         unsigned int pin;
467         char value = '0';
468
469         pin = iminor(file->f_path.dentry->d_inode);
470         if (pin >= giu_nr_pins)
471                 return -EBADF;
472
473         if (vr41xx_gpio_get_pin(pin) == GPIO_DATA_HIGH)
474                 value = '1';
475
476         if (len <= 0)
477                 return -EFAULT;
478
479         if (put_user(value, buf))
480                 return -EFAULT;
481
482         return 1;
483 }
484
485 static ssize_t gpio_write(struct file *file, const char __user *data,
486                           size_t len, loff_t *ppos)
487 {
488         unsigned int pin;
489         size_t i;
490         char c;
491         int retval = 0;
492
493         pin = iminor(file->f_path.dentry->d_inode);
494         if (pin >= giu_nr_pins)
495                 return -EBADF;
496
497         for (i = 0; i < len; i++) {
498                 if (get_user(c, data + i))
499                         return -EFAULT;
500
501                 switch (c) {
502                 case '0':
503                         retval = vr41xx_gpio_set_pin(pin, GPIO_DATA_LOW);
504                         break;
505                 case '1':
506                         retval = vr41xx_gpio_set_pin(pin, GPIO_DATA_HIGH);
507                         break;
508                 case 'D':
509                         printk(KERN_INFO "GPIO%d: pull down\n", pin);
510                         retval = vr41xx_gpio_pullupdown(pin, GPIO_PULL_DOWN);
511                         break;
512                 case 'd':
513                         printk(KERN_INFO "GPIO%d: pull up/down disable\n", pin);
514                         retval = vr41xx_gpio_pullupdown(pin, GPIO_PULL_DISABLE);
515                         break;
516                 case 'I':
517                         printk(KERN_INFO "GPIO%d: input\n", pin);
518                         retval = vr41xx_gpio_set_direction(pin, GPIO_INPUT);
519                         break;
520                 case 'O':
521                         printk(KERN_INFO "GPIO%d: output\n", pin);
522                         retval = vr41xx_gpio_set_direction(pin, GPIO_OUTPUT);
523                         break;
524                 case 'o':
525                         printk(KERN_INFO "GPIO%d: output disable\n", pin);
526                         retval = vr41xx_gpio_set_direction(pin, GPIO_OUTPUT_DISABLE);
527                         break;
528                 case 'P':
529                         printk(KERN_INFO "GPIO%d: pull up\n", pin);
530                         retval = vr41xx_gpio_pullupdown(pin, GPIO_PULL_UP);
531                         break;
532                 case 'p':
533                         printk(KERN_INFO "GPIO%d: pull up/down disable\n", pin);
534                         retval = vr41xx_gpio_pullupdown(pin, GPIO_PULL_DISABLE);
535                         break;
536                 default:
537                         break;
538                 }
539
540                 if (retval < 0)
541                         break;
542         }
543
544         return i;
545 }
546
547 static int gpio_open(struct inode *inode, struct file *file)
548 {
549         unsigned int pin;
550
551         cycle_kernel_lock();
552         pin = iminor(inode);
553         if (pin >= giu_nr_pins)
554                 return -EBADF;
555
556         return nonseekable_open(inode, file);
557 }
558
559 static int gpio_release(struct inode *inode, struct file *file)
560 {
561         unsigned int pin;
562
563         pin = iminor(inode);
564         if (pin >= giu_nr_pins)
565                 return -EBADF;
566
567         return 0;
568 }
569
570 static const struct file_operations gpio_fops = {
571         .owner          = THIS_MODULE,
572         .read           = gpio_read,
573         .write          = gpio_write,
574         .open           = gpio_open,
575         .release        = gpio_release,
576 };
577
578 static int __devinit giu_probe(struct platform_device *dev)
579 {
580         struct resource *res;
581         unsigned int trigger, i, pin;
582         struct irq_chip *chip;
583         int irq, retval;
584
585         switch (dev->id) {
586         case GPIO_50PINS_PULLUPDOWN:
587                 giu_flags = GPIO_HAS_PULLUPDOWN_IO;
588                 giu_nr_pins = 50;
589                 break;
590         case GPIO_36PINS:
591                 giu_nr_pins = 36;
592                 break;
593         case GPIO_48PINS_EDGE_SELECT:
594                 giu_flags = GPIO_HAS_INTERRUPT_EDGE_SELECT;
595                 giu_nr_pins = 48;
596                 break;
597         default:
598                 printk(KERN_ERR "GIU: unknown ID %d\n", dev->id);
599                 return -ENODEV;
600         }
601
602         res = platform_get_resource(dev, IORESOURCE_MEM, 0);
603         if (!res)
604                 return -EBUSY;
605
606         giu_base = ioremap(res->start, res->end - res->start + 1);
607         if (!giu_base)
608                 return -ENOMEM;
609
610         retval = register_chrdev(major, "GIU", &gpio_fops);
611         if (retval < 0) {
612                 iounmap(giu_base);
613                 giu_base = NULL;
614                 return retval;
615         }
616
617         if (major == 0) {
618                 major = retval;
619                 printk(KERN_INFO "GIU: major number %d\n", major);
620         }
621
622         spin_lock_init(&giu_lock);
623
624         giu_write(GIUINTENL, 0);
625         giu_write(GIUINTENH, 0);
626
627         trigger = giu_read(GIUINTTYPH) << 16;
628         trigger |= giu_read(GIUINTTYPL);
629         for (i = GIU_IRQ_BASE; i <= GIU_IRQ_LAST; i++) {
630                 pin = GPIO_PIN_OF_IRQ(i);
631                 if (pin < GIUINT_HIGH_OFFSET)
632                         chip = &giuint_low_irq_chip;
633                 else
634                         chip = &giuint_high_irq_chip;
635
636                 if (trigger & (1 << pin))
637                         set_irq_chip_and_handler(i, chip, handle_edge_irq);
638                 else
639                         set_irq_chip_and_handler(i, chip, handle_level_irq);
640
641         }
642
643         irq = platform_get_irq(dev, 0);
644         if (irq < 0 || irq >= NR_IRQS)
645                 return -EBUSY;
646
647         return cascade_irq(irq, giu_get_irq);
648 }
649
650 static int __devexit giu_remove(struct platform_device *dev)
651 {
652         if (giu_base) {
653                 iounmap(giu_base);
654                 giu_base = NULL;
655         }
656
657         return 0;
658 }
659
660 static struct platform_driver giu_device_driver = {
661         .probe          = giu_probe,
662         .remove         = __devexit_p(giu_remove),
663         .driver         = {
664                 .name   = "GIU",
665                 .owner  = THIS_MODULE,
666         },
667 };
668
669 static int __init vr41xx_giu_init(void)
670 {
671         return platform_driver_register(&giu_device_driver);
672 }
673
674 static void __exit vr41xx_giu_exit(void)
675 {
676         platform_driver_unregister(&giu_device_driver);
677 }
678
679 module_init(vr41xx_giu_init);
680 module_exit(vr41xx_giu_exit);