target/linux/danube/files/drivers/char/danube_gpio.c

   1 /*
   2  *   This program is free software; you can redistribute it and/or modify
   3  *   it under the terms of the GNU General Public License as published by
   4  *   the Free Software Foundation; either version 2 of the License, or
   5  *   (at your option) any later version.
   6  *
   7  *   This program is distributed in the hope that it will be useful,
   8  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  *   GNU General Public License for more details.
  11  *
  12  *   You should have received a copy of the GNU General Public License
  13  *   along with this program; if not, write to the Free Software
  14  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
  15  *
  16  *   Copyright (C) 2005 infineon
  17  *   Copyright (C) 2007 John Crispin <blogic@openwrt.org>
  18  *
  19  */
  20
  21 #include <linux/module.h>
  22 #include <linux/types.h>
  23 #include <linux/errno.h>
  24 #include <linux/proc_fs.h>
  25 #include <linux/init.h>
  26 #include <linux/ioctl.h>
  27 #include <asm/semaphore.h>
  28 #include <asm/uaccess.h>
  29 #include <asm/danube/danube.h>
  30 #include <asm/danube/danube_ioctl.h>
  31
  32
  33 #define DANUBE_PORT_OUT_REG                             0x00000010
  34 #define DANUBE_PORT_IN_REG                              0x00000014
  35 #define DANUBE_PORT_DIR_REG                             0x00000018
  36 #define DANUBE_PORT_ALTSEL0_REG                 0x0000001C
  37 #define DANUBE_PORT_ALTSEL1_REG                 0x00000020
  38 #define DANUBE_PORT_OD_REG                              0x00000024
  39 #define DANUBE_PORT_STOFF_REG                   0x00000028
  40 #define DANUBE_PORT_PUDSEL_REG                  0x0000002C
  41 #define DANUBE_PORT_PUDEN_REG                   0x00000030
  42
  43 #define PORT_MODULE_ID  0xff
  44
  45 #define PORT_WRITE_REG(reg, value)   \
  46                 *((volatile u32*)(reg)) = (u32)value;
  47
  48 #define PORT_READ_REG(reg, value)    \
  49                 value = (u32)*((volatile u32*)(reg));
  50
  51 #define PORT_IOC_CALL(ret,port,pin,func)    \
  52                 ret=danube_port_reserve_pin(port,pin,PORT_MODULE_ID); \
  53                 if (ret == 0) ret=func(port,pin,PORT_MODULE_ID); \
  54                 if (ret == 0) ret=danube_port_free_pin(port,pin,PORT_MODULE_ID);
  55
  56
  57 #define MAX_PORTS       2       // Number of ports in system
  58 #define PINS_PER_PORT   16      // Number of available pins per port
  59
  60 static int port_major = 0;
  61 static int danube_port_pin_usage[MAX_PORTS][PINS_PER_PORT];     // Map for pin usage
  62 static u32 danube_port_bases[MAX_PORTS]
  63         = { DANUBE_GPIO,
  64         DANUBE_GPIO + 0x00000030
  65 };                              // Base addresses for ports
  66
  67 static struct semaphore port_sem;
  68
  69 int
  70 danube_port_reserve_pin (int port, int pin, int module_id)
  71 {
  72         if (port < 0 || pin < 0)
  73                 return -EINVAL;
  74         if (port > MAX_PORTS || pin > PINS_PER_PORT)
  75                 return -EINVAL;
  76
  77         if (danube_port_pin_usage[port][pin] == 0) {
  78                 danube_port_pin_usage[port][pin] = module_id;
  79         }
  80         else {
  81                 return -EBUSY;
  82         }
  83
  84         return 0;
  85 }
  86
  87 int
  88 danube_port_free_pin (int port, int pin, int module_id)
  89 {
  90
  91         if (port < 0 || pin < 0)
  92                 return -EINVAL;
  93         if (port > MAX_PORTS || pin > PINS_PER_PORT)
  94                 return -EINVAL;
  95
  96         if (danube_port_pin_usage[port][pin] != module_id)
  97                 return -EBUSY;
  98         danube_port_pin_usage[port][pin] = 0;
  99
 100         return 0;
 101 }
 102
 103 int
 104 danube_port_set_open_drain (int port, int pin, int module_id)
 105 {
 106         u32 reg;
 107
 108         if (port < 0 || pin < 0)
 109                 return -EINVAL;
 110         if (port > MAX_PORTS || pin > PINS_PER_PORT)
 111                 return -EINVAL;
 112
 113         if (danube_port_pin_usage[port][pin] != module_id)
 114                 return -EBUSY;
 115
 116         PORT_READ_REG (danube_port_bases[port] + DANUBE_PORT_OD_REG, reg);
 117         reg |= (1 << pin);
 118         PORT_WRITE_REG (danube_port_bases[port] + DANUBE_PORT_OD_REG, reg);
 119
 120         return 0;
 121 }
 122
 123 int
 124 danube_port_clear_open_drain (int port, int pin, int module_id)
 125 {
 126         u32 reg;
 127
 128         if (port < 0 || pin < 0)
 129                 return -EINVAL;
 130         if (port > MAX_PORTS || pin > PINS_PER_PORT)
 131                 return -EINVAL;
 132
 133         if (danube_port_pin_usage[port][pin] != module_id)
 134                 return -EBUSY;
 135
 136         PORT_READ_REG (danube_port_bases[port] + DANUBE_PORT_OD_REG, reg);
 137         reg &= ~(1 << pin);
 138         PORT_WRITE_REG (danube_port_bases[port] + DANUBE_PORT_OD_REG, reg);
 139
 140         return 0;
 141 }
 142
 143 int
 144 danube_port_set_pudsel (int port, int pin, int module_id)
 145 {
 146         u32 reg;
 147
 148         if (port < 0 || pin < 0)
 149                 return -EINVAL;
 150         if (port > MAX_PORTS || pin > PINS_PER_PORT)
 151                 return -EINVAL;
 152
 153         if (danube_port_pin_usage[port][pin] != module_id)
 154                 return -EBUSY;
 155
 156         PORT_READ_REG (danube_port_bases[port] + DANUBE_PORT_PUDSEL_REG, reg);
 157         reg |= (1 << pin);
 158         PORT_WRITE_REG (danube_port_bases[port] + DANUBE_PORT_PUDSEL_REG,
 159                         reg);
 160
 161         return 0;
 162 }
 163
 164 int
 165 danube_port_clear_pudsel (int port, int pin, int module_id)
 166 {
 167         u32 reg;
 168
 169         if (port < 0 || pin < 0)
 170                 return -EINVAL;
 171         if (port > MAX_PORTS || pin > PINS_PER_PORT)
 172                 return -EINVAL;
 173
 174         if (danube_port_pin_usage[port][pin] != module_id)
 175                 return -EBUSY;
 176
 177         PORT_READ_REG (danube_port_bases[port] + DANUBE_PORT_PUDSEL_REG, reg);
 178         reg &= ~(1 << pin);
 179         PORT_WRITE_REG (danube_port_bases[port] + DANUBE_PORT_PUDSEL_REG,
 180                         reg);
 181
 182         return 0;
 183 }
 184
 185 int
 186 danube_port_set_puden (int port, int pin, int module_id)
 187 {
 188         u32 reg;
 189
 190         if (port < 0 || pin < 0)
 191                 return -EINVAL;
 192         if (port > MAX_PORTS || pin > PINS_PER_PORT)
 193                 return -EINVAL;
 194
 195         if (danube_port_pin_usage[port][pin] != module_id)
 196                 return -EBUSY;
 197
 198         PORT_READ_REG (danube_port_bases[port] + DANUBE_PORT_PUDEN_REG, reg);
 199         reg |= (1 << pin);
 200         PORT_WRITE_REG (danube_port_bases[port] + DANUBE_PORT_PUDEN_REG, reg);
 201
 202         return 0;
 203 }
 204
 205 int
 206 danube_port_clear_puden (int port, int pin, int module_id)
 207 {
 208         u32 reg;
 209
 210         if (port < 0 || pin < 0)
 211                 return -EINVAL;
 212         if (port > MAX_PORTS || pin > PINS_PER_PORT)
 213                 return -EINVAL;
 214
 215         if (danube_port_pin_usage[port][pin] != module_id)
 216                 return -EBUSY;
 217
 218         PORT_READ_REG (danube_port_bases[port] + DANUBE_PORT_PUDEN_REG, reg);
 219         reg &= ~(1 << pin);
 220         PORT_WRITE_REG (danube_port_bases[port] + DANUBE_PORT_PUDEN_REG, reg);
 221
 222         return 0;
 223 }
 224
 225 int
 226 danube_port_set_stoff (int port, int pin, int module_id)
 227 {
 228         u32 reg;
 229
 230         if (port < 0 || pin < 0)
 231                 return -EINVAL;
 232         if (port > MAX_PORTS || pin > PINS_PER_PORT)
 233                 return -EINVAL;
 234
 235         if (danube_port_pin_usage[port][pin] != module_id)
 236                 return -EBUSY;
 237
 238         PORT_READ_REG (danube_port_bases[port] + DANUBE_PORT_STOFF_REG, reg);
 239         reg |= (1 << pin);
 240         PORT_WRITE_REG (danube_port_bases[port] + DANUBE_PORT_STOFF_REG, reg);
 241
 242         return 0;
 243 }
 244
 245 int
 246 danube_port_clear_stoff (int port, int pin, int module_id)
 247 {
 248         u32 reg;
 249
 250         if (port < 0 || pin < 0)
 251                 return -EINVAL;
 252         if (port > MAX_PORTS || pin > PINS_PER_PORT)
 253                 return -EINVAL;
 254
 255         if (danube_port_pin_usage[port][pin] != module_id)
 256                 return -EBUSY;
 257
 258         PORT_READ_REG (danube_port_bases[port] + DANUBE_PORT_STOFF_REG, reg);
 259         reg &= ~(1 << pin);
 260         PORT_WRITE_REG (danube_port_bases[port] + DANUBE_PORT_STOFF_REG, reg);
 261
 262         return 0;
 263 }
 264
 265 int
 266 danube_port_set_dir_out (int port, int pin, int module_id)
 267 {
 268         u32 reg;
 269
 270         if (port < 0 || pin < 0)
 271                 return -EINVAL;
 272         if (port > MAX_PORTS || pin > PINS_PER_PORT)
 273                 return -EINVAL;
 274
 275         if (danube_port_pin_usage[port][pin] != module_id)
 276                 return -EBUSY;
 277
 278         PORT_READ_REG (danube_port_bases[port] + DANUBE_PORT_DIR_REG, reg);
 279         reg |= (1 << pin);
 280         PORT_WRITE_REG (danube_port_bases[port] + DANUBE_PORT_DIR_REG, reg);
 281
 282         return 0;
 283 }
 284
 285 int
 286 danube_port_set_dir_in (int port, int pin, int module_id)
 287 {
 288         u32 reg;
 289
 290         if (port < 0 || pin < 0)
 291                 return -EINVAL;
 292         if (port > MAX_PORTS || pin > PINS_PER_PORT)
 293                 return -EINVAL;
 294
 295         if (danube_port_pin_usage[port][pin] != module_id)
 296                 return -EBUSY;
 297
 298         PORT_READ_REG (danube_port_bases[port] + DANUBE_PORT_DIR_REG, reg);
 299         reg &= ~(1 << pin);
 300         PORT_WRITE_REG (danube_port_bases[port] + DANUBE_PORT_DIR_REG, reg);
 301
 302         return 0;
 303 }
 304
 305 int
 306 danube_port_set_output (int port, int pin, int module_id)
 307 {
 308         u32 reg;
 309
 310         if (port < 0 || pin < 0)
 311                 return -EINVAL;
 312         if (port > MAX_PORTS || pin > PINS_PER_PORT)
 313                 return -EINVAL;
 314
 315         if (danube_port_pin_usage[port][pin] != module_id)
 316                 return -EBUSY;
 317
 318         PORT_READ_REG (danube_port_bases[port] + DANUBE_PORT_OUT_REG, reg);
 319         reg |= (1 << pin);
 320         PORT_WRITE_REG (danube_port_bases[port] + DANUBE_PORT_OUT_REG, reg);
 321
 322         return 0;
 323 }
 324
 325 int
 326 danube_port_clear_output (int port, int pin, int module_id)
 327 {
 328         u32 reg;
 329
 330         if (port < 0 || pin < 0)
 331                 return -EINVAL;
 332         if (port > MAX_PORTS || pin > PINS_PER_PORT)
 333                 return -EINVAL;
 334
 335         if (danube_port_pin_usage[port][pin] != module_id)
 336                 return -EBUSY;
 337
 338         PORT_READ_REG (danube_port_bases[port] + DANUBE_PORT_OUT_REG, reg);
 339         reg &= ~(1 << pin);
 340         PORT_WRITE_REG (danube_port_bases[port] + DANUBE_PORT_OUT_REG, reg);
 341
 342         return 0;
 343 }
 344
 345 int
 346 danube_port_get_input (int port, int pin, int module_id)
 347 {
 348         u32 reg;
 349
 350         if (port < 0 || pin < 0)
 351                 return -EINVAL;
 352         if (port > MAX_PORTS || pin > PINS_PER_PORT)
 353                 return -EINVAL;
 354
 355         if (danube_port_pin_usage[port][pin] != module_id)
 356                 return -EBUSY;
 357
 358         PORT_READ_REG (danube_port_bases[port] + DANUBE_PORT_IN_REG, reg);
 359         reg &= (1 << pin);
 360         if (reg == 0x00)
 361                 return 0;
 362         else
 363                 return 1;
 364 }
 365
 366 int
 367 danube_port_set_altsel0 (int port, int pin, int module_id)
 368 {
 369         u32 reg;
 370
 371         if (port < 0 || pin < 0)
 372                 return -EINVAL;
 373         if (port > MAX_PORTS || pin > PINS_PER_PORT)
 374                 return -EINVAL;
 375
 376         if (danube_port_pin_usage[port][pin] != module_id)
 377                 return -EBUSY;
 378
 379         PORT_READ_REG (danube_port_bases[port] + DANUBE_PORT_ALTSEL0_REG,
 380                        reg);
 381         reg |= (1 << pin);
 382         PORT_WRITE_REG (danube_port_bases[port] + DANUBE_PORT_ALTSEL0_REG,
 383                         reg);
 384
 385         return 0;
 386 }
 387
 388 int
 389 danube_port_clear_altsel0 (int port, int pin, int module_id)
 390 {
 391         u32 reg;
 392
 393         if (port < 0 || pin < 0)
 394                 return -EINVAL;
 395         if (port > MAX_PORTS || pin > PINS_PER_PORT)
 396                 return -EINVAL;
 397
 398         if (danube_port_pin_usage[port][pin] != module_id)
 399                 return -EBUSY;
 400
 401         PORT_READ_REG (danube_port_bases[port] + DANUBE_PORT_ALTSEL0_REG,
 402                        reg);
 403         reg &= ~(1 << pin);
 404         PORT_WRITE_REG (danube_port_bases[port] + DANUBE_PORT_ALTSEL0_REG,
 405                         reg);
 406
 407         return 0;
 408 }
 409
 410 int
 411 danube_port_set_altsel1 (int port, int pin, int module_id)
 412 {
 413         u32 reg;
 414
 415         if (port < 0 || pin < 0)
 416                 return -EINVAL;
 417         if (port > MAX_PORTS || pin > PINS_PER_PORT)
 418                 return -EINVAL;
 419
 420         if (danube_port_pin_usage[port][pin] != module_id)
 421                 return -EBUSY;
 422
 423         PORT_READ_REG (danube_port_bases[port] + DANUBE_PORT_ALTSEL1_REG,
 424                        reg);
 425         reg |= (1 << pin);
 426         PORT_WRITE_REG (danube_port_bases[port] + DANUBE_PORT_ALTSEL1_REG,
 427                         reg);
 428
 429         return 0;
 430 }
 431
 432 int
 433 danube_port_clear_altsel1 (int port, int pin, int module_id)
 434 {
 435         u32 reg;
 436
 437         if (port < 0 || pin < 0)
 438                 return -EINVAL;
 439         if (port > MAX_PORTS || pin > PINS_PER_PORT)
 440                 return -EINVAL;
 441
 442         if (danube_port_pin_usage[port][pin] != module_id)
 443                 return -EBUSY;
 444
 445         PORT_READ_REG (danube_port_bases[port] + DANUBE_PORT_ALTSEL1_REG,
 446                        reg);
 447         reg &= ~(1 << pin);
 448         PORT_WRITE_REG (danube_port_bases[port] + DANUBE_PORT_ALTSEL1_REG,
 449                         reg);
 450
 451         return 0;
 452 }
 453
 454 int
 455 danube_port_read_procmem (char *buf, char **start, off_t offset, int count,
 456                           int *eof, void *data)
 457 {
 458         long len = 0;
 459         int t = 0;
 460         u32 bit = 0;
 461         u32 reg = 0;
 462
 463         len = sprintf (buf, "\nDanube Port Settings\n");
 464
 465         len = len + sprintf (buf + len,
 466                              "         3         2         1         0\n");
 467         len = len + sprintf (buf + len,
 468                              "        10987654321098765432109876543210\n");
 469         len = len + sprintf (buf + len,
 470                              "----------------------------------------\n");
 471
 472         len = len + sprintf (buf + len, "\nP0-OUT: ");
 473         PORT_READ_REG (DANUBE_GPIO_P0_OUT, reg);
 474         bit = 0x80000000;
 475         for (t = 0; t < 32; t++) {
 476                 if ((reg & bit) > 0)
 477                         len = len + sprintf (buf + len, "X");
 478                 else
 479                         len = len + sprintf (buf + len, " ");
 480                 bit = bit >> 1;
 481         }
 482
 483         len = len + sprintf (buf + len, "\nP1-OUT: ");
 484         PORT_READ_REG (DANUBE_GPIO_P1_OUT, reg);
 485         bit = 0x80000000;
 486         for (t = 0; t < 32; t++) {
 487                 if ((reg & bit) > 0)
 488                         len = len + sprintf (buf + len, "X");
 489                 else
 490                         len = len + sprintf (buf + len, " ");
 491                 bit = bit >> 1;
 492         }
 493
 494         len = len + sprintf (buf + len, "\nP0-IN:  ");
 495         PORT_READ_REG (DANUBE_GPIO_P0_IN, reg);
 496         bit = 0x80000000;
 497         for (t = 0; t < 32; t++) {
 498                 if ((reg & bit) > 0)
 499                         len = len + sprintf (buf + len, "X");
 500                 else
 501                         len = len + sprintf (buf + len, " ");
 502                 bit = bit >> 1;
 503         }
 504
 505         len = len + sprintf (buf + len, "\nP1-IN:  ");
 506         PORT_READ_REG (DANUBE_GPIO_P1_IN, reg);
 507         bit = 0x80000000;
 508         for (t = 0; t < 32; t++) {
 509                 if ((reg & bit) > 0)
 510                         len = len + sprintf (buf + len, "X");
 511                 else
 512                         len = len + sprintf (buf + len, " ");
 513                 bit = bit >> 1;
 514         }
 515
 516         len = len + sprintf (buf + len, "\nP0-DIR: ");
 517         PORT_READ_REG (DANUBE_GPIO_P0_DIR, reg);
 518         bit = 0x80000000;
 519         for (t = 0; t < 32; t++) {
 520                 if ((reg & bit) > 0)
 521                         len = len + sprintf (buf + len, "X");
 522                 else
 523                         len = len + sprintf (buf + len, " ");
 524                 bit = bit >> 1;
 525         }
 526
 527         len = len + sprintf (buf + len, "\nP1-DIR: ");
 528         PORT_READ_REG (DANUBE_GPIO_P1_DIR, reg);
 529         bit = 0x80000000;
 530         for (t = 0; t < 32; t++) {
 531                 if ((reg & bit) > 0)
 532                         len = len + sprintf (buf + len, "X");
 533                 else
 534                         len = len + sprintf (buf + len, " ");
 535                 bit = bit >> 1;
 536         }
 537
 538         len = len + sprintf (buf + len, "\nP0-STO: ");
 539         PORT_READ_REG (DANUBE_GPIO_P0_STOFF, reg);
 540         bit = 0x80000000;
 541         for (t = 0; t < 32; t++) {
 542                 if ((reg & bit) > 0)
 543                         len = len + sprintf (buf + len, "X");
 544                 else
 545                         len = len + sprintf (buf + len, " ");
 546                 bit = bit >> 1;
 547         }
 548
 549         len = len + sprintf (buf + len, "\nP1-STO: ");
 550         PORT_READ_REG (DANUBE_GPIO_P1_STOFF, reg);
 551         bit = 0x80000000;
 552         for (t = 0; t < 32; t++) {
 553                 if ((reg & bit) > 0)
 554                         len = len + sprintf (buf + len, "X");
 555                 else
 556                         len = len + sprintf (buf + len, " ");
 557                 bit = bit >> 1;
 558         }
 559
 560         len = len + sprintf (buf + len, "\nP0-PUDE:");
 561         PORT_READ_REG (DANUBE_GPIO_P0_PUDEN, reg);
 562         bit = 0x80000000;
 563         for (t = 0; t < 32; t++) {
 564                 if ((reg & bit) > 0)
 565                         len = len + sprintf (buf + len, "X");
 566                 else
 567                         len = len + sprintf (buf + len, " ");
 568                 bit = bit >> 1;
 569         }
 570
 571         len = len + sprintf (buf + len, "\nP1-PUDE:");
 572         PORT_READ_REG (DANUBE_GPIO_P1_PUDEN, reg);
 573         bit = 0x80000000;
 574         for (t = 0; t < 32; t++) {
 575                 if ((reg & bit) > 0)
 576                         len = len + sprintf (buf + len, "X");
 577                 else
 578                         len = len + sprintf (buf + len, " ");
 579                 bit = bit >> 1;
 580         }
 581
 582         len = len + sprintf (buf + len, "\nP0-OD:  ");
 583         PORT_READ_REG (DANUBE_GPIO_P0_OD, reg);
 584         bit = 0x80000000;
 585         for (t = 0; t < 32; t++) {
 586                 if ((reg & bit) > 0)
 587                         len = len + sprintf (buf + len, "X");
 588                 else
 589                         len = len + sprintf (buf + len, " ");
 590                 bit = bit >> 1;
 591         }
 592
 593         len = len + sprintf (buf + len, "\nP1-OD:  ");
 594         PORT_READ_REG (DANUBE_GPIO_P1_OD, reg);
 595         bit = 0x80000000;
 596         for (t = 0; t < 32; t++) {
 597                 if ((reg & bit) > 0)
 598                         len = len + sprintf (buf + len, "X");
 599                 else
 600                         len = len + sprintf (buf + len, " ");
 601                 bit = bit >> 1;
 602         }
 603
 604         len = len + sprintf (buf + len, "\nP0-PUDS:");
 605         PORT_READ_REG (DANUBE_GPIO_P0_PUDSEL, reg);
 606         bit = 0x80000000;
 607         for (t = 0; t < 32; t++) {
 608                 if ((reg & bit) > 0)
 609                         len = len + sprintf (buf + len, "X");
 610                 else
 611                         len = len + sprintf (buf + len, " ");
 612                 bit = bit >> 1;
 613         }
 614
 615         len = len + sprintf (buf + len, "\nP1-PUDS:");
 616         PORT_READ_REG (DANUBE_GPIO_P1_PUDSEL, reg);
 617         bit = 0x80000000;
 618         for (t = 0; t < 32; t++) {
 619                 if ((reg & bit) > 0)
 620                         len = len + sprintf (buf + len, "X");
 621                 else
 622                         len = len + sprintf (buf + len, " ");
 623                 bit = bit >> 1;
 624         }
 625
 626         len = len + sprintf (buf + len, "\nP0_ALT0:");
 627         PORT_READ_REG (DANUBE_GPIO_P0_ALTSEL0, reg);
 628         bit = 0x80000000;
 629         for (t = 0; t < 32; t++) {
 630                 if ((reg & bit) > 0)
 631                         len = len + sprintf (buf + len, "X");
 632                 else
 633                         len = len + sprintf (buf + len, " ");
 634                 bit = bit >> 1;
 635         }
 636
 637         len = len + sprintf (buf + len, "\nP0_ALT1:");
 638         PORT_READ_REG (DANUBE_GPIO_P0_ALTSEL1, reg);
 639         bit = 0x80000000;
 640         for (t = 0; t < 32; t++) {
 641                 if ((reg & bit) > 0)
 642                         len = len + sprintf (buf + len, "X");
 643                 else
 644                         len = len + sprintf (buf + len, " ");
 645                 bit = bit >> 1;
 646         }
 647
 648         len = len + sprintf (buf + len, "\nP1_ALT0:");
 649         PORT_READ_REG (DANUBE_GPIO_P1_ALTSEL0, reg);
 650         bit = 0x80000000;
 651         for (t = 0; t < 32; t++) {
 652                 if ((reg & bit) > 0)
 653                         len = len + sprintf (buf + len, "X");
 654                 else
 655                         len = len + sprintf (buf + len, " ");
 656                 bit = bit >> 1;
 657         }
 658
 659         len = len + sprintf (buf + len, "\nP1_ALT1:");
 660         PORT_READ_REG (DANUBE_GPIO_P1_ALTSEL1, reg);
 661         bit = 0x80000000;
 662         for (t = 0; t < 32; t++) {
 663                 if ((reg & bit) > 0)
 664                         len = len + sprintf (buf + len, "X");
 665                 else
 666                         len = len + sprintf (buf + len, " ");
 667                 bit = bit >> 1;
 668         }
 669
 670         len = len + sprintf (buf + len, "\n\n");
 671
 672         *eof = 1;               // No more data available
 673         return len;
 674 }
 675
 676 static int
 677 danube_port_open (struct inode *inode, struct file *filep)
 678 {
 679         return 0;
 680 }
 681
 682 static int
 683 danube_port_release (struct inode *inode, struct file *filelp)
 684 {
 685         return 0;
 686 }
 687
 688 static int
 689 danube_port_ioctl (struct inode *inode, struct file *filp,
 690                    unsigned int cmd, unsigned long arg)
 691 {
 692         int ret = 0;
 693         volatile struct danube_port_ioctl_parm parm;
 694
 695         if (_IOC_TYPE (cmd) != DANUBE_PORT_IOC_MAGIC)
 696                 return -EINVAL;
 697
 698         if (_IOC_DIR (cmd) & _IOC_WRITE) {
 699                 if (!access_ok
 700                     (VERIFY_READ, arg,
 701                      sizeof (struct danube_port_ioctl_parm)))
 702                         return -EFAULT;
 703                 ret = copy_from_user ((void *) &parm, (void *) arg,
 704                                       sizeof (struct danube_port_ioctl_parm));
 705         }
 706         if (_IOC_DIR (cmd) & _IOC_READ) {
 707                 if (!access_ok
 708                     (VERIFY_WRITE, arg,
 709                      sizeof (struct danube_port_ioctl_parm)))
 710                         return -EFAULT;
 711         }
 712
 713         if (down_trylock (&port_sem) != 0)
 714                 return -EBUSY;
 715
 716         switch (cmd) {
 717         case DANUBE_PORT_IOCOD:
 718                 if (parm.value == 0x00) {
 719                         PORT_IOC_CALL (ret, parm.port, parm.pin,
 720                                        danube_port_clear_open_drain);
 721                 }
 722                 else {
 723                         PORT_IOC_CALL (ret, parm.port, parm.pin,
 724                                        danube_port_set_open_drain);
 725                 }
 726                 break;
 727         case DANUBE_PORT_IOCPUDSEL:
 728                 if (parm.value == 0x00) {
 729                         PORT_IOC_CALL (ret, parm.port, parm.pin,
 730                                        danube_port_clear_pudsel);
 731                 }
 732                 else {
 733                         PORT_IOC_CALL (ret, parm.port, parm.pin,
 734                                        danube_port_set_pudsel);
 735                 }
 736                 break;
 737         case DANUBE_PORT_IOCPUDEN:
 738                 if (parm.value == 0x00) {
 739                         PORT_IOC_CALL (ret, parm.port, parm.pin,
 740                                        danube_port_clear_puden);
 741                 }
 742                 else {
 743                         PORT_IOC_CALL (ret, parm.port, parm.pin,
 744                                        danube_port_set_puden);
 745                 }
 746                 break;
 747         case DANUBE_PORT_IOCSTOFF:
 748                 if (parm.value == 0x00) {
 749                         PORT_IOC_CALL (ret, parm.port, parm.pin,
 750                                        danube_port_clear_stoff);
 751                 }
 752                 else {
 753                         PORT_IOC_CALL (ret, parm.port, parm.pin,
 754                                        danube_port_set_stoff);
 755                 }
 756                 break;
 757         case DANUBE_PORT_IOCDIR:
 758                 if (parm.value == 0x00) {
 759                         PORT_IOC_CALL (ret, parm.port, parm.pin,
 760                                        danube_port_set_dir_in);
 761                 }
 762                 else {
 763                         PORT_IOC_CALL (ret, parm.port, parm.pin,
 764                                        danube_port_set_dir_out);
 765                 }
 766                 break;
 767         case DANUBE_PORT_IOCOUTPUT:
 768                 if (parm.value == 0x00) {
 769                         PORT_IOC_CALL (ret, parm.port, parm.pin,
 770                                        danube_port_clear_output);
 771                 }
 772                 else {
 773                         PORT_IOC_CALL (ret, parm.port, parm.pin,
 774                                        danube_port_set_output);
 775                 }
 776                 break;
 777         case DANUBE_PORT_IOCALTSEL0:
 778                 if (parm.value == 0x00) {
 779                         PORT_IOC_CALL (ret, parm.port, parm.pin,
 780                                        danube_port_clear_altsel0);
 781                 }
 782                 else {
 783                         PORT_IOC_CALL (ret, parm.port, parm.pin,
 784                                        danube_port_set_altsel0);
 785                 }
 786                 break;
 787         case DANUBE_PORT_IOCALTSEL1:
 788                 if (parm.value == 0x00) {
 789                         PORT_IOC_CALL (ret, parm.port, parm.pin,
 790                                        danube_port_clear_altsel1);
 791                 }
 792                 else {
 793                         PORT_IOC_CALL (ret, parm.port, parm.pin,
 794                                        danube_port_set_altsel1);
 795                 }
 796                 break;
 797         case DANUBE_PORT_IOCINPUT:
 798                 ret = danube_port_reserve_pin (parm.port, parm.pin,
 799                                                PORT_MODULE_ID);
 800                 if (ret == 0)
 801                         parm.value =
 802                                 danube_port_get_input (parm.port, parm.pin,
 803                                                        PORT_MODULE_ID);
 804                 ret = danube_port_free_pin (parm.port, parm.pin,
 805                                             PORT_MODULE_ID);
 806                 copy_to_user ((void *) arg, (void *) &parm,
 807                               sizeof (struct danube_port_ioctl_parm));
 808                 break;
 809         default:
 810                 ret = -EINVAL;
 811         }
 812
 813         up (&port_sem);
 814
 815         return ret;
 816 }
 817
 818 static struct file_operations port_fops = {
 819       open:danube_port_open,
 820       release:danube_port_release,
 821       ioctl:danube_port_ioctl
 822 };
 823
 824 int __init
 825 danube_port_init (void)
 826 {
 827         int t = 0;
 828         int i = 0;
 829         int err = 0;
 830         u32 pins = 0;
 831
 832         printk ("Danube Port Initialization\n");
 833
 834         sema_init (&port_sem, 1);
 835
 836         /* Check ports for available pins */
 837         for (t = 0; t < MAX_PORTS; t++) {
 838                 for (i = 0; i < PINS_PER_PORT; i++)
 839                         danube_port_pin_usage[t][i] = 0;
 840         }
 841
 842         /* register port device */
 843         err = register_chrdev (0, "danube-port", &port_fops);
 844         if (err > 0)
 845                 port_major = err;
 846         else {
 847                 printk ("danube-port: Error! Could not register port device. #%d\n", err);
 848                 return err;
 849         }
 850
 851         /* Create proc file */
 852         create_proc_read_entry ("driver/danube_port", 0, NULL,
 853                                 danube_port_read_procmem, NULL);
 854
 855         return 0;
 856 }
 857
 858 module_init (danube_port_init);
 859
 860 EXPORT_SYMBOL (danube_port_reserve_pin);
 861 EXPORT_SYMBOL (danube_port_free_pin);
 862 EXPORT_SYMBOL (danube_port_set_open_drain);
 863 EXPORT_SYMBOL (danube_port_clear_open_drain);
 864 EXPORT_SYMBOL (danube_port_set_pudsel);
 865 EXPORT_SYMBOL (danube_port_clear_pudsel);
 866 EXPORT_SYMBOL (danube_port_set_puden);
 867 EXPORT_SYMBOL (danube_port_clear_puden);
 868 EXPORT_SYMBOL (danube_port_set_stoff);
 869 EXPORT_SYMBOL (danube_port_clear_stoff);
 870 EXPORT_SYMBOL (danube_port_set_dir_out);
 871 EXPORT_SYMBOL (danube_port_set_dir_in);
 872 EXPORT_SYMBOL (danube_port_set_output);
 873 EXPORT_SYMBOL (danube_port_clear_output);
 874 EXPORT_SYMBOL (danube_port_get_input);
 875
 876 EXPORT_SYMBOL (danube_port_set_altsel0);
 877 EXPORT_SYMBOL (danube_port_clear_altsel0);
 878 EXPORT_SYMBOL (danube_port_set_altsel1);
 879 EXPORT_SYMBOL (danube_port_clear_altsel1);