arch/cris/arch-v10/kernel/io_interface_mux.c

   1 /* IO interface mux allocator for ETRAX100LX.
   2  * Copyright 2004-2007, Axis Communications AB
   3  */
   4
   5
   6 /* C.f. ETRAX100LX Designer's Reference chapter 19.9 */
   7
   8 #include <linux/kernel.h>
   9 #include <linux/slab.h>
  10 #include <linux/errno.h>
  11 #include <linux/module.h>
  12 #include <linux/init.h>
  13
  14 #include <arch/svinto.h>
  15 #include <asm/io.h>
  16 #include <arch/io_interface_mux.h>
  17
  18
  19 #define DBG(s)
  20
  21 /* Macro to access ETRAX 100 registers */
  22 #define SETS(var, reg, field, val) var = (var & ~IO_MASK_(reg##_, field##_)) | \
  23                                           IO_STATE_(reg##_, field##_, _##val)
  24
  25 enum io_if_group {
  26         group_a = (1<<0),
  27         group_b = (1<<1),
  28         group_c = (1<<2),
  29         group_d = (1<<3),
  30         group_e = (1<<4),
  31         group_f = (1<<5)
  32 };
  33
  34 struct watcher
  35 {
  36         void (*notify)(const unsigned int gpio_in_available,
  37                        const unsigned int gpio_out_available,
  38                        const unsigned char pa_available,
  39                        const unsigned char pb_available);
  40         struct watcher *next;
  41 };
  42
  43
  44 struct if_group
  45 {
  46         enum io_if_group        group;
  47         /* name - the name of the group 'A' to 'F' */
  48         char                   *name;
  49         /* used - a bit mask of all pins in the group in the order listed
  50          * in the tables in 19.9.1 to 19.9.6.  Note that no
  51          * distinction is made between in, out and in/out pins. */
  52         unsigned int            used;
  53 };
  54
  55
  56 struct interface
  57 {
  58         enum cris_io_interface   ioif;
  59         /* name - the name of the interface */
  60         char                    *name;
  61         /* groups - OR'ed together io_if_group flags describing what pin groups
  62          * the interface uses pins in. */
  63         unsigned char            groups;
  64         /* used - set when the interface is allocated. */
  65         unsigned char            used;
  66         char                    *owner;
  67         /* group_a through group_f - bit masks describing what pins in the
  68          * pin groups the interface uses. */
  69         unsigned int             group_a;
  70         unsigned int             group_b;
  71         unsigned int             group_c;
  72         unsigned int             group_d;
  73         unsigned int             group_e;
  74         unsigned int             group_f;
  75
  76         /* gpio_g_in, gpio_g_out, gpio_b - bit masks telling what pins in the
  77          * GPIO ports the interface uses.  This could be reconstucted using
  78          * the group_X masks and a table of what pins the GPIO ports use,
  79          * but that would be messy. */
  80         unsigned int             gpio_g_in;
  81         unsigned int             gpio_g_out;
  82         unsigned char            gpio_b;
  83 };
  84
  85 static struct if_group if_groups[6] = {
  86         {
  87                 .group = group_a,
  88                 .name = "A",
  89                 .used = 0,
  90         },
  91         {
  92                 .group = group_b,
  93                 .name = "B",
  94                 .used = 0,
  95         },
  96         {
  97                 .group = group_c,
  98                 .name = "C",
  99                 .used = 0,
 100         },
 101         {
 102                 .group = group_d,
 103                 .name = "D",
 104                 .used = 0,
 105         },
 106         {
 107                 .group = group_e,
 108                 .name = "E",
 109                 .used = 0,
 110         },
 111         {
 112                 .group = group_f,
 113                 .name = "F",
 114                 .used = 0,
 115         }
 116 };
 117
 118 /* The order in the array must match the order of enum
 119  * cris_io_interface in io_interface_mux.h */
 120 static struct interface interfaces[] = {
 121         /* Begin Non-multiplexed interfaces */
 122         {
 123                 .ioif = if_eth,
 124                 .name = "ethernet",
 125                 .groups = 0,
 126
 127                 .group_a = 0,
 128                 .group_b = 0,
 129                 .group_c = 0,
 130                 .group_d = 0,
 131                 .group_e = 0,
 132                 .group_f = 0,
 133
 134                 .gpio_g_in = 0,
 135                 .gpio_g_out = 0,
 136                 .gpio_b = 0
 137         },
 138         {
 139                 .ioif = if_serial_0,
 140                 .name = "serial_0",
 141                 .groups = 0,
 142
 143                 .group_a = 0,
 144                 .group_b = 0,
 145                 .group_c = 0,
 146                 .group_d = 0,
 147                 .group_e = 0,
 148                 .group_f = 0,
 149
 150                 .gpio_g_in = 0,
 151                 .gpio_g_out = 0,
 152                 .gpio_b = 0
 153         },
 154         /* End Non-multiplexed interfaces */
 155         {
 156                 .ioif = if_serial_1,
 157                 .name = "serial_1",
 158                 .groups = group_e,
 159
 160                 .group_a = 0,
 161                 .group_b = 0,
 162                 .group_c = 0,
 163                 .group_d = 0,
 164                 .group_e = 0x0f,
 165                 .group_f = 0,
 166
 167                 .gpio_g_in =  0x00000000,
 168                 .gpio_g_out = 0x00000000,
 169                 .gpio_b = 0x00
 170         },
 171         {
 172                 .ioif = if_serial_2,
 173                 .name = "serial_2",
 174                 .groups = group_b,
 175
 176                 .group_a = 0,
 177                 .group_b = 0x0f,
 178                 .group_c = 0,
 179                 .group_d = 0,
 180                 .group_e = 0,
 181                 .group_f = 0,
 182
 183                 .gpio_g_in =  0x000000c0,
 184                 .gpio_g_out = 0x000000c0,
 185                 .gpio_b = 0x00
 186         },
 187         {
 188                 .ioif = if_serial_3,
 189                 .name = "serial_3",
 190                 .groups = group_c,
 191
 192                 .group_a = 0,
 193                 .group_b = 0,
 194                 .group_c = 0x0f,
 195                 .group_d = 0,
 196                 .group_e = 0,
 197                 .group_f = 0,
 198
 199                 .gpio_g_in =  0xc0000000,
 200                 .gpio_g_out = 0xc0000000,
 201                 .gpio_b = 0x00
 202         },
 203         {
 204                 .ioif = if_sync_serial_1,
 205                 .name = "sync_serial_1",
 206                 .groups = group_e | group_f,
 207
 208                 .group_a = 0,
 209                 .group_b = 0,
 210                 .group_c = 0,
 211                 .group_d = 0,
 212                 .group_e = 0x0f,
 213                 .group_f = 0x10,
 214
 215                 .gpio_g_in =  0x00000000,
 216                 .gpio_g_out = 0x00000000,
 217                 .gpio_b = 0x10
 218         },
 219         {
 220                 .ioif = if_sync_serial_3,
 221                 .name = "sync_serial_3",
 222                 .groups = group_c | group_f,
 223
 224                 .group_a = 0,
 225                 .group_b = 0,
 226                 .group_c = 0x0f,
 227                 .group_d = 0,
 228                 .group_e = 0,
 229                 .group_f = 0x80,
 230
 231                 .gpio_g_in =  0xc0000000,
 232                 .gpio_g_out = 0xc0000000,
 233                 .gpio_b = 0x80
 234         },
 235         {
 236                 .ioif = if_shared_ram,
 237                 .name = "shared_ram",
 238                 .groups = group_a,
 239
 240                 .group_a = 0x7f8ff,
 241                 .group_b = 0,
 242                 .group_c = 0,
 243                 .group_d = 0,
 244                 .group_e = 0,
 245                 .group_f = 0,
 246
 247                 .gpio_g_in =  0x0000ff3e,
 248                 .gpio_g_out = 0x0000ff38,
 249                 .gpio_b = 0x00
 250         },
 251         {
 252                 .ioif = if_shared_ram_w,
 253                 .name = "shared_ram_w",
 254                 .groups = group_a | group_d,
 255
 256                 .group_a = 0x7f8ff,
 257                 .group_b = 0,
 258                 .group_c = 0,
 259                 .group_d = 0xff,
 260                 .group_e = 0,
 261                 .group_f = 0,
 262
 263                 .gpio_g_in =  0x00ffff3e,
 264                 .gpio_g_out = 0x00ffff38,
 265                 .gpio_b = 0x00
 266         },
 267         {
 268                 .ioif = if_par_0,
 269                 .name = "par_0",
 270                 .groups = group_a,
 271
 272                 .group_a = 0x7fbff,
 273                 .group_b = 0,
 274                 .group_c = 0,
 275                 .group_d = 0,
 276                 .group_e = 0,
 277                 .group_f = 0,
 278
 279                 .gpio_g_in =  0x0000ff3e,
 280                 .gpio_g_out = 0x0000ff3e,
 281                 .gpio_b = 0x00
 282         },
 283         {
 284                 .ioif = if_par_1,
 285                 .name = "par_1",
 286                 .groups = group_d,
 287
 288                 .group_a = 0,
 289                 .group_b = 0,
 290                 .group_c = 0,
 291                 .group_d = 0x7feff,
 292                 .group_e = 0,
 293                 .group_f = 0,
 294
 295                 .gpio_g_in =  0x3eff0000,
 296                 .gpio_g_out = 0x3eff0000,
 297                 .gpio_b = 0x00
 298         },
 299         {
 300                 .ioif = if_par_w,
 301                 .name = "par_w",
 302                 .groups = group_a | group_d,
 303
 304                 .group_a = 0x7fbff,
 305                 .group_b = 0,
 306                 .group_c = 0,
 307                 .group_d = 0xff,
 308                 .group_e = 0,
 309                 .group_f = 0,
 310
 311                 .gpio_g_in =  0x00ffff3e,
 312                 .gpio_g_out = 0x00ffff3e,
 313                 .gpio_b = 0x00
 314         },
 315         {
 316                 .ioif = if_scsi8_0,
 317                 .name = "scsi8_0",
 318                 .groups = group_a | group_b | group_f,
 319
 320                 .group_a = 0x7ffff,
 321                 .group_b = 0x0f,
 322                 .group_c = 0,
 323                 .group_d = 0,
 324                 .group_e = 0,
 325                 .group_f = 0x10,
 326
 327                 .gpio_g_in =  0x0000ffff,
 328                 .gpio_g_out = 0x0000ffff,
 329                 .gpio_b = 0x10
 330         },
 331         {
 332                 .ioif = if_scsi8_1,
 333                 .name = "scsi8_1",
 334                 .groups = group_c | group_d | group_f,
 335
 336                 .group_a = 0,
 337                 .group_b = 0,
 338                 .group_c = 0x0f,
 339                 .group_d = 0x7ffff,
 340                 .group_e = 0,
 341                 .group_f = 0x80,
 342
 343                 .gpio_g_in =  0xffff0000,
 344                 .gpio_g_out = 0xffff0000,
 345                 .gpio_b = 0x80
 346         },
 347         {
 348                 .ioif = if_scsi_w,
 349                 .name = "scsi_w",
 350                 .groups = group_a | group_b | group_d | group_f,
 351
 352                 .group_a = 0x7ffff,
 353                 .group_b = 0x0f,
 354                 .group_c = 0,
 355                 .group_d = 0x601ff,
 356                 .group_e = 0,
 357                 .group_f = 0x90,
 358
 359                 .gpio_g_in =  0x01ffffff,
 360                 .gpio_g_out = 0x07ffffff,
 361                 .gpio_b = 0x80
 362         },
 363         {
 364                 .ioif = if_ata,
 365                 .name = "ata",
 366                 .groups = group_a | group_b | group_c | group_d,
 367
 368                 .group_a = 0x7ffff,
 369                 .group_b = 0x0f,
 370                 .group_c = 0x0f,
 371                 .group_d = 0x7cfff,
 372                 .group_e = 0,
 373                 .group_f = 0,
 374
 375                 .gpio_g_in =  0xf9ffffff,
 376                 .gpio_g_out = 0xffffffff,
 377                 .gpio_b = 0x80
 378         },
 379         {
 380                 .ioif = if_csp,
 381                 .name = "csp",
 382                 .groups = group_f,
 383
 384                 .group_a = 0,
 385                 .group_b = 0,
 386                 .group_c = 0,
 387                 .group_d = 0,
 388                 .group_e = 0,
 389                 .group_f = 0xfc,
 390
 391                 .gpio_g_in =  0x00000000,
 392                 .gpio_g_out = 0x00000000,
 393                 .gpio_b = 0xfc
 394         },
 395         {
 396                 .ioif = if_i2c,
 397                 .name = "i2c",
 398                 .groups = group_f,
 399
 400                 .group_a = 0,
 401                 .group_b = 0,
 402                 .group_c = 0,
 403                 .group_d = 0,
 404                 .group_e = 0,
 405                 .group_f = 0x03,
 406
 407                 .gpio_g_in =  0x00000000,
 408                 .gpio_g_out = 0x00000000,
 409                 .gpio_b = 0x03
 410         },
 411         {
 412                 .ioif = if_usb_1,
 413                 .name = "usb_1",
 414                 .groups = group_e | group_f,
 415
 416                 .group_a = 0,
 417                 .group_b = 0,
 418                 .group_c = 0,
 419                 .group_d = 0,
 420                 .group_e = 0x0f,
 421                 .group_f = 0x2c,
 422
 423                 .gpio_g_in =  0x00000000,
 424                 .gpio_g_out = 0x00000000,
 425                 .gpio_b = 0x2c
 426         },
 427         {
 428                 .ioif = if_usb_2,
 429                 .name = "usb_2",
 430                 .groups = group_d,
 431
 432                 .group_a = 0,
 433                 .group_b = 0,
 434                 .group_c = 0,
 435                 .group_d = 0,
 436                 .group_e = 0x33e00,
 437                 .group_f = 0,
 438
 439                 .gpio_g_in =  0x3e000000,
 440                 .gpio_g_out = 0x0c000000,
 441                 .gpio_b = 0x00
 442         },
 443         /* GPIO pins */
 444         {
 445                 .ioif = if_gpio_grp_a,
 446                 .name = "gpio_a",
 447                 .groups = group_a,
 448
 449                 .group_a = 0,
 450                 .group_b = 0,
 451                 .group_c = 0,
 452                 .group_d = 0,
 453                 .group_e = 0,
 454                 .group_f = 0,
 455
 456                 .gpio_g_in =  0x0000ff3f,
 457                 .gpio_g_out = 0x0000ff3f,
 458                 .gpio_b = 0x00
 459         },
 460         {
 461                 .ioif = if_gpio_grp_b,
 462                 .name = "gpio_b",
 463                 .groups = group_b,
 464
 465                 .group_a = 0,
 466                 .group_b = 0,
 467                 .group_c = 0,
 468                 .group_d = 0,
 469                 .group_e = 0,
 470                 .group_f = 0,
 471
 472                 .gpio_g_in =  0x000000c0,
 473                 .gpio_g_out = 0x000000c0,
 474                 .gpio_b = 0x00
 475         },
 476         {
 477                 .ioif = if_gpio_grp_c,
 478                 .name = "gpio_c",
 479                 .groups = group_c,
 480
 481                 .group_a = 0,
 482                 .group_b = 0,
 483                 .group_c = 0,
 484                 .group_d = 0,
 485                 .group_e = 0,
 486                 .group_f = 0,
 487
 488                 .gpio_g_in =  0xc0000000,
 489                 .gpio_g_out = 0xc0000000,
 490                 .gpio_b = 0x00
 491         },
 492         {
 493                 .ioif = if_gpio_grp_d,
 494                 .name = "gpio_d",
 495                 .groups = group_d,
 496
 497                 .group_a = 0,
 498                 .group_b = 0,
 499                 .group_c = 0,
 500                 .group_d = 0,
 501                 .group_e = 0,
 502                 .group_f = 0,
 503
 504                 .gpio_g_in =  0x3fff0000,
 505                 .gpio_g_out = 0x3fff0000,
 506                 .gpio_b = 0x00
 507         },
 508         {
 509                 .ioif = if_gpio_grp_e,
 510                 .name = "gpio_e",
 511                 .groups = group_e,
 512
 513                 .group_a = 0,
 514                 .group_b = 0,
 515                 .group_c = 0,
 516                 .group_d = 0,
 517                 .group_e = 0,
 518                 .group_f = 0,
 519
 520                 .gpio_g_in =  0x00000000,
 521                 .gpio_g_out = 0x00000000,
 522                 .gpio_b = 0x00
 523         },
 524         {
 525                 .ioif = if_gpio_grp_f,
 526                 .name = "gpio_f",
 527                 .groups = group_f,
 528
 529                 .group_a = 0,
 530                 .group_b = 0,
 531                 .group_c = 0,
 532                 .group_d = 0,
 533                 .group_e = 0,
 534                 .group_f = 0,
 535
 536                 .gpio_g_in =  0x00000000,
 537                 .gpio_g_out = 0x00000000,
 538                 .gpio_b = 0xff
 539         }
 540         /* Array end */
 541 };
 542
 543 static struct watcher *watchers = NULL;
 544
 545 /* The pins that are free to use in the GPIO ports. */
 546 static unsigned int gpio_in_pins =  0xffffffff;
 547 static unsigned int gpio_out_pins = 0xffffffff;
 548 static unsigned char gpio_pb_pins = 0xff;
 549 static unsigned char gpio_pa_pins = 0xff;
 550
 551 /* Identifiers for the owners of the GPIO pins. */
 552 static enum cris_io_interface gpio_pa_owners[8];
 553 static enum cris_io_interface gpio_pb_owners[8];
 554 static enum cris_io_interface gpio_pg_owners[32];
 555
 556 static int cris_io_interface_init(void);
 557
 558 static unsigned char clear_group_from_set(const unsigned char groups, struct if_group *group)
 559 {
 560         return (groups & ~group->group);
 561 }
 562
 563
 564 static struct if_group *get_group(const unsigned char groups)
 565 {
 566         int i;
 567         for (i = 0; i < ARRAY_SIZE(if_groups); i++) {
 568                 if (groups & if_groups[i].group) {
 569                         return &if_groups[i];
 570                 }
 571         }
 572         return NULL;
 573 }
 574
 575
 576 static void notify_watchers(void)
 577 {
 578         struct watcher *w = watchers;
 579
 580         DBG(printk("io_interface_mux: notifying watchers\n"));
 581
 582         while (NULL != w) {
 583                 w->notify((const unsigned int)gpio_in_pins,
 584                           (const unsigned int)gpio_out_pins,
 585                           (const unsigned char)gpio_pa_pins,
 586                           (const unsigned char)gpio_pb_pins);
 587                 w = w->next;
 588         }
 589 }
 590
 591
 592 int cris_request_io_interface(enum cris_io_interface ioif, const char *device_id)
 593 {
 594         int set_gen_config = 0;
 595         int set_gen_config_ii = 0;
 596         unsigned long int gens;
 597         unsigned long int gens_ii;
 598         struct if_group *grp;
 599         unsigned char group_set;
 600         unsigned long flags;
 601         int res = 0;
 602
 603         (void)cris_io_interface_init();
 604
 605         DBG(printk("cris_request_io_interface(%d, \"%s\")\n", ioif, device_id));
 606
 607         if ((ioif >= if_max_interfaces) || (ioif < 0)) {
 608                 printk(KERN_CRIT "cris_request_io_interface: Bad interface "
 609                         "%u submitted for %s\n",
 610                        ioif,
 611                        device_id);
 612                 return -EINVAL;
 613         }
 614
 615         local_irq_save(flags);
 616
 617         if (interfaces[ioif].used) {
 618                 printk(KERN_CRIT "cris_io_interface: Cannot allocate interface "
 619                         "%s for %s, in use by %s\n",
 620                        interfaces[ioif].name,
 621                        device_id,
 622                        interfaces[ioif].owner);
 623                 res = -EBUSY;
 624                 goto exit;
 625         }
 626
 627         /* Check that all required pins in the used groups are free
 628          * before allocating. */
 629         group_set = interfaces[ioif].groups;
 630         while (NULL != (grp = get_group(group_set))) {
 631                 unsigned int if_group_use = 0;
 632
 633                 switch (grp->group) {
 634                 case group_a:
 635                         if_group_use = interfaces[ioif].group_a;
 636                         break;
 637                 case group_b:
 638                         if_group_use = interfaces[ioif].group_b;
 639                         break;
 640                 case group_c:
 641                         if_group_use = interfaces[ioif].group_c;
 642                         break;
 643                 case group_d:
 644                         if_group_use = interfaces[ioif].group_d;
 645                         break;
 646                 case group_e:
 647                         if_group_use = interfaces[ioif].group_e;
 648                         break;
 649                 case group_f:
 650                         if_group_use = interfaces[ioif].group_f;
 651                         break;
 652                 default:
 653                         BUG_ON(1);
 654                 }
 655
 656                 if (if_group_use & grp->used) {
 657                         printk(KERN_INFO "cris_request_io_interface: group "
 658                                 "%s needed by %s not available\n",
 659                                 grp->name, interfaces[ioif].name);
 660                         res = -EBUSY;
 661                         goto exit;
 662                 }
 663
 664                 group_set = clear_group_from_set(group_set, grp);
 665         }
 666
 667         /* Are the required GPIO pins available too? */
 668         if (((interfaces[ioif].gpio_g_in & gpio_in_pins) !=
 669                         interfaces[ioif].gpio_g_in) ||
 670                 ((interfaces[ioif].gpio_g_out & gpio_out_pins) !=
 671                         interfaces[ioif].gpio_g_out) ||
 672                 ((interfaces[ioif].gpio_b & gpio_pb_pins) !=
 673                         interfaces[ioif].gpio_b)) {
 674                 printk(KERN_CRIT "cris_request_io_interface: Could not get "
 675                         "required pins for interface %u\n", ioif);
 676                 res = -EBUSY;
 677                 goto exit;
 678         }
 679
 680         /* Check which registers need to be reconfigured. */
 681         gens = genconfig_shadow;
 682         gens_ii = gen_config_ii_shadow;
 683
 684         set_gen_config = 1;
 685         switch (ioif)
 686         {
 687         /* Begin Non-multiplexed interfaces */
 688         case if_eth:
 689                 /* fall through */
 690         case if_serial_0:
 691                 set_gen_config = 0;
 692                 break;
 693         /* End Non-multiplexed interfaces */
 694         case if_serial_1:
 695                 set_gen_config_ii = 1;
 696                 SETS(gens_ii, R_GEN_CONFIG_II, sermode1, async);
 697                 break;
 698         case if_serial_2:
 699                 SETS(gens, R_GEN_CONFIG, ser2, select);
 700                 break;
 701         case if_serial_3:
 702                 SETS(gens, R_GEN_CONFIG, ser3, select);
 703                 set_gen_config_ii = 1;
 704                 SETS(gens_ii, R_GEN_CONFIG_II, sermode3, async);
 705                 break;
 706         case if_sync_serial_1:
 707                 set_gen_config_ii = 1;
 708                 SETS(gens_ii, R_GEN_CONFIG_II, sermode1, sync);
 709                 break;
 710         case if_sync_serial_3:
 711                 SETS(gens, R_GEN_CONFIG, ser3, select);
 712                 set_gen_config_ii = 1;
 713                 SETS(gens_ii, R_GEN_CONFIG_II, sermode3, sync);
 714                 break;
 715         case if_shared_ram:
 716                 SETS(gens, R_GEN_CONFIG, mio, select);
 717                 break;
 718         case if_shared_ram_w:
 719                 SETS(gens, R_GEN_CONFIG, mio_w, select);
 720                 break;
 721         case if_par_0:
 722                 SETS(gens, R_GEN_CONFIG, par0, select);
 723                 break;
 724         case if_par_1:
 725                 SETS(gens, R_GEN_CONFIG, par1, select);
 726                 break;
 727         case if_par_w:
 728                 SETS(gens, R_GEN_CONFIG, par0, select);
 729                 SETS(gens, R_GEN_CONFIG, par_w, select);
 730                 break;
 731         case if_scsi8_0:
 732                 SETS(gens, R_GEN_CONFIG, scsi0, select);
 733                 break;
 734         case if_scsi8_1:
 735                 SETS(gens, R_GEN_CONFIG, scsi1, select);
 736                 break;
 737         case if_scsi_w:
 738                 SETS(gens, R_GEN_CONFIG, scsi0, select);
 739                 SETS(gens, R_GEN_CONFIG, scsi0w, select);
 740                 break;
 741         case if_ata:
 742                 SETS(gens, R_GEN_CONFIG, ata, select);
 743                 break;
 744         case if_csp:
 745                 /* fall through */
 746         case if_i2c:
 747                 set_gen_config = 0;
 748                 break;
 749         case if_usb_1:
 750                 SETS(gens, R_GEN_CONFIG, usb1, select);
 751                 break;
 752         case if_usb_2:
 753                 SETS(gens, R_GEN_CONFIG, usb2, select);
 754                 break;
 755         case if_gpio_grp_a:
 756                 /* GPIO groups are only accounted, don't do configuration changes. */
 757                 /* fall through */
 758         case if_gpio_grp_b:
 759                 /* fall through */
 760         case if_gpio_grp_c:
 761                 /* fall through */
 762         case if_gpio_grp_d:
 763                 /* fall through */
 764         case if_gpio_grp_e:
 765                 /* fall through */
 766         case if_gpio_grp_f:
 767                 set_gen_config = 0;
 768                 break;
 769         default:
 770                 printk(KERN_INFO "cris_request_io_interface: Bad interface "
 771                         "%u submitted for %s\n",
 772                         ioif, device_id);
 773                 res = -EBUSY;
 774                 goto exit;
 775         }
 776
 777         /* All needed I/O pins and pin groups are free, allocate. */
 778         group_set = interfaces[ioif].groups;
 779         while (NULL != (grp = get_group(group_set))) {
 780                 unsigned int if_group_use = 0;
 781
 782                 switch (grp->group) {
 783                 case group_a:
 784                         if_group_use = interfaces[ioif].group_a;
 785                         break;
 786                 case group_b:
 787                         if_group_use = interfaces[ioif].group_b;
 788                         break;
 789                 case group_c:
 790                         if_group_use = interfaces[ioif].group_c;
 791                         break;
 792                 case group_d:
 793                         if_group_use = interfaces[ioif].group_d;
 794                         break;
 795                 case group_e:
 796                         if_group_use = interfaces[ioif].group_e;
 797                         break;
 798                 case group_f:
 799                         if_group_use = interfaces[ioif].group_f;
 800                         break;
 801                 default:
 802                         BUG_ON(1);
 803                 }
 804                 grp->used |= if_group_use;
 805
 806                 group_set = clear_group_from_set(group_set, grp);
 807         }
 808
 809         interfaces[ioif].used = 1;
 810         interfaces[ioif].owner = (char*)device_id;
 811
 812         if (set_gen_config) {
 813                 volatile int i;
 814                 genconfig_shadow = gens;
 815                 *R_GEN_CONFIG = genconfig_shadow;
 816                 /* Wait 12 cycles before doing any DMA command */
 817                 for(i = 6; i > 0; i--)
 818                         nop();
 819         }
 820         if (set_gen_config_ii) {
 821                 gen_config_ii_shadow = gens_ii;
 822                 *R_GEN_CONFIG_II = gen_config_ii_shadow;
 823         }
 824
 825         DBG(printk(KERN_DEBUG "GPIO pins: available before: "
 826                 "g_in=0x%08x g_out=0x%08x pb=0x%02x\n",
 827                 gpio_in_pins, gpio_out_pins, gpio_pb_pins));
 828         DBG(printk(KERN_DEBUG
 829                 "grabbing pins: g_in=0x%08x g_out=0x%08x pb=0x%02x\n",
 830                 interfaces[ioif].gpio_g_in,
 831                 interfaces[ioif].gpio_g_out,
 832                 interfaces[ioif].gpio_b));
 833
 834         gpio_in_pins &= ~interfaces[ioif].gpio_g_in;
 835         gpio_out_pins &= ~interfaces[ioif].gpio_g_out;
 836         gpio_pb_pins &= ~interfaces[ioif].gpio_b;
 837
 838         DBG(printk(KERN_DEBUG "GPIO pins: available after: "
 839                 "g_in=0x%08x g_out=0x%08x pb=0x%02x\n",
 840                 gpio_in_pins, gpio_out_pins, gpio_pb_pins));
 841
 842 exit:
 843         local_irq_restore(flags);
 844         if (res == 0)
 845                 notify_watchers();
 846         return res;
 847 }
 848
 849
 850 void cris_free_io_interface(enum cris_io_interface ioif)
 851 {
 852         struct if_group *grp;
 853         unsigned char group_set;
 854         unsigned long flags;
 855
 856         (void)cris_io_interface_init();
 857
 858         if ((ioif >= if_max_interfaces) || (ioif < 0)) {
 859                 printk(KERN_CRIT "cris_free_io_interface: Bad interface %u\n",
 860                        ioif);
 861                 return;
 862         }
 863         local_irq_save(flags);
 864         if (!interfaces[ioif].used) {
 865                 printk(KERN_CRIT "cris_free_io_interface: Freeing free interface %u\n",
 866                        ioif);
 867                 local_irq_restore(flags);
 868                 return;
 869         }
 870         group_set = interfaces[ioif].groups;
 871         while (NULL != (grp = get_group(group_set))) {
 872                 unsigned int if_group_use = 0;
 873
 874                 switch (grp->group) {
 875                 case group_a:
 876                         if_group_use = interfaces[ioif].group_a;
 877                         break;
 878                 case group_b:
 879                         if_group_use = interfaces[ioif].group_b;
 880                         break;
 881                 case group_c:
 882                         if_group_use = interfaces[ioif].group_c;
 883                         break;
 884                 case group_d:
 885                         if_group_use = interfaces[ioif].group_d;
 886                         break;
 887                 case group_e:
 888                         if_group_use = interfaces[ioif].group_e;
 889                         break;
 890                 case group_f:
 891                         if_group_use = interfaces[ioif].group_f;
 892                         break;
 893                 default:
 894                         BUG_ON(1);
 895                 }
 896
 897                 if ((grp->used & if_group_use) != if_group_use)
 898                         BUG_ON(1);
 899                 grp->used = grp->used & ~if_group_use;
 900
 901                 group_set = clear_group_from_set(group_set, grp);
 902         }
 903         interfaces[ioif].used = 0;
 904         interfaces[ioif].owner = NULL;
 905
 906         DBG(printk("GPIO pins: available before: g_in=0x%08x g_out=0x%08x pb=0x%02x\n",
 907                    gpio_in_pins, gpio_out_pins, gpio_pb_pins));
 908         DBG(printk("freeing pins: g_in=0x%08x g_out=0x%08x pb=0x%02x\n",
 909                    interfaces[ioif].gpio_g_in,
 910                    interfaces[ioif].gpio_g_out,
 911                    interfaces[ioif].gpio_b));
 912
 913         gpio_in_pins |= interfaces[ioif].gpio_g_in;
 914         gpio_out_pins |= interfaces[ioif].gpio_g_out;
 915         gpio_pb_pins |= interfaces[ioif].gpio_b;
 916
 917         DBG(printk("GPIO pins: available after: g_in=0x%08x g_out=0x%08x pb=0x%02x\n",
 918                    gpio_in_pins, gpio_out_pins, gpio_pb_pins));
 919
 920         local_irq_restore(flags);
 921
 922         notify_watchers();
 923 }
 924
 925 /* Create a bitmask from bit 0 (inclusive) to bit stop_bit
 926    (non-inclusive).  stop_bit == 0 returns 0x0 */
 927 static inline unsigned int create_mask(const unsigned stop_bit)
 928 {
 929         /* Avoid overflow */
 930         if (stop_bit >= 32) {
 931                 return 0xffffffff;
 932         }
 933         return (1<<stop_bit)-1;
 934 }
 935
 936
 937 /* port can be 'a', 'b' or 'g' */
 938 int cris_io_interface_allocate_pins(const enum cris_io_interface ioif,
 939                                     const char port,
 940                                     const unsigned start_bit,
 941                                     const unsigned stop_bit)
 942 {
 943         unsigned int i;
 944         unsigned int mask = 0;
 945         unsigned int tmp_mask;
 946         unsigned long int flags;
 947         enum cris_io_interface *owners;
 948
 949         (void)cris_io_interface_init();
 950
 951         DBG(printk("cris_io_interface_allocate_pins: if=%d port=%c start=%u stop=%u\n",
 952                    ioif, port, start_bit, stop_bit));
 953
 954         if (!((start_bit <= stop_bit) &&
 955               ((((port == 'a') || (port == 'b')) && (stop_bit < 8)) ||
 956                ((port == 'g') && (stop_bit < 32))))) {
 957                 return -EINVAL;
 958         }
 959
 960         mask = create_mask(stop_bit + 1);
 961         tmp_mask = create_mask(start_bit);
 962         mask &= ~tmp_mask;
 963
 964         DBG(printk("cris_io_interface_allocate_pins: port=%c start=%u stop=%u mask=0x%08x\n",
 965                    port, start_bit, stop_bit, mask));
 966
 967         local_irq_save(flags);
 968
 969         switch (port) {
 970         case 'a':
 971                 if ((gpio_pa_pins & mask) != mask) {
 972                         local_irq_restore(flags);
 973                         return -EBUSY;
 974                 }
 975                 owners = gpio_pa_owners;
 976                 gpio_pa_pins &= ~mask;
 977                 break;
 978         case 'b':
 979                 if ((gpio_pb_pins & mask) != mask) {
 980                         local_irq_restore(flags);
 981                         return -EBUSY;
 982                 }
 983                 owners = gpio_pb_owners;
 984                 gpio_pb_pins &= ~mask;
 985                 break;
 986         case 'g':
 987                 if (((gpio_in_pins & mask) != mask) ||
 988                     ((gpio_out_pins & mask) != mask)) {
 989                         local_irq_restore(flags);
 990                         return -EBUSY;
 991                 }
 992                 owners = gpio_pg_owners;
 993                 gpio_in_pins &= ~mask;
 994                 gpio_out_pins &= ~mask;
 995                 break;
 996         default:
 997                 local_irq_restore(flags);
 998                 return -EINVAL;
 999         }
1000
1001         for (i = start_bit; i <= stop_bit; i++) {
1002                 owners[i] = ioif;
1003         }
1004         local_irq_restore(flags);
1005
1006         notify_watchers();
1007         return 0;
1008 }
1009
1010
1011 /* port can be 'a', 'b' or 'g' */
1012 int cris_io_interface_free_pins(const enum cris_io_interface ioif,
1013                                 const char port,
1014                                 const unsigned start_bit,
1015                                 const unsigned stop_bit)
1016 {
1017         unsigned int i;
1018         unsigned int mask = 0;
1019         unsigned int tmp_mask;
1020         unsigned long int flags;
1021         enum cris_io_interface *owners;
1022
1023         (void)cris_io_interface_init();
1024
1025         if (!((start_bit <= stop_bit) &&
1026               ((((port == 'a') || (port == 'b')) && (stop_bit < 8)) ||
1027                ((port == 'g') && (stop_bit < 32))))) {
1028                 return -EINVAL;
1029         }
1030
1031         mask = create_mask(stop_bit + 1);
1032         tmp_mask = create_mask(start_bit);
1033         mask &= ~tmp_mask;
1034
1035         DBG(printk("cris_io_interface_free_pins: port=%c start=%u stop=%u mask=0x%08x\n",
1036                    port, start_bit, stop_bit, mask));
1037
1038         local_irq_save(flags);
1039
1040         switch (port) {
1041         case 'a':
1042                 if ((~gpio_pa_pins & mask) != mask) {
1043                         local_irq_restore(flags);
1044                         printk(KERN_CRIT "cris_io_interface_free_pins: Freeing free pins");
1045                 }
1046                 owners = gpio_pa_owners;
1047                 break;
1048         case 'b':
1049                 if ((~gpio_pb_pins & mask) != mask) {
1050                         local_irq_restore(flags);
1051                         printk(KERN_CRIT "cris_io_interface_free_pins: Freeing free pins");
1052                 }
1053                 owners = gpio_pb_owners;
1054                 break;
1055         case 'g':
1056                 if (((~gpio_in_pins & mask) != mask) ||
1057                     ((~gpio_out_pins & mask) != mask)) {
1058                         local_irq_restore(flags);
1059                         printk(KERN_CRIT "cris_io_interface_free_pins: Freeing free pins");
1060                 }
1061                 owners = gpio_pg_owners;
1062                 break;
1063         default:
1064                 owners = NULL; /* Cannot happen. Shut up, gcc! */
1065         }
1066
1067         for (i = start_bit; i <= stop_bit; i++) {
1068                 if (owners[i] != ioif) {
1069                         printk(KERN_CRIT "cris_io_interface_free_pins: Freeing unowned pins");
1070                 }
1071         }
1072
1073         /* All was ok, change data. */
1074         switch (port) {
1075         case 'a':
1076                 gpio_pa_pins |= mask;
1077                 break;
1078         case 'b':
1079                 gpio_pb_pins |= mask;
1080                 break;
1081         case 'g':
1082                 gpio_in_pins |= mask;
1083                 gpio_out_pins |= mask;
1084                 break;
1085         }
1086
1087         for (i = start_bit; i <= stop_bit; i++) {
1088                 owners[i] = if_unclaimed;
1089         }
1090         local_irq_restore(flags);
1091         notify_watchers();
1092
1093         return 0;
1094 }
1095
1096
1097 int cris_io_interface_register_watcher(void (*notify)(const unsigned int gpio_in_available,
1098                                                       const unsigned int gpio_out_available,
1099                                                       const unsigned char pa_available,
1100                                                       const unsigned char pb_available))
1101 {
1102         struct watcher *w;
1103
1104         (void)cris_io_interface_init();
1105
1106         if (NULL == notify) {
1107                 return -EINVAL;
1108         }
1109         w = kmalloc(sizeof(*w), GFP_KERNEL);
1110         if (!w) {
1111                 return -ENOMEM;
1112         }
1113         w->notify = notify;
1114         w->next = watchers;
1115         watchers = w;
1116
1117         w->notify((const unsigned int)gpio_in_pins,
1118                   (const unsigned int)gpio_out_pins,
1119                   (const unsigned char)gpio_pa_pins,
1120                   (const unsigned char)gpio_pb_pins);
1121
1122         return 0;
1123 }
1124
1125 void cris_io_interface_delete_watcher(void (*notify)(const unsigned int gpio_in_available,
1126                                                      const unsigned int gpio_out_available,
1127                                                      const unsigned char pa_available,
1128                                                      const unsigned char pb_available))
1129 {
1130         struct watcher *w = watchers, *prev = NULL;
1131
1132         (void)cris_io_interface_init();
1133
1134         while ((NULL != w) && (w->notify != notify)){
1135                 prev = w;
1136                 w = w->next;
1137         }
1138         if (NULL != w) {
1139                 if (NULL != prev) {
1140                         prev->next = w->next;
1141                 } else {
1142                         watchers = w->next;
1143                 }
1144                 kfree(w);
1145                 return;
1146         }
1147         printk(KERN_WARNING "cris_io_interface_delete_watcher: Deleting unknown watcher 0x%p\n", notify);
1148 }
1149
1150
1151 static int cris_io_interface_init(void)
1152 {
1153         static int first = 1;
1154         int i;
1155
1156         if (!first) {
1157                 return 0;
1158         }
1159         first = 0;
1160
1161         for (i = 0; i<8; i++) {
1162                 gpio_pa_owners[i] = if_unclaimed;
1163                 gpio_pb_owners[i] = if_unclaimed;
1164                 gpio_pg_owners[i] = if_unclaimed;
1165         }
1166         for (; i<32; i++) {
1167                 gpio_pg_owners[i] = if_unclaimed;
1168         }
1169         return 0;
1170 }
1171
1172
1173 module_init(cris_io_interface_init);
1174
1175
1176 EXPORT_SYMBOL(cris_request_io_interface);
1177 EXPORT_SYMBOL(cris_free_io_interface);
1178 EXPORT_SYMBOL(cris_io_interface_allocate_pins);
1179 EXPORT_SYMBOL(cris_io_interface_free_pins);
1180 EXPORT_SYMBOL(cris_io_interface_register_watcher);
1181 EXPORT_SYMBOL(cris_io_interface_delete_watcher);