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