[PATCH] CRIS update: drivers
[linux-2.6.git] / arch / cris / arch-v10 / drivers / gpio.c
1 /* $Id: gpio.c,v 1.17 2005/06/19 17:06:46 starvik Exp $
2  *
3  * Etrax general port I/O device
4  *
5  * Copyright (c) 1999, 2000, 2001, 2002 Axis Communications AB
6  *
7  * Authors:    Bjorn Wesen      (initial version)
8  *             Ola Knutsson     (LED handling)
9  *             Johan Adolfsson  (read/set directions, write, port G)
10  *
11  * $Log: gpio.c,v $
12  * Revision 1.17  2005/06/19 17:06:46  starvik
13  * Merge of Linux 2.6.12.
14  *
15  * Revision 1.16  2005/03/07 13:02:29  starvik
16  * Protect driver global states with spinlock
17  *
18  * Revision 1.15  2005/01/05 06:08:55  starvik
19  * No need to do local_irq_disable after local_irq_save.
20  *
21  * Revision 1.14  2004/12/13 12:21:52  starvik
22  * Added I/O and DMA allocators from Linux 2.4
23  *
24  * Revision 1.12  2004/08/24 07:19:59  starvik
25  * Whitespace cleanup
26  *
27  * Revision 1.11  2004/05/14 07:58:03  starvik
28  * Merge of changes from 2.4
29  *
30  * Revision 1.9  2003/09/11 07:29:48  starvik
31  * Merge of Linux 2.6.0-test5
32  *
33  * Revision 1.8  2003/07/04 08:27:37  starvik
34  * Merge of Linux 2.5.74
35  *
36  * Revision 1.7  2003/01/10 07:44:07  starvik
37  * init_ioremap is now called by kernel before drivers are initialized
38  *
39  * Revision 1.6  2002/12/11 13:13:57  starvik
40  * Added arch/ to v10 specific includes
41  * Added fix from Linux 2.4 in serial.c (flush_to_flip_buffer)
42  *
43  * Revision 1.5  2002/11/20 11:56:11  starvik
44  * Merge of Linux 2.5.48
45  *
46  * Revision 1.4  2002/11/18 10:10:05  starvik
47  * Linux 2.5 port of latest gpio.c from Linux 2.4
48  *
49  * Revision 1.20  2002/10/16 21:16:24  johana
50  * Added support for PA high level interrupt.
51  * That gives 2ms response time with iodtest for high levels and 2-12 ms
52  * response time on low levels if the check is not made in
53  * process.c:cpu_idle() as well.
54  *
55  * Revision 1.19  2002/10/14 18:27:33  johana
56  * Implemented alarm handling so select() now works.
57  * Latency is around 6-9 ms with a etrax_gpio_wake_up_check() in
58  * cpu_idle().
59  * Otherwise I get 15-18 ms (same as doing the poll in userspace -
60  * but less overhead).
61  * TODO? Perhaps we should add the check in IMMEDIATE_BH (or whatever it
62  * is in 2.4) as well?
63  * TODO? Perhaps call request_irq()/free_irq() only when needed?
64  * Increased version to 2.5
65  *
66  * Revision 1.18  2002/10/11 15:02:00  johana
67  * Mask inverted 8 bit value in setget_input().
68  *
69  * Revision 1.17  2002/06/17 15:53:01  johana
70  * Added IO_READ_INBITS, IO_READ_OUTBITS, IO_SETGET_INPUT and IO_SETGET_OUTPUT
71  * that take a pointer as argument and thus can handle 32 bit ports (G)
72  * correctly.
73  * These should be used instead of IO_READBITS, IO_SETINPUT and IO_SETOUTPUT.
74  * (especially if Port G bit 31 is used)
75  *
76  * Revision 1.16  2002/06/17 09:59:51  johana
77  * Returning 32 bit values in the ioctl return value doesn't work if bit
78  * 31 is set (could happen for port G), so mask it of with 0x7FFFFFFF.
79  * A new set of ioctl's will be added.
80  *
81  * Revision 1.15  2002/05/06 13:19:13  johana
82  * IO_SETINPUT returns mask with bit set = inputs for PA and PB as well.
83  *
84  * Revision 1.14  2002/04/12 12:01:53  johana
85  * Use global r_port_g_data_shadow.
86  * Moved gpio_init_port_g() closer to gpio_init() and marked it __init.
87  *
88  * Revision 1.13  2002/04/10 12:03:55  johana
89  * Added support for port G /dev/gpiog (minor 3).
90  * Changed indentation on switch cases.
91  * Fixed other spaces to tabs.
92  *
93  * Revision 1.12  2001/11/12 19:42:15  pkj
94  * * Corrected return values from gpio_leds_ioctl().
95  * * Fixed compiler warnings.
96  *
97  * Revision 1.11  2001/10/30 14:39:12  johana
98  * Added D() around gpio_write printk.
99  *
100  * Revision 1.10  2001/10/25 10:24:42  johana
101  * Added IO_CFG_WRITE_MODE ioctl and write method that can do fast
102  * bittoggling in the kernel. (This speeds up programming an FPGA with 450kB
103  * from ~60 seconds to 4 seconds).
104  * Added save_flags/cli/restore_flags in ioctl.
105  *
106  * Revision 1.9  2001/05/04 14:16:07  matsfg
107  * Corrected spelling error
108  *
109  * Revision 1.8  2001/04/27 13:55:26  matsfg
110  * Moved initioremap.
111  * Turns off all LEDS on init.
112  * Added support for shutdown and powerbutton.
113  *
114  * Revision 1.7  2001/04/04 13:30:08  matsfg
115  * Added bitset and bitclear for leds. Calls init_ioremap to set up memmapping
116  *
117  * Revision 1.6  2001/03/26 16:03:06  bjornw
118  * Needs linux/config.h
119  *
120  * Revision 1.5  2001/03/26 14:22:03  bjornw
121  * Namechange of some config options
122  *
123  * Revision 1.4  2001/02/27 13:52:48  bjornw
124  * malloc.h -> slab.h
125  *
126  * Revision 1.3  2001/01/24 15:06:48  bjornw
127  * gpio_wq correct type
128  *
129  * Revision 1.2  2001/01/18 16:07:30  bjornw
130  * 2.4 port
131  *
132  * Revision 1.1  2001/01/18 15:55:16  bjornw
133  * Verbatim copy of etraxgpio.c from elinux 2.0 added
134  *
135  *
136  */
137
138 #include <linux/config.h>
139
140 #include <linux/module.h>
141 #include <linux/sched.h>
142 #include <linux/slab.h>
143 #include <linux/ioport.h>
144 #include <linux/errno.h>
145 #include <linux/kernel.h>
146 #include <linux/fs.h>
147 #include <linux/string.h>
148 #include <linux/poll.h>
149 #include <linux/init.h>
150 #include <linux/interrupt.h>
151
152 #include <asm/etraxgpio.h>
153 #include <asm/arch/svinto.h>
154 #include <asm/io.h>
155 #include <asm/system.h>
156 #include <asm/irq.h>
157 #include <asm/arch/io_interface_mux.h>
158
159 #define GPIO_MAJOR 120  /* experimental MAJOR number */
160
161 #define D(x)
162
163 #if 0
164 static int dp_cnt;
165 #define DP(x) do { dp_cnt++; if (dp_cnt % 1000 == 0) x; }while(0)
166 #else
167 #define DP(x)
168 #endif
169         
170 static char gpio_name[] = "etrax gpio";
171
172 #if 0
173 static wait_queue_head_t *gpio_wq;
174 #endif
175
176 static int gpio_ioctl(struct inode *inode, struct file *file,
177                       unsigned int cmd, unsigned long arg);
178 static ssize_t gpio_write(struct file * file, const char * buf, size_t count,
179                           loff_t *off);
180 static int gpio_open(struct inode *inode, struct file *filp);
181 static int gpio_release(struct inode *inode, struct file *filp);
182 static unsigned int gpio_poll(struct file *filp, struct poll_table_struct *wait);
183
184 /* private data per open() of this driver */
185
186 struct gpio_private {
187         struct gpio_private *next;
188         /* These fields are for PA and PB only */
189         volatile unsigned char *port, *shadow;
190         volatile unsigned char *dir, *dir_shadow;
191         unsigned char changeable_dir;
192         unsigned char changeable_bits;
193         unsigned char clk_mask;
194         unsigned char data_mask;
195         unsigned char write_msb;
196         unsigned char pad1, pad2, pad3;
197         /* These fields are generic */
198         unsigned long highalarm, lowalarm;
199         wait_queue_head_t alarm_wq;
200         int minor;
201 };
202
203 /* linked list of alarms to check for */
204
205 static struct gpio_private *alarmlist = 0;
206
207 static int gpio_some_alarms = 0; /* Set if someone uses alarm */
208 static unsigned long gpio_pa_irq_enabled_mask = 0;
209
210 static DEFINE_SPINLOCK(gpio_lock); /* Protect directions etc */
211
212 /* Port A and B use 8 bit access, but Port G is 32 bit */
213 #define NUM_PORTS (GPIO_MINOR_B+1)
214
215 static volatile unsigned char *ports[NUM_PORTS] = { 
216         R_PORT_PA_DATA, 
217         R_PORT_PB_DATA,
218 };
219 static volatile unsigned char *shads[NUM_PORTS] = {
220         &port_pa_data_shadow, 
221         &port_pb_data_shadow
222 };
223
224 /* What direction bits that are user changeable 1=changeable*/
225 #ifndef CONFIG_ETRAX_PA_CHANGEABLE_DIR
226 #define CONFIG_ETRAX_PA_CHANGEABLE_DIR 0x00
227 #endif
228 #ifndef CONFIG_ETRAX_PB_CHANGEABLE_DIR
229 #define CONFIG_ETRAX_PB_CHANGEABLE_DIR 0x00
230 #endif
231
232 #ifndef CONFIG_ETRAX_PA_CHANGEABLE_BITS
233 #define CONFIG_ETRAX_PA_CHANGEABLE_BITS 0xFF
234 #endif
235 #ifndef CONFIG_ETRAX_PB_CHANGEABLE_BITS
236 #define CONFIG_ETRAX_PB_CHANGEABLE_BITS 0xFF
237 #endif
238
239
240 static unsigned char changeable_dir[NUM_PORTS] = { 
241         CONFIG_ETRAX_PA_CHANGEABLE_DIR,
242         CONFIG_ETRAX_PB_CHANGEABLE_DIR 
243 };
244 static unsigned char changeable_bits[NUM_PORTS] = { 
245         CONFIG_ETRAX_PA_CHANGEABLE_BITS,
246         CONFIG_ETRAX_PB_CHANGEABLE_BITS 
247 };
248
249 static volatile unsigned char *dir[NUM_PORTS] = { 
250         R_PORT_PA_DIR, 
251         R_PORT_PB_DIR 
252 };
253
254 static volatile unsigned char *dir_shadow[NUM_PORTS] = {
255         &port_pa_dir_shadow, 
256         &port_pb_dir_shadow 
257 };
258
259 /* All bits in port g that can change dir. */
260 static const unsigned long int changeable_dir_g_mask = 0x01FFFF01;
261
262 /* Port G is 32 bit, handle it special, some bits are both inputs 
263    and outputs at the same time, only some of the bits can change direction
264    and some of them in groups of 8 bit. */
265 static unsigned long changeable_dir_g;
266 static unsigned long dir_g_in_bits;
267 static unsigned long dir_g_out_bits;
268 static unsigned long dir_g_shadow; /* 1=output */
269
270 #define USE_PORTS(priv) ((priv)->minor <= GPIO_MINOR_B)
271
272
273
274 static unsigned int 
275 gpio_poll(struct file *file,
276           poll_table *wait)
277 {
278         unsigned int mask = 0;
279         struct gpio_private *priv = (struct gpio_private *)file->private_data;
280         unsigned long data;
281         spin_lock(&gpio_lock);
282         poll_wait(file, &priv->alarm_wq, wait);
283         if (priv->minor == GPIO_MINOR_A) {
284                 unsigned long flags;
285                 unsigned long tmp;
286                 data = *R_PORT_PA_DATA;
287                 /* PA has support for high level interrupt -
288                  * lets activate for those low and with highalarm set
289                  */
290                 tmp = ~data & priv->highalarm & 0xFF;
291                 tmp = (tmp << R_IRQ_MASK1_SET__pa0__BITNR);
292                 local_irq_save(flags);
293                 gpio_pa_irq_enabled_mask |= tmp;
294                 *R_IRQ_MASK1_SET = tmp;
295                 local_irq_restore(flags);
296
297         } else if (priv->minor == GPIO_MINOR_B)
298                 data = *R_PORT_PB_DATA;
299         else if (priv->minor == GPIO_MINOR_G)
300                 data = *R_PORT_G_DATA;
301         else
302                 return 0;
303         
304         if ((data & priv->highalarm) ||
305             (~data & priv->lowalarm)) {
306                 mask = POLLIN|POLLRDNORM;
307         }
308
309         spin_unlock(&gpio_lock);
310         
311         DP(printk("gpio_poll ready: mask 0x%08X\n", mask));
312
313         return mask;
314 }
315
316 int etrax_gpio_wake_up_check(void)
317 {
318         struct gpio_private *priv = alarmlist;
319         unsigned long data = 0;
320         int ret = 0;
321         spin_lock(&gpio_lock);
322         while (priv) {
323                 if (USE_PORTS(priv)) {
324                         data = *priv->port;
325                 } else if (priv->minor == GPIO_MINOR_G) {
326                         data = *R_PORT_G_DATA;
327                 }
328                 if ((data & priv->highalarm) ||
329                     (~data & priv->lowalarm)) {
330                         DP(printk("etrax_gpio_wake_up_check %i\n",priv->minor));
331                         wake_up_interruptible(&priv->alarm_wq);
332                         ret = 1;
333                 }
334                 priv = priv->next;
335         }
336         spin_unlock(&gpio_lock);
337         return ret;
338 }
339
340 static irqreturn_t
341 gpio_poll_timer_interrupt(int irq, void *dev_id, struct pt_regs *regs)
342 {
343         if (gpio_some_alarms) {
344                 etrax_gpio_wake_up_check();
345                 return IRQ_HANDLED;
346         }
347         return IRQ_NONE;
348 }
349
350 static irqreturn_t
351 gpio_pa_interrupt(int irq, void *dev_id, struct pt_regs *regs)
352 {
353         unsigned long tmp;
354         spin_lock(&gpio_lock);
355         /* Find what PA interrupts are active */
356         tmp = (*R_IRQ_READ1);
357
358         /* Find those that we have enabled */
359         tmp &= gpio_pa_irq_enabled_mask;
360
361         /* Clear them.. */
362         *R_IRQ_MASK1_CLR = tmp;
363         gpio_pa_irq_enabled_mask &= ~tmp;
364
365         spin_unlock(&gpio_lock);
366
367         if (gpio_some_alarms) {
368                 return IRQ_RETVAL(etrax_gpio_wake_up_check());
369         }
370         return IRQ_NONE;
371 }
372
373
374 static ssize_t gpio_write(struct file * file, const char * buf, size_t count,
375                           loff_t *off)
376 {
377         struct gpio_private *priv = (struct gpio_private *)file->private_data;
378         unsigned char data, clk_mask, data_mask, write_msb;
379         unsigned long flags;
380
381         spin_lock(&gpio_lock);
382
383         ssize_t retval = count;
384         if (priv->minor !=GPIO_MINOR_A && priv->minor != GPIO_MINOR_B) {
385                 return -EFAULT;
386         }
387     
388         if (!access_ok(VERIFY_READ, buf, count)) {
389                 return -EFAULT;
390         }
391         clk_mask = priv->clk_mask;
392         data_mask = priv->data_mask;
393         /* It must have been configured using the IO_CFG_WRITE_MODE */
394         /* Perhaps a better error code? */
395         if (clk_mask == 0 || data_mask == 0) {
396                 return -EPERM;
397         }
398         write_msb = priv->write_msb;
399         D(printk("gpio_write: %lu to data 0x%02X clk 0x%02X msb: %i\n",count, data_mask, clk_mask, write_msb));
400         while (count--) {
401                 int i;
402                 data = *buf++;
403                 if (priv->write_msb) {
404                         for (i = 7; i >= 0;i--) {
405                                 local_irq_save(flags);
406                                 *priv->port = *priv->shadow &= ~clk_mask;
407                                 if (data & 1<<i)
408                                         *priv->port = *priv->shadow |= data_mask;
409                                 else
410                                         *priv->port = *priv->shadow &= ~data_mask;
411                         /* For FPGA: min 5.0ns (DCC) before CCLK high */
412                                 *priv->port = *priv->shadow |= clk_mask;
413                                 local_irq_restore(flags);
414                         }
415                 } else {
416                         for (i = 0; i <= 7;i++) {
417                                 local_irq_save(flags);
418                                 *priv->port = *priv->shadow &= ~clk_mask;
419                                 if (data & 1<<i)
420                                         *priv->port = *priv->shadow |= data_mask;
421                                 else
422                                         *priv->port = *priv->shadow &= ~data_mask;
423                         /* For FPGA: min 5.0ns (DCC) before CCLK high */
424                                 *priv->port = *priv->shadow |= clk_mask;
425                                 local_irq_restore(flags);
426                         }
427                 }
428         }
429         spin_unlock(&gpio_lock);
430         return retval;
431 }
432
433
434
435 static int
436 gpio_open(struct inode *inode, struct file *filp)
437 {
438         struct gpio_private *priv;
439         int p = MINOR(inode->i_rdev);
440
441         if (p > GPIO_MINOR_LAST)
442                 return -EINVAL;
443
444         priv = (struct gpio_private *)kmalloc(sizeof(struct gpio_private), 
445                                               GFP_KERNEL);
446
447         if (!priv)
448                 return -ENOMEM;
449
450         priv->minor = p;
451
452         /* initialize the io/alarm struct and link it into our alarmlist */
453
454         priv->next = alarmlist;
455         alarmlist = priv;
456         if (USE_PORTS(priv)) { /* A and B */
457                 priv->port = ports[p];
458                 priv->shadow = shads[p];
459                 priv->dir = dir[p];
460                 priv->dir_shadow = dir_shadow[p];
461                 priv->changeable_dir = changeable_dir[p];
462                 priv->changeable_bits = changeable_bits[p];
463         } else {
464                 priv->port = NULL;
465                 priv->shadow = NULL;
466                 priv->dir = NULL;
467                 priv->dir_shadow = NULL;
468                 priv->changeable_dir = 0;
469                 priv->changeable_bits = 0;
470         }
471
472         priv->highalarm = 0;
473         priv->lowalarm = 0;
474         priv->clk_mask = 0;
475         priv->data_mask = 0;
476         init_waitqueue_head(&priv->alarm_wq);
477
478         filp->private_data = (void *)priv;
479
480         return 0;
481 }
482
483 static int
484 gpio_release(struct inode *inode, struct file *filp)
485 {
486         struct gpio_private *p;
487         struct gpio_private *todel;
488
489         spin_lock(&gpio_lock);
490
491         p = alarmlist;
492         todel = (struct gpio_private *)filp->private_data;
493
494         /* unlink from alarmlist and free the private structure */
495
496         if (p == todel) {
497                 alarmlist = todel->next;
498         } else {
499                 while (p->next != todel)
500                         p = p->next;
501                 p->next = todel->next;
502         }
503
504         kfree(todel);
505         /* Check if there are still any alarms set */
506         p = alarmlist;
507         while (p) {
508                 if (p->highalarm | p->lowalarm) {
509                         gpio_some_alarms = 1;
510                         return 0;
511                 }
512                 p = p->next;
513         }
514         gpio_some_alarms = 0;
515         spin_unlock(&gpio_lock);
516         return 0;
517 }
518
519 /* Main device API. ioctl's to read/set/clear bits, as well as to 
520  * set alarms to wait for using a subsequent select().
521  */
522
523 unsigned long inline setget_input(struct gpio_private *priv, unsigned long arg)
524 {
525         /* Set direction 0=unchanged 1=input, 
526          * return mask with 1=input 
527          */
528         unsigned long flags;
529         if (USE_PORTS(priv)) {
530                 local_irq_save(flags);
531                 *priv->dir = *priv->dir_shadow &= 
532                 ~((unsigned char)arg & priv->changeable_dir);
533                 local_irq_restore(flags);
534                 return ~(*priv->dir_shadow) & 0xFF; /* Only 8 bits */
535         } else if (priv->minor == GPIO_MINOR_G) {
536                 /* We must fiddle with R_GEN_CONFIG to change dir */
537                 local_irq_save(flags);
538                 if (((arg & dir_g_in_bits) != arg) && 
539                     (arg & changeable_dir_g)) {
540                         arg &= changeable_dir_g;
541                         /* Clear bits in genconfig to set to input */
542                         if (arg & (1<<0)) {
543                                 genconfig_shadow &= ~IO_MASK(R_GEN_CONFIG,g0dir);
544                                 dir_g_in_bits |= (1<<0);
545                                 dir_g_out_bits &= ~(1<<0);
546                         }
547                         if ((arg & 0x0000FF00) == 0x0000FF00) {
548                                 genconfig_shadow &= ~IO_MASK(R_GEN_CONFIG,g8_15dir);
549                                 dir_g_in_bits |= 0x0000FF00;
550                                 dir_g_out_bits &= ~0x0000FF00;
551                         }
552                         if ((arg & 0x00FF0000) == 0x00FF0000) {
553                                 genconfig_shadow &= ~IO_MASK(R_GEN_CONFIG,g16_23dir);
554                                 dir_g_in_bits |= 0x00FF0000;
555                                 dir_g_out_bits &= ~0x00FF0000;
556                         }
557                         if (arg & (1<<24)) {
558                                 genconfig_shadow &= ~IO_MASK(R_GEN_CONFIG,g24dir);
559                                 dir_g_in_bits |= (1<<24);
560                                 dir_g_out_bits &= ~(1<<24);
561                         }
562                         D(printk(KERN_INFO "gpio: SETINPUT on port G set "
563                                  "genconfig to 0x%08lX "
564                                  "in_bits: 0x%08lX "
565                                  "out_bits: 0x%08lX\n",
566                                  (unsigned long)genconfig_shadow,
567                                  dir_g_in_bits, dir_g_out_bits));
568                         *R_GEN_CONFIG = genconfig_shadow;
569                         /* Must be a >120 ns delay before writing this again */
570                                 
571                 }
572                 local_irq_restore(flags);
573                 return dir_g_in_bits;
574         }
575         return 0;
576 } /* setget_input */
577
578 unsigned long inline setget_output(struct gpio_private *priv, unsigned long arg)
579 {
580         unsigned long flags;
581         if (USE_PORTS(priv)) {
582                 local_irq_save(flags);
583                 *priv->dir = *priv->dir_shadow |= 
584                   ((unsigned char)arg & priv->changeable_dir);
585                 local_irq_restore(flags);
586                 return *priv->dir_shadow;
587         } else if (priv->minor == GPIO_MINOR_G) {
588                 /* We must fiddle with R_GEN_CONFIG to change dir */                    
589                 local_irq_save(flags);
590                 if (((arg & dir_g_out_bits) != arg) &&
591                     (arg & changeable_dir_g)) {
592                         /* Set bits in genconfig to set to output */
593                         if (arg & (1<<0)) {
594                                 genconfig_shadow |= IO_MASK(R_GEN_CONFIG,g0dir);
595                                 dir_g_out_bits |= (1<<0);
596                                 dir_g_in_bits &= ~(1<<0);
597                         }
598                         if ((arg & 0x0000FF00) == 0x0000FF00) {
599                                 genconfig_shadow |= IO_MASK(R_GEN_CONFIG,g8_15dir);
600                                 dir_g_out_bits |= 0x0000FF00;
601                                 dir_g_in_bits &= ~0x0000FF00;
602                         }
603                         if ((arg & 0x00FF0000) == 0x00FF0000) {
604                                 genconfig_shadow |= IO_MASK(R_GEN_CONFIG,g16_23dir);
605                                 dir_g_out_bits |= 0x00FF0000;
606                                 dir_g_in_bits &= ~0x00FF0000;
607                         }
608                         if (arg & (1<<24)) {
609                                 genconfig_shadow |= IO_MASK(R_GEN_CONFIG,g24dir);
610                                 dir_g_out_bits |= (1<<24);
611                                 dir_g_in_bits &= ~(1<<24);
612                         }
613                         D(printk(KERN_INFO "gpio: SETOUTPUT on port G set "
614                                  "genconfig to 0x%08lX "
615                                  "in_bits: 0x%08lX "
616                                  "out_bits: 0x%08lX\n",
617                                  (unsigned long)genconfig_shadow,
618                                  dir_g_in_bits, dir_g_out_bits));
619                         *R_GEN_CONFIG = genconfig_shadow;
620                         /* Must be a >120 ns delay before writing this again */
621                 }
622                 local_irq_restore(flags);
623                 return dir_g_out_bits & 0x7FFFFFFF;
624         }
625         return 0;
626 } /* setget_output */
627
628 static int
629 gpio_leds_ioctl(unsigned int cmd, unsigned long arg);
630
631 static int
632 gpio_ioctl(struct inode *inode, struct file *file,
633            unsigned int cmd, unsigned long arg)
634 {
635         unsigned long flags;
636         unsigned long val;
637         int ret = 0;
638
639         struct gpio_private *priv = (struct gpio_private *)file->private_data;
640         if (_IOC_TYPE(cmd) != ETRAXGPIO_IOCTYPE) {
641                 return -EINVAL;
642         }
643
644         spin_lock(&gpio_lock);
645
646         switch (_IOC_NR(cmd)) {
647         case IO_READBITS: /* Use IO_READ_INBITS and IO_READ_OUTBITS instead */
648                 // read the port
649                 if (USE_PORTS(priv)) {
650                         ret =  *priv->port;
651                 } else if (priv->minor == GPIO_MINOR_G) {
652                         ret =  (*R_PORT_G_DATA) & 0x7FFFFFFF;
653                 }
654                 break;
655         case IO_SETBITS:
656                 local_irq_save(flags);
657                 // set changeable bits with a 1 in arg
658                 if (USE_PORTS(priv)) {
659                         *priv->port = *priv->shadow |= 
660                           ((unsigned char)arg & priv->changeable_bits);
661                 } else if (priv->minor == GPIO_MINOR_G) {
662                         *R_PORT_G_DATA = port_g_data_shadow |= (arg & dir_g_out_bits);
663                 }
664                 local_irq_restore(flags);
665                 break;
666         case IO_CLRBITS:
667                 local_irq_save(flags);
668                 // clear changeable bits with a 1 in arg
669                 if (USE_PORTS(priv)) {
670                         *priv->port = *priv->shadow &= 
671                          ~((unsigned char)arg & priv->changeable_bits);
672                 } else if (priv->minor == GPIO_MINOR_G) {
673                         *R_PORT_G_DATA = port_g_data_shadow &= ~((unsigned long)arg & dir_g_out_bits);
674                 }
675                 local_irq_restore(flags);
676                 break;
677         case IO_HIGHALARM:
678                 // set alarm when bits with 1 in arg go high
679                 priv->highalarm |= arg;
680                 gpio_some_alarms = 1;
681                 break;
682         case IO_LOWALARM:
683                 // set alarm when bits with 1 in arg go low
684                 priv->lowalarm |= arg;
685                 gpio_some_alarms = 1;
686                 break;
687         case IO_CLRALARM:
688                 // clear alarm for bits with 1 in arg
689                 priv->highalarm &= ~arg;
690                 priv->lowalarm  &= ~arg;
691                 {
692                         /* Must update gpio_some_alarms */
693                         struct gpio_private *p = alarmlist;
694                         int some_alarms;
695                         some_alarms = 0;
696                         while (p) {
697                                 if (p->highalarm | p->lowalarm) {
698                                         some_alarms = 1;
699                                         break;
700                                 }
701                                 p = p->next;
702                         }
703                         gpio_some_alarms = some_alarms;
704                 }
705                 break;
706         case IO_READDIR: /* Use IO_SETGET_INPUT/OUTPUT instead! */
707                 /* Read direction 0=input 1=output */
708                 if (USE_PORTS(priv)) {
709                         ret = *priv->dir_shadow;
710                 } else if (priv->minor == GPIO_MINOR_G) {
711                         /* Note: Some bits are both in and out,
712                          * Those that are dual is set here as well.
713                          */
714                         ret = (dir_g_shadow | dir_g_out_bits) & 0x7FFFFFFF;
715                 }
716                 break;
717         case IO_SETINPUT: /* Use IO_SETGET_INPUT instead! */
718                 /* Set direction 0=unchanged 1=input, 
719                  * return mask with 1=input 
720                  */
721                 ret = setget_input(priv, arg) & 0x7FFFFFFF;
722                 break;
723         case IO_SETOUTPUT: /* Use IO_SETGET_OUTPUT instead! */
724                 /* Set direction 0=unchanged 1=output, 
725                  * return mask with 1=output 
726                  */
727                 ret =  setget_output(priv, arg) & 0x7FFFFFFF;
728                 break;
729         case IO_SHUTDOWN:
730                 SOFT_SHUTDOWN();
731                 break;
732         case IO_GET_PWR_BT:
733 #if defined (CONFIG_ETRAX_SOFT_SHUTDOWN)
734                 ret = (*R_PORT_G_DATA & ( 1 << CONFIG_ETRAX_POWERBUTTON_BIT));
735 #else
736                 ret = 0;
737 #endif
738                 break;
739         case IO_CFG_WRITE_MODE:
740                 priv->clk_mask = arg & 0xFF;
741                 priv->data_mask = (arg >> 8) & 0xFF;
742                 priv->write_msb = (arg >> 16) & 0x01;
743                 /* Check if we're allowed to change the bits and
744                  * the direction is correct
745                  */
746                 if (!((priv->clk_mask & priv->changeable_bits) &&
747                       (priv->data_mask & priv->changeable_bits) &&
748                       (priv->clk_mask & *priv->dir_shadow) &&
749                       (priv->data_mask & *priv->dir_shadow)))
750                 {
751                         priv->clk_mask = 0;
752                         priv->data_mask = 0;
753                         ret = -EPERM;
754                 }
755                 break;
756         case IO_READ_INBITS: 
757                 /* *arg is result of reading the input pins */
758                 if (USE_PORTS(priv)) {
759                         val = *priv->port;
760                 } else if (priv->minor == GPIO_MINOR_G) {
761                         val = *R_PORT_G_DATA;
762                 }
763                 if (copy_to_user((unsigned long*)arg, &val, sizeof(val)))
764                         ret = -EFAULT;
765                 break;
766         case IO_READ_OUTBITS:
767                  /* *arg is result of reading the output shadow */
768                 if (USE_PORTS(priv)) {
769                         val = *priv->shadow;
770                 } else if (priv->minor == GPIO_MINOR_G) {
771                         val = port_g_data_shadow;
772                 }
773                 if (copy_to_user((unsigned long*)arg, &val, sizeof(val)))
774                         ret = -EFAULT;
775                 break;
776         case IO_SETGET_INPUT: 
777                 /* bits set in *arg is set to input,
778                  * *arg updated with current input pins.
779                  */
780                 if (copy_from_user(&val, (unsigned long*)arg, sizeof(val)))
781                 {
782                         ret = -EFAULT;
783                         break;
784                 }
785                 val = setget_input(priv, val);
786                 if (copy_to_user((unsigned long*)arg, &val, sizeof(val)))
787                         ret = -EFAULT;
788                 break;
789         case IO_SETGET_OUTPUT:
790                 /* bits set in *arg is set to output,
791                  * *arg updated with current output pins.
792                  */
793                 if (copy_from_user(&val, (unsigned long*)arg, sizeof(val)))
794                 {
795                         ret = -EFAULT;
796                         break;
797                 }
798                 val = setget_output(priv, val);
799                 if (copy_to_user((unsigned long*)arg, &val, sizeof(val)))
800                         ret = -EFAULT;
801                 break;
802         default:
803                 if (priv->minor == GPIO_MINOR_LEDS)
804                         ret = gpio_leds_ioctl(cmd, arg);
805                 else
806                         ret = -EINVAL;
807         } /* switch */
808
809         spin_unlock(&gpio_lock);
810         return ret;
811 }
812
813 static int
814 gpio_leds_ioctl(unsigned int cmd, unsigned long arg)
815 {
816         unsigned char green;
817         unsigned char red;
818
819         switch (_IOC_NR(cmd)) {
820         case IO_LEDACTIVE_SET:
821                 green = ((unsigned char) arg) & 1;
822                 red   = (((unsigned char) arg) >> 1) & 1;
823                 LED_ACTIVE_SET_G(green);
824                 LED_ACTIVE_SET_R(red);
825                 break;
826
827         case IO_LED_SETBIT:
828                 LED_BIT_SET(arg);
829                 break;
830
831         case IO_LED_CLRBIT:
832                 LED_BIT_CLR(arg);
833                 break;
834
835         default:
836                 return -EINVAL;
837         } /* switch */
838
839         return 0;
840 }
841
842 struct file_operations gpio_fops = {
843         .owner       = THIS_MODULE,
844         .poll        = gpio_poll,
845         .ioctl       = gpio_ioctl,
846         .write       = gpio_write,
847         .open        = gpio_open,
848         .release     = gpio_release,
849 };
850
851
852 void ioif_watcher(const unsigned int gpio_in_available,
853                   const unsigned int gpio_out_available,
854                   const unsigned char pa_available,
855                   const unsigned char pb_available)
856 {
857         unsigned long int flags;
858         D(printk("gpio.c: ioif_watcher called\n"));
859         D(printk("gpio.c: G in: 0x%08x G out: 0x%08x PA: 0x%02x PB: 0x%02x\n",
860                  gpio_in_available, gpio_out_available, pa_available, pb_available));
861
862         spin_lock_irqsave(&gpio_lock, flags);
863
864         dir_g_in_bits = gpio_in_available;
865         dir_g_out_bits = gpio_out_available;
866
867         /* Initialise the dir_g_shadow etc. depending on genconfig */
868         /* 0=input 1=output */
869         if (genconfig_shadow & IO_STATE(R_GEN_CONFIG, g0dir, out)) 
870                 dir_g_shadow |= (1 << 0);
871         if (genconfig_shadow & IO_STATE(R_GEN_CONFIG, g8_15dir, out))
872                 dir_g_shadow |= 0x0000FF00;
873         if (genconfig_shadow & IO_STATE(R_GEN_CONFIG, g16_23dir, out))
874                 dir_g_shadow |= 0x00FF0000;
875         if (genconfig_shadow & IO_STATE(R_GEN_CONFIG, g24dir, out))
876                 dir_g_shadow |= (1 << 24);
877
878         changeable_dir_g = changeable_dir_g_mask;
879         changeable_dir_g &= dir_g_out_bits;
880         changeable_dir_g &= dir_g_in_bits;
881         /* Correct the bits that can change direction */ 
882         dir_g_out_bits &= ~changeable_dir_g;
883         dir_g_out_bits |= dir_g_shadow;
884         dir_g_in_bits &= ~changeable_dir_g;
885         dir_g_in_bits |= (~dir_g_shadow & changeable_dir_g);
886
887         spin_unlock_irqrestore(&gpio_lock, flags);
888
889         printk(KERN_INFO "GPIO port G: in_bits: 0x%08lX out_bits: 0x%08lX val: %08lX\n",
890                dir_g_in_bits, dir_g_out_bits, (unsigned long)*R_PORT_G_DATA);
891         printk(KERN_INFO "GPIO port G: dir: %08lX changeable: %08lX\n",
892                dir_g_shadow, changeable_dir_g);
893 }
894
895 /* main driver initialization routine, called from mem.c */
896
897 static __init int
898 gpio_init(void)
899 {
900         int res;
901 #if defined (CONFIG_ETRAX_CSP0_LEDS)
902         int i;
903 #endif
904         printk("gpio init\n");
905
906         /* do the formalities */
907
908         res = register_chrdev(GPIO_MAJOR, gpio_name, &gpio_fops);
909         if (res < 0) {
910                 printk(KERN_ERR "gpio: couldn't get a major number.\n");
911                 return res;
912         }
913
914         /* Clear all leds */
915 #if defined (CONFIG_ETRAX_CSP0_LEDS) ||  defined (CONFIG_ETRAX_PA_LEDS) || defined (CONFIG_ETRAX_PB_LEDS)
916         LED_NETWORK_SET(0);
917         LED_ACTIVE_SET(0);
918         LED_DISK_READ(0);
919         LED_DISK_WRITE(0);
920
921 #if defined (CONFIG_ETRAX_CSP0_LEDS)
922         for (i = 0; i < 32; i++) {
923                 LED_BIT_SET(i);
924         }
925 #endif
926
927 #endif
928         /* The I/O interface allocation watcher will be called when
929          * registering it. */
930         if (cris_io_interface_register_watcher(ioif_watcher)){
931                 printk(KERN_WARNING "gpio_init: Failed to install IO if allocator watcher\n");
932         }
933
934         printk(KERN_INFO "ETRAX 100LX GPIO driver v2.5, (c) 2001, 2002, 2003, 2004 Axis Communications AB\n");
935         /* We call etrax_gpio_wake_up_check() from timer interrupt and
936          * from cpu_idle() in kernel/process.c
937          * The check in cpu_idle() reduces latency from ~15 ms to ~6 ms
938          * in some tests.
939          */  
940         if (request_irq(TIMER0_IRQ_NBR, gpio_poll_timer_interrupt,
941                         SA_SHIRQ | SA_INTERRUPT,"gpio poll", NULL)) {
942                 printk(KERN_CRIT "err: timer0 irq for gpio\n");
943         }
944         if (request_irq(PA_IRQ_NBR, gpio_pa_interrupt,
945                         SA_SHIRQ | SA_INTERRUPT,"gpio PA", NULL)) {
946                 printk(KERN_CRIT "err: PA irq for gpio\n");
947         }
948         
949
950         return res;
951 }
952
953 /* this makes sure that gpio_init is called during kernel boot */
954
955 module_init(gpio_init);