sh: migrate to arch/sh/include/
[linux-2.6.git] / arch / cris / arch-v10 / drivers / gpio.c
1 /*
2  * Etrax general port I/O device
3  *
4  * Copyright (c) 1999-2007 Axis Communications AB
5  *
6  * Authors:    Bjorn Wesen      (initial version)
7  *             Ola Knutsson     (LED handling)
8  *             Johan Adolfsson  (read/set directions, write, port G)
9  */
10
11
12 #include <linux/module.h>
13 #include <linux/sched.h>
14 #include <linux/slab.h>
15 #include <linux/ioport.h>
16 #include <linux/errno.h>
17 #include <linux/kernel.h>
18 #include <linux/fs.h>
19 #include <linux/smp_lock.h>
20 #include <linux/string.h>
21 #include <linux/poll.h>
22 #include <linux/init.h>
23 #include <linux/interrupt.h>
24
25 #include <asm/etraxgpio.h>
26 #include <asm/arch/svinto.h>
27 #include <asm/io.h>
28 #include <asm/system.h>
29 #include <asm/irq.h>
30 #include <asm/arch/io_interface_mux.h>
31
32 #define GPIO_MAJOR 120  /* experimental MAJOR number */
33
34 #define D(x)
35
36 #if 0
37 static int dp_cnt;
38 #define DP(x) do { dp_cnt++; if (dp_cnt % 1000 == 0) x; }while(0)
39 #else
40 #define DP(x)
41 #endif
42
43 static char gpio_name[] = "etrax gpio";
44
45 #if 0
46 static wait_queue_head_t *gpio_wq;
47 #endif
48
49 static int gpio_ioctl(struct inode *inode, struct file *file,
50         unsigned int cmd, unsigned long arg);
51 static ssize_t gpio_write(struct file *file, const char __user *buf,
52         size_t count, loff_t *off);
53 static int gpio_open(struct inode *inode, struct file *filp);
54 static int gpio_release(struct inode *inode, struct file *filp);
55 static unsigned int gpio_poll(struct file *filp, struct poll_table_struct *wait);
56
57 /* private data per open() of this driver */
58
59 struct gpio_private {
60         struct gpio_private *next;
61         /* These fields are for PA and PB only */
62         volatile unsigned char *port, *shadow;
63         volatile unsigned char *dir, *dir_shadow;
64         unsigned char changeable_dir;
65         unsigned char changeable_bits;
66         unsigned char clk_mask;
67         unsigned char data_mask;
68         unsigned char write_msb;
69         unsigned char pad1, pad2, pad3;
70         /* These fields are generic */
71         unsigned long highalarm, lowalarm;
72         wait_queue_head_t alarm_wq;
73         int minor;
74 };
75
76 /* linked list of alarms to check for */
77
78 static struct gpio_private *alarmlist;
79
80 static int gpio_some_alarms; /* Set if someone uses alarm */
81 static unsigned long gpio_pa_irq_enabled_mask;
82
83 static DEFINE_SPINLOCK(gpio_lock); /* Protect directions etc */
84
85 /* Port A and B use 8 bit access, but Port G is 32 bit */
86 #define NUM_PORTS (GPIO_MINOR_B+1)
87
88 static volatile unsigned char *ports[NUM_PORTS] = {
89         R_PORT_PA_DATA,
90         R_PORT_PB_DATA,
91 };
92 static volatile unsigned char *shads[NUM_PORTS] = {
93         &port_pa_data_shadow,
94         &port_pb_data_shadow
95 };
96
97 /* What direction bits that are user changeable 1=changeable*/
98 #ifndef CONFIG_ETRAX_PA_CHANGEABLE_DIR
99 #define CONFIG_ETRAX_PA_CHANGEABLE_DIR 0x00
100 #endif
101 #ifndef CONFIG_ETRAX_PB_CHANGEABLE_DIR
102 #define CONFIG_ETRAX_PB_CHANGEABLE_DIR 0x00
103 #endif
104
105 #ifndef CONFIG_ETRAX_PA_CHANGEABLE_BITS
106 #define CONFIG_ETRAX_PA_CHANGEABLE_BITS 0xFF
107 #endif
108 #ifndef CONFIG_ETRAX_PB_CHANGEABLE_BITS
109 #define CONFIG_ETRAX_PB_CHANGEABLE_BITS 0xFF
110 #endif
111
112
113 static unsigned char changeable_dir[NUM_PORTS] = {
114         CONFIG_ETRAX_PA_CHANGEABLE_DIR,
115         CONFIG_ETRAX_PB_CHANGEABLE_DIR
116 };
117 static unsigned char changeable_bits[NUM_PORTS] = {
118         CONFIG_ETRAX_PA_CHANGEABLE_BITS,
119         CONFIG_ETRAX_PB_CHANGEABLE_BITS
120 };
121
122 static volatile unsigned char *dir[NUM_PORTS] = {
123         R_PORT_PA_DIR,
124         R_PORT_PB_DIR
125 };
126
127 static volatile unsigned char *dir_shadow[NUM_PORTS] = {
128         &port_pa_dir_shadow,
129         &port_pb_dir_shadow
130 };
131
132 /* All bits in port g that can change dir. */
133 static const unsigned long int changeable_dir_g_mask = 0x01FFFF01;
134
135 /* Port G is 32 bit, handle it special, some bits are both inputs
136    and outputs at the same time, only some of the bits can change direction
137    and some of them in groups of 8 bit. */
138 static unsigned long changeable_dir_g;
139 static unsigned long dir_g_in_bits;
140 static unsigned long dir_g_out_bits;
141 static unsigned long dir_g_shadow; /* 1=output */
142
143 #define USE_PORTS(priv) ((priv)->minor <= GPIO_MINOR_B)
144
145
146 static unsigned int gpio_poll(struct file *file, poll_table *wait)
147 {
148         unsigned int mask = 0;
149         struct gpio_private *priv = file->private_data;
150         unsigned long data;
151         unsigned long flags;
152
153         spin_lock_irqsave(&gpio_lock, flags);
154
155         poll_wait(file, &priv->alarm_wq, wait);
156         if (priv->minor == GPIO_MINOR_A) {
157                 unsigned long tmp;
158                 data = *R_PORT_PA_DATA;
159                 /* PA has support for high level interrupt -
160                  * lets activate for those low and with highalarm set
161                  */
162                 tmp = ~data & priv->highalarm & 0xFF;
163                 tmp = (tmp << R_IRQ_MASK1_SET__pa0__BITNR);
164
165                 gpio_pa_irq_enabled_mask |= tmp;
166                 *R_IRQ_MASK1_SET = tmp;
167         } else if (priv->minor == GPIO_MINOR_B)
168                 data = *R_PORT_PB_DATA;
169         else if (priv->minor == GPIO_MINOR_G)
170                 data = *R_PORT_G_DATA;
171         else {
172                 mask = 0;
173                 goto out;
174         }
175
176         if ((data & priv->highalarm) ||
177             (~data & priv->lowalarm)) {
178                 mask = POLLIN|POLLRDNORM;
179         }
180
181 out:
182         spin_unlock_irqrestore(&gpio_lock, flags);
183         DP(printk("gpio_poll ready: mask 0x%08X\n", mask));
184
185         return mask;
186 }
187
188 int etrax_gpio_wake_up_check(void)
189 {
190         struct gpio_private *priv;
191         unsigned long data = 0;
192         int ret = 0;
193         unsigned long flags;
194
195         spin_lock_irqsave(&gpio_lock, flags);
196         priv = alarmlist;
197         while (priv) {
198                 if (USE_PORTS(priv))
199                         data = *priv->port;
200                 else if (priv->minor == GPIO_MINOR_G)
201                         data = *R_PORT_G_DATA;
202
203                 if ((data & priv->highalarm) ||
204                     (~data & priv->lowalarm)) {
205                         DP(printk("etrax_gpio_wake_up_check %i\n",priv->minor));
206                         wake_up_interruptible(&priv->alarm_wq);
207                         ret = 1;
208                 }
209                 priv = priv->next;
210         }
211         spin_unlock_irqrestore(&gpio_lock, flags);
212         return ret;
213 }
214
215 static irqreturn_t
216 gpio_poll_timer_interrupt(int irq, void *dev_id)
217 {
218         if (gpio_some_alarms) {
219                 etrax_gpio_wake_up_check();
220                 return IRQ_HANDLED;
221         }
222         return IRQ_NONE;
223 }
224
225 static irqreturn_t
226 gpio_interrupt(int irq, void *dev_id)
227 {
228         unsigned long tmp;
229         unsigned long flags;
230
231         spin_lock_irqsave(&gpio_lock, flags);
232
233         /* Find what PA interrupts are active */
234         tmp = (*R_IRQ_READ1);
235
236         /* Find those that we have enabled */
237         tmp &= gpio_pa_irq_enabled_mask;
238
239         /* Clear them.. */
240         *R_IRQ_MASK1_CLR = tmp;
241         gpio_pa_irq_enabled_mask &= ~tmp;
242
243         spin_unlock_irqrestore(&gpio_lock, flags);
244
245         if (gpio_some_alarms)
246                 return IRQ_RETVAL(etrax_gpio_wake_up_check());
247
248         return IRQ_NONE;
249 }
250
251 static void gpio_write_bit(struct gpio_private *priv,
252         unsigned char data, int bit)
253 {
254         *priv->port = *priv->shadow &= ~(priv->clk_mask);
255         if (data & 1 << bit)
256                 *priv->port = *priv->shadow |= priv->data_mask;
257         else
258                 *priv->port = *priv->shadow &= ~(priv->data_mask);
259
260         /* For FPGA: min 5.0ns (DCC) before CCLK high */
261         *priv->port = *priv->shadow |= priv->clk_mask;
262 }
263
264 static void gpio_write_byte(struct gpio_private *priv, unsigned char data)
265 {
266         int i;
267
268         if (priv->write_msb)
269                 for (i = 7; i >= 0; i--)
270                         gpio_write_bit(priv, data, i);
271         else
272                 for (i = 0; i <= 7; i++)
273                         gpio_write_bit(priv, data, i);
274 }
275
276 static ssize_t gpio_write(struct file *file, const char __user *buf,
277         size_t count, loff_t *off)
278 {
279         struct gpio_private *priv = file->private_data;
280         unsigned long flags;
281         ssize_t retval = count;
282
283         if (priv->minor != GPIO_MINOR_A && priv->minor != GPIO_MINOR_B)
284                 return -EFAULT;
285
286         if (!access_ok(VERIFY_READ, buf, count))
287                 return -EFAULT;
288
289         spin_lock_irqsave(&gpio_lock, flags);
290
291         /* It must have been configured using the IO_CFG_WRITE_MODE */
292         /* Perhaps a better error code? */
293         if (priv->clk_mask == 0 || priv->data_mask == 0) {
294                 retval = -EPERM;
295                 goto out;
296         }
297
298         D(printk(KERN_DEBUG "gpio_write: %02X to data 0x%02X "
299                 "clk 0x%02X msb: %i\n",
300                 count, priv->data_mask, priv->clk_mask, priv->write_msb));
301
302         while (count--)
303                 gpio_write_byte(priv, *buf++);
304
305 out:
306         spin_unlock_irqrestore(&gpio_lock, flags);
307         return retval;
308 }
309
310
311
312 static int
313 gpio_open(struct inode *inode, struct file *filp)
314 {
315         struct gpio_private *priv;
316         int p = iminor(inode);
317         unsigned long flags;
318
319         if (p > GPIO_MINOR_LAST)
320                 return -EINVAL;
321
322         priv = kzalloc(sizeof(struct gpio_private), GFP_KERNEL);
323
324         if (!priv)
325                 return -ENOMEM;
326
327         lock_kernel();
328         priv->minor = p;
329
330         /* initialize the io/alarm struct */
331
332         if (USE_PORTS(priv)) { /* A and B */
333                 priv->port = ports[p];
334                 priv->shadow = shads[p];
335                 priv->dir = dir[p];
336                 priv->dir_shadow = dir_shadow[p];
337                 priv->changeable_dir = changeable_dir[p];
338                 priv->changeable_bits = changeable_bits[p];
339         } else {
340                 priv->port = NULL;
341                 priv->shadow = NULL;
342                 priv->dir = NULL;
343                 priv->dir_shadow = NULL;
344                 priv->changeable_dir = 0;
345                 priv->changeable_bits = 0;
346         }
347
348         priv->highalarm = 0;
349         priv->lowalarm = 0;
350         priv->clk_mask = 0;
351         priv->data_mask = 0;
352         init_waitqueue_head(&priv->alarm_wq);
353
354         filp->private_data = priv;
355
356         /* link it into our alarmlist */
357         spin_lock_irqsave(&gpio_lock, flags);
358         priv->next = alarmlist;
359         alarmlist = priv;
360         spin_unlock_irqrestore(&gpio_lock, flags);
361
362         unlock_kernel();
363         return 0;
364 }
365
366 static int
367 gpio_release(struct inode *inode, struct file *filp)
368 {
369         struct gpio_private *p;
370         struct gpio_private *todel;
371         unsigned long flags;
372
373         spin_lock_irqsave(&gpio_lock, flags);
374
375         p = alarmlist;
376         todel = filp->private_data;
377
378         /* unlink from alarmlist and free the private structure */
379
380         if (p == todel) {
381                 alarmlist = todel->next;
382         } else {
383                 while (p->next != todel)
384                         p = p->next;
385                 p->next = todel->next;
386         }
387
388         kfree(todel);
389         /* Check if there are still any alarms set */
390         p = alarmlist;
391         while (p) {
392                 if (p->highalarm | p->lowalarm) {
393                         gpio_some_alarms = 1;
394                         goto out;
395                 }
396                 p = p->next;
397         }
398         gpio_some_alarms = 0;
399 out:
400         spin_unlock_irqrestore(&gpio_lock, flags);
401         return 0;
402 }
403
404 /* Main device API. ioctl's to read/set/clear bits, as well as to
405  * set alarms to wait for using a subsequent select().
406  */
407 unsigned long inline setget_input(struct gpio_private *priv, unsigned long arg)
408 {
409         /* Set direction 0=unchanged 1=input,
410          * return mask with 1=input */
411         if (USE_PORTS(priv)) {
412                 *priv->dir = *priv->dir_shadow &=
413                 ~((unsigned char)arg & priv->changeable_dir);
414                 return ~(*priv->dir_shadow) & 0xFF; /* Only 8 bits */
415         }
416
417         if (priv->minor != GPIO_MINOR_G)
418                 return 0;
419
420         /* We must fiddle with R_GEN_CONFIG to change dir */
421         if (((arg & dir_g_in_bits) != arg) &&
422             (arg & changeable_dir_g)) {
423                 arg &= changeable_dir_g;
424                 /* Clear bits in genconfig to set to input */
425                 if (arg & (1<<0)) {
426                         genconfig_shadow &= ~IO_MASK(R_GEN_CONFIG, g0dir);
427                         dir_g_in_bits |= (1<<0);
428                         dir_g_out_bits &= ~(1<<0);
429                 }
430                 if ((arg & 0x0000FF00) == 0x0000FF00) {
431                         genconfig_shadow &= ~IO_MASK(R_GEN_CONFIG, g8_15dir);
432                         dir_g_in_bits |= 0x0000FF00;
433                         dir_g_out_bits &= ~0x0000FF00;
434                 }
435                 if ((arg & 0x00FF0000) == 0x00FF0000) {
436                         genconfig_shadow &= ~IO_MASK(R_GEN_CONFIG, g16_23dir);
437                         dir_g_in_bits |= 0x00FF0000;
438                         dir_g_out_bits &= ~0x00FF0000;
439                 }
440                 if (arg & (1<<24)) {
441                         genconfig_shadow &= ~IO_MASK(R_GEN_CONFIG, g24dir);
442                         dir_g_in_bits |= (1<<24);
443                         dir_g_out_bits &= ~(1<<24);
444                 }
445                 D(printk(KERN_DEBUG "gpio: SETINPUT on port G set "
446                          "genconfig to 0x%08lX "
447                          "in_bits: 0x%08lX "
448                          "out_bits: 0x%08lX\n",
449                          (unsigned long)genconfig_shadow,
450                          dir_g_in_bits, dir_g_out_bits));
451                 *R_GEN_CONFIG = genconfig_shadow;
452                 /* Must be a >120 ns delay before writing this again */
453
454         }
455         return dir_g_in_bits;
456 } /* setget_input */
457
458 unsigned long inline setget_output(struct gpio_private *priv, unsigned long arg)
459 {
460         if (USE_PORTS(priv)) {
461                 *priv->dir = *priv->dir_shadow |=
462                         ((unsigned char)arg & priv->changeable_dir);
463                 return *priv->dir_shadow;
464         }
465         if (priv->minor != GPIO_MINOR_G)
466                 return 0;
467
468         /* We must fiddle with R_GEN_CONFIG to change dir */
469         if (((arg & dir_g_out_bits) != arg) &&
470             (arg & changeable_dir_g)) {
471                 /* Set bits in genconfig to set to output */
472                 if (arg & (1<<0)) {
473                         genconfig_shadow |= IO_MASK(R_GEN_CONFIG, g0dir);
474                         dir_g_out_bits |= (1<<0);
475                         dir_g_in_bits &= ~(1<<0);
476                 }
477                 if ((arg & 0x0000FF00) == 0x0000FF00) {
478                         genconfig_shadow |= IO_MASK(R_GEN_CONFIG, g8_15dir);
479                         dir_g_out_bits |= 0x0000FF00;
480                         dir_g_in_bits &= ~0x0000FF00;
481                 }
482                 if ((arg & 0x00FF0000) == 0x00FF0000) {
483                         genconfig_shadow |= IO_MASK(R_GEN_CONFIG, g16_23dir);
484                         dir_g_out_bits |= 0x00FF0000;
485                         dir_g_in_bits &= ~0x00FF0000;
486                 }
487                 if (arg & (1<<24)) {
488                         genconfig_shadow |= IO_MASK(R_GEN_CONFIG, g24dir);
489                         dir_g_out_bits |= (1<<24);
490                         dir_g_in_bits &= ~(1<<24);
491                 }
492                 D(printk(KERN_INFO "gpio: SETOUTPUT on port G set "
493                          "genconfig to 0x%08lX "
494                          "in_bits: 0x%08lX "
495                          "out_bits: 0x%08lX\n",
496                          (unsigned long)genconfig_shadow,
497                          dir_g_in_bits, dir_g_out_bits));
498                 *R_GEN_CONFIG = genconfig_shadow;
499                 /* Must be a >120 ns delay before writing this again */
500         }
501         return dir_g_out_bits & 0x7FFFFFFF;
502 } /* setget_output */
503
504 static int
505 gpio_leds_ioctl(unsigned int cmd, unsigned long arg);
506
507 static int
508 gpio_ioctl(struct inode *inode, struct file *file,
509            unsigned int cmd, unsigned long arg)
510 {
511         unsigned long flags;
512         unsigned long val;
513         int ret = 0;
514
515         struct gpio_private *priv = file->private_data;
516         if (_IOC_TYPE(cmd) != ETRAXGPIO_IOCTYPE)
517                 return -EINVAL;
518
519         spin_lock_irqsave(&gpio_lock, flags);
520
521         switch (_IOC_NR(cmd)) {
522         case IO_READBITS: /* Use IO_READ_INBITS and IO_READ_OUTBITS instead */
523                 // read the port
524                 if (USE_PORTS(priv)) {
525                         ret =  *priv->port;
526                 } else if (priv->minor == GPIO_MINOR_G) {
527                         ret =  (*R_PORT_G_DATA) & 0x7FFFFFFF;
528                 }
529                 break;
530         case IO_SETBITS:
531                 // set changeable bits with a 1 in arg
532                 if (USE_PORTS(priv)) {
533                         *priv->port = *priv->shadow |= 
534                           ((unsigned char)arg & priv->changeable_bits);
535                 } else if (priv->minor == GPIO_MINOR_G) {
536                         *R_PORT_G_DATA = port_g_data_shadow |= (arg & dir_g_out_bits);
537                 }
538                 break;
539         case IO_CLRBITS:
540                 // clear changeable bits with a 1 in arg
541                 if (USE_PORTS(priv)) {
542                         *priv->port = *priv->shadow &= 
543                          ~((unsigned char)arg & priv->changeable_bits);
544                 } else if (priv->minor == GPIO_MINOR_G) {
545                         *R_PORT_G_DATA = port_g_data_shadow &= ~((unsigned long)arg & dir_g_out_bits);
546                 }
547                 break;
548         case IO_HIGHALARM:
549                 // set alarm when bits with 1 in arg go high
550                 priv->highalarm |= arg;
551                 gpio_some_alarms = 1;
552                 break;
553         case IO_LOWALARM:
554                 // set alarm when bits with 1 in arg go low
555                 priv->lowalarm |= arg;
556                 gpio_some_alarms = 1;
557                 break;
558         case IO_CLRALARM:
559                 // clear alarm for bits with 1 in arg
560                 priv->highalarm &= ~arg;
561                 priv->lowalarm  &= ~arg;
562                 {
563                         /* Must update gpio_some_alarms */
564                         struct gpio_private *p = alarmlist;
565                         int some_alarms;
566                         spin_lock_irq(&gpio_lock);
567                         p = alarmlist;
568                         some_alarms = 0;
569                         while (p) {
570                                 if (p->highalarm | p->lowalarm) {
571                                         some_alarms = 1;
572                                         break;
573                                 }
574                                 p = p->next;
575                         }
576                         gpio_some_alarms = some_alarms;
577                         spin_unlock_irq(&gpio_lock);
578                 }
579                 break;
580         case IO_READDIR: /* Use IO_SETGET_INPUT/OUTPUT instead! */
581                 /* Read direction 0=input 1=output */
582                 if (USE_PORTS(priv)) {
583                         ret = *priv->dir_shadow;
584                 } else if (priv->minor == GPIO_MINOR_G) {
585                         /* Note: Some bits are both in and out,
586                          * Those that are dual is set here as well.
587                          */
588                         ret = (dir_g_shadow | dir_g_out_bits) & 0x7FFFFFFF;
589                 }
590                 break;
591         case IO_SETINPUT: /* Use IO_SETGET_INPUT instead! */
592                 /* Set direction 0=unchanged 1=input, 
593                  * return mask with 1=input 
594                  */
595                 ret = setget_input(priv, arg) & 0x7FFFFFFF;
596                 break;
597         case IO_SETOUTPUT: /* Use IO_SETGET_OUTPUT instead! */
598                 /* Set direction 0=unchanged 1=output, 
599                  * return mask with 1=output 
600                  */
601                 ret =  setget_output(priv, arg) & 0x7FFFFFFF;
602                 break;
603         case IO_SHUTDOWN:
604                 SOFT_SHUTDOWN();
605                 break;
606         case IO_GET_PWR_BT:
607 #if defined (CONFIG_ETRAX_SOFT_SHUTDOWN)
608                 ret = (*R_PORT_G_DATA & ( 1 << CONFIG_ETRAX_POWERBUTTON_BIT));
609 #else
610                 ret = 0;
611 #endif
612                 break;
613         case IO_CFG_WRITE_MODE:
614                 priv->clk_mask = arg & 0xFF;
615                 priv->data_mask = (arg >> 8) & 0xFF;
616                 priv->write_msb = (arg >> 16) & 0x01;
617                 /* Check if we're allowed to change the bits and
618                  * the direction is correct
619                  */
620                 if (!((priv->clk_mask & priv->changeable_bits) &&
621                       (priv->data_mask & priv->changeable_bits) &&
622                       (priv->clk_mask & *priv->dir_shadow) &&
623                       (priv->data_mask & *priv->dir_shadow)))
624                 {
625                         priv->clk_mask = 0;
626                         priv->data_mask = 0;
627                         ret = -EPERM;
628                 }
629                 break;
630         case IO_READ_INBITS: 
631                 /* *arg is result of reading the input pins */
632                 if (USE_PORTS(priv)) {
633                         val = *priv->port;
634                 } else if (priv->minor == GPIO_MINOR_G) {
635                         val = *R_PORT_G_DATA;
636                 }
637                 if (copy_to_user((void __user *)arg, &val, sizeof(val)))
638                         ret = -EFAULT;
639                 break;
640         case IO_READ_OUTBITS:
641                  /* *arg is result of reading the output shadow */
642                 if (USE_PORTS(priv)) {
643                         val = *priv->shadow;
644                 } else if (priv->minor == GPIO_MINOR_G) {
645                         val = port_g_data_shadow;
646                 }
647                 if (copy_to_user((void __user *)arg, &val, sizeof(val)))
648                         ret = -EFAULT;
649                 break;
650         case IO_SETGET_INPUT: 
651                 /* bits set in *arg is set to input,
652                  * *arg updated with current input pins.
653                  */
654                 if (copy_from_user(&val, (void __user *)arg, sizeof(val)))
655                 {
656                         ret = -EFAULT;
657                         break;
658                 }
659                 val = setget_input(priv, val);
660                 if (copy_to_user((void __user *)arg, &val, sizeof(val)))
661                         ret = -EFAULT;
662                 break;
663         case IO_SETGET_OUTPUT:
664                 /* bits set in *arg is set to output,
665                  * *arg updated with current output pins.
666                  */
667                 if (copy_from_user(&val, (void __user *)arg, sizeof(val))) {
668                         ret = -EFAULT;
669                         break;
670                 }
671                 val = setget_output(priv, val);
672                 if (copy_to_user((void __user *)arg, &val, sizeof(val)))
673                         ret = -EFAULT;
674                 break;
675         default:
676                 if (priv->minor == GPIO_MINOR_LEDS)
677                         ret = gpio_leds_ioctl(cmd, arg);
678                 else
679                         ret = -EINVAL;
680         } /* switch */
681
682         spin_unlock_irqrestore(&gpio_lock, flags);
683         return ret;
684 }
685
686 static int
687 gpio_leds_ioctl(unsigned int cmd, unsigned long arg)
688 {
689         unsigned char green;
690         unsigned char red;
691
692         switch (_IOC_NR(cmd)) {
693         case IO_LEDACTIVE_SET:
694                 green = ((unsigned char)arg) & 1;
695                 red   = (((unsigned char)arg) >> 1) & 1;
696                 CRIS_LED_ACTIVE_SET_G(green);
697                 CRIS_LED_ACTIVE_SET_R(red);
698                 break;
699
700         case IO_LED_SETBIT:
701                 CRIS_LED_BIT_SET(arg);
702                 break;
703
704         case IO_LED_CLRBIT:
705                 CRIS_LED_BIT_CLR(arg);
706                 break;
707
708         default:
709                 return -EINVAL;
710         } /* switch */
711
712         return 0;
713 }
714
715 static const struct file_operations gpio_fops = {
716         .owner       = THIS_MODULE,
717         .poll        = gpio_poll,
718         .ioctl       = gpio_ioctl,
719         .write       = gpio_write,
720         .open        = gpio_open,
721         .release     = gpio_release,
722 };
723
724 static void ioif_watcher(const unsigned int gpio_in_available,
725         const unsigned int gpio_out_available,
726         const unsigned char pa_available,
727         const unsigned char pb_available)
728 {
729         unsigned long int flags;
730
731         D(printk(KERN_DEBUG "gpio.c: ioif_watcher called\n"));
732         D(printk(KERN_DEBUG "gpio.c: G in: 0x%08x G out: 0x%08x "
733                 "PA: 0x%02x PB: 0x%02x\n",
734                 gpio_in_available, gpio_out_available,
735                 pa_available, pb_available));
736
737         spin_lock_irqsave(&gpio_lock, flags);
738
739         dir_g_in_bits = gpio_in_available;
740         dir_g_out_bits = gpio_out_available;
741
742         /* Initialise the dir_g_shadow etc. depending on genconfig */
743         /* 0=input 1=output */
744         if (genconfig_shadow & IO_STATE(R_GEN_CONFIG, g0dir, out))
745                 dir_g_shadow |= (1 << 0);
746         if (genconfig_shadow & IO_STATE(R_GEN_CONFIG, g8_15dir, out))
747                 dir_g_shadow |= 0x0000FF00;
748         if (genconfig_shadow & IO_STATE(R_GEN_CONFIG, g16_23dir, out))
749                 dir_g_shadow |= 0x00FF0000;
750         if (genconfig_shadow & IO_STATE(R_GEN_CONFIG, g24dir, out))
751                 dir_g_shadow |= (1 << 24);
752
753         changeable_dir_g = changeable_dir_g_mask;
754         changeable_dir_g &= dir_g_out_bits;
755         changeable_dir_g &= dir_g_in_bits;
756
757         /* Correct the bits that can change direction */
758         dir_g_out_bits &= ~changeable_dir_g;
759         dir_g_out_bits |= dir_g_shadow;
760         dir_g_in_bits &= ~changeable_dir_g;
761         dir_g_in_bits |= (~dir_g_shadow & changeable_dir_g);
762
763         spin_unlock_irqrestore(&gpio_lock, flags);
764
765         printk(KERN_INFO "GPIO port G: in_bits: 0x%08lX out_bits: 0x%08lX "
766                 "val: %08lX\n",
767                dir_g_in_bits, dir_g_out_bits, (unsigned long)*R_PORT_G_DATA);
768         printk(KERN_INFO "GPIO port G: dir: %08lX changeable: %08lX\n",
769                dir_g_shadow, changeable_dir_g);
770 }
771
772 /* main driver initialization routine, called from mem.c */
773
774 static int __init gpio_init(void)
775 {
776         int res;
777 #if defined (CONFIG_ETRAX_CSP0_LEDS)
778         int i;
779 #endif
780
781         res = register_chrdev(GPIO_MAJOR, gpio_name, &gpio_fops);
782         if (res < 0) {
783                 printk(KERN_ERR "gpio: couldn't get a major number.\n");
784                 return res;
785         }
786
787         /* Clear all leds */
788 #if defined (CONFIG_ETRAX_CSP0_LEDS) ||  defined (CONFIG_ETRAX_PA_LEDS) || defined (CONFIG_ETRAX_PB_LEDS)
789         CRIS_LED_NETWORK_SET(0);
790         CRIS_LED_ACTIVE_SET(0);
791         CRIS_LED_DISK_READ(0);
792         CRIS_LED_DISK_WRITE(0);
793
794 #if defined (CONFIG_ETRAX_CSP0_LEDS)
795         for (i = 0; i < 32; i++)
796                 CRIS_LED_BIT_SET(i);
797 #endif
798
799 #endif
800         /* The I/O interface allocation watcher will be called when
801          * registering it. */
802         if (cris_io_interface_register_watcher(ioif_watcher)){
803                 printk(KERN_WARNING "gpio_init: Failed to install IO "
804                         "if allocator watcher\n");
805         }
806
807         printk(KERN_INFO "ETRAX 100LX GPIO driver v2.5, (c) 2001-2008 "
808                 "Axis Communications AB\n");
809         /* We call etrax_gpio_wake_up_check() from timer interrupt and
810          * from cpu_idle() in kernel/process.c
811          * The check in cpu_idle() reduces latency from ~15 ms to ~6 ms
812          * in some tests.
813          */
814         res = request_irq(TIMER0_IRQ_NBR, gpio_poll_timer_interrupt,
815                 IRQF_SHARED | IRQF_DISABLED, "gpio poll", gpio_name);
816         if (res) {
817                 printk(KERN_CRIT "err: timer0 irq for gpio\n");
818                 return res;
819         }
820         res = request_irq(PA_IRQ_NBR, gpio_interrupt,
821                 IRQF_SHARED | IRQF_DISABLED, "gpio PA", gpio_name);
822         if (res)
823                 printk(KERN_CRIT "err: PA irq for gpio\n");
824
825         return res;
826 }
827
828 /* this makes sure that gpio_init is called during kernel boot */
829 module_init(gpio_init);
830