drivers/pnp/isapnp/core.c

   1 /*
   2  *  ISA Plug & Play support
   3  *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
   4  *
   5  *
   6  *   This program is free software; you can redistribute it and/or modify
   7  *   it under the terms of the GNU General Public License as published by
   8  *   the Free Software Foundation; either version 2 of the License, or
   9  *   (at your option) any later version.
  10  *
  11  *   This program is distributed in the hope that it will be useful,
  12  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *   GNU General Public License for more details.
  15  *
  16  *   You should have received a copy of the GNU General Public License
  17  *   along with this program; if not, write to the Free Software
  18  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19  *
  20  *  Changelog:
  21  *  2000-01-01  Added quirks handling for buggy hardware
  22  *              Peter Denison <peterd@pnd-pc.demon.co.uk>
  23  *  2000-06-14  Added isapnp_probe_devs() and isapnp_activate_dev()
  24  *              Christoph Hellwig <hch@infradead.org>
  25  *  2001-06-03  Added release_region calls to correspond with
  26  *              request_region calls when a failure occurs.  Also
  27  *              added KERN_* constants to printk() calls.
  28  *  2001-11-07  Added isapnp_{,un}register_driver calls along the lines
  29  *              of the pci driver interface
  30  *              Kai Germaschewski <kai.germaschewski@gmx.de>
  31  *  2002-06-06  Made the use of dma channel 0 configurable
  32  *              Gerald Teschl <gerald.teschl@univie.ac.at>
  33  *  2002-10-06  Ported to PnP Layer - Adam Belay <ambx1@neo.rr.com>
  34  *  2003-08-11  Resource Management Updates - Adam Belay <ambx1@neo.rr.com>
  35  */
  36
  37 #include <linux/module.h>
  38 #include <linux/kernel.h>
  39 #include <linux/errno.h>
  40 #include <linux/slab.h>
  41 #include <linux/delay.h>
  42 #include <linux/init.h>
  43 #include <linux/isapnp.h>
  44 #include <linux/mutex.h>
  45 #include <asm/io.h>
  46
  47 #if 0
  48 #define ISAPNP_REGION_OK
  49 #endif
  50
  51 int isapnp_disable;             /* Disable ISA PnP */
  52 static int isapnp_rdp;          /* Read Data Port */
  53 static int isapnp_reset = 1;    /* reset all PnP cards (deactivate) */
  54 static int isapnp_verbose = 1;  /* verbose mode */
  55
  56 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
  57 MODULE_DESCRIPTION("Generic ISA Plug & Play support");
  58 module_param(isapnp_disable, int, 0);
  59 MODULE_PARM_DESC(isapnp_disable, "ISA Plug & Play disable");
  60 module_param(isapnp_rdp, int, 0);
  61 MODULE_PARM_DESC(isapnp_rdp, "ISA Plug & Play read data port");
  62 module_param(isapnp_reset, int, 0);
  63 MODULE_PARM_DESC(isapnp_reset, "ISA Plug & Play reset all cards");
  64 module_param(isapnp_verbose, int, 0);
  65 MODULE_PARM_DESC(isapnp_verbose, "ISA Plug & Play verbose mode");
  66 MODULE_LICENSE("GPL");
  67
  68 #define _PIDXR          0x279
  69 #define _PNPWRP         0xa79
  70
  71 /* short tags */
  72 #define _STAG_PNPVERNO          0x01
  73 #define _STAG_LOGDEVID          0x02
  74 #define _STAG_COMPATDEVID       0x03
  75 #define _STAG_IRQ               0x04
  76 #define _STAG_DMA               0x05
  77 #define _STAG_STARTDEP          0x06
  78 #define _STAG_ENDDEP            0x07
  79 #define _STAG_IOPORT            0x08
  80 #define _STAG_FIXEDIO           0x09
  81 #define _STAG_VENDOR            0x0e
  82 #define _STAG_END               0x0f
  83 /* long tags */
  84 #define _LTAG_MEMRANGE          0x81
  85 #define _LTAG_ANSISTR           0x82
  86 #define _LTAG_UNICODESTR        0x83
  87 #define _LTAG_VENDOR            0x84
  88 #define _LTAG_MEM32RANGE        0x85
  89 #define _LTAG_FIXEDMEM32RANGE   0x86
  90
  91 /*
  92  * Sizes of ISAPNP logical device configuration register sets.
  93  * See PNP-ISA-v1.0a.pdf, Appendix A.
  94  */
  95 #define ISAPNP_MAX_MEM          4
  96 #define ISAPNP_MAX_PORT         8
  97 #define ISAPNP_MAX_IRQ          2
  98 #define ISAPNP_MAX_DMA          2
  99
 100 static unsigned char isapnp_checksum_value;
 101 static DEFINE_MUTEX(isapnp_cfg_mutex);
 102 static int isapnp_csn_count;
 103
 104 /* some prototypes */
 105
 106 static inline void write_data(unsigned char x)
 107 {
 108         outb(x, _PNPWRP);
 109 }
 110
 111 static inline void write_address(unsigned char x)
 112 {
 113         outb(x, _PIDXR);
 114         udelay(20);
 115 }
 116
 117 static inline unsigned char read_data(void)
 118 {
 119         unsigned char val = inb(isapnp_rdp);
 120         return val;
 121 }
 122
 123 unsigned char isapnp_read_byte(unsigned char idx)
 124 {
 125         write_address(idx);
 126         return read_data();
 127 }
 128
 129 static unsigned short isapnp_read_word(unsigned char idx)
 130 {
 131         unsigned short val;
 132
 133         val = isapnp_read_byte(idx);
 134         val = (val << 8) + isapnp_read_byte(idx + 1);
 135         return val;
 136 }
 137
 138 void isapnp_write_byte(unsigned char idx, unsigned char val)
 139 {
 140         write_address(idx);
 141         write_data(val);
 142 }
 143
 144 static void isapnp_write_word(unsigned char idx, unsigned short val)
 145 {
 146         isapnp_write_byte(idx, val >> 8);
 147         isapnp_write_byte(idx + 1, val);
 148 }
 149
 150 static void isapnp_key(void)
 151 {
 152         unsigned char code = 0x6a, msb;
 153         int i;
 154
 155         mdelay(1);
 156         write_address(0x00);
 157         write_address(0x00);
 158
 159         write_address(code);
 160
 161         for (i = 1; i < 32; i++) {
 162                 msb = ((code & 0x01) ^ ((code & 0x02) >> 1)) << 7;
 163                 code = (code >> 1) | msb;
 164                 write_address(code);
 165         }
 166 }
 167
 168 /* place all pnp cards in wait-for-key state */
 169 static void isapnp_wait(void)
 170 {
 171         isapnp_write_byte(0x02, 0x02);
 172 }
 173
 174 static void isapnp_wake(unsigned char csn)
 175 {
 176         isapnp_write_byte(0x03, csn);
 177 }
 178
 179 static void isapnp_device(unsigned char logdev)
 180 {
 181         isapnp_write_byte(0x07, logdev);
 182 }
 183
 184 static void isapnp_activate(unsigned char logdev)
 185 {
 186         isapnp_device(logdev);
 187         isapnp_write_byte(ISAPNP_CFG_ACTIVATE, 1);
 188         udelay(250);
 189 }
 190
 191 static void isapnp_deactivate(unsigned char logdev)
 192 {
 193         isapnp_device(logdev);
 194         isapnp_write_byte(ISAPNP_CFG_ACTIVATE, 0);
 195         udelay(500);
 196 }
 197
 198 static void __init isapnp_peek(unsigned char *data, int bytes)
 199 {
 200         int i, j;
 201         unsigned char d = 0;
 202
 203         for (i = 1; i <= bytes; i++) {
 204                 for (j = 0; j < 20; j++) {
 205                         d = isapnp_read_byte(0x05);
 206                         if (d & 1)
 207                                 break;
 208                         udelay(100);
 209                 }
 210                 if (!(d & 1)) {
 211                         if (data != NULL)
 212                                 *data++ = 0xff;
 213                         continue;
 214                 }
 215                 d = isapnp_read_byte(0x04);     /* PRESDI */
 216                 isapnp_checksum_value += d;
 217                 if (data != NULL)
 218                         *data++ = d;
 219         }
 220 }
 221
 222 #define RDP_STEP        32      /* minimum is 4 */
 223
 224 static int isapnp_next_rdp(void)
 225 {
 226         int rdp = isapnp_rdp;
 227         static int old_rdp = 0;
 228
 229         if (old_rdp) {
 230                 release_region(old_rdp, 1);
 231                 old_rdp = 0;
 232         }
 233         while (rdp <= 0x3ff) {
 234                 /*
 235                  *      We cannot use NE2000 probe spaces for ISAPnP or we
 236                  *      will lock up machines.
 237                  */
 238                 if ((rdp < 0x280 || rdp > 0x380)
 239                     && request_region(rdp, 1, "ISAPnP")) {
 240                         isapnp_rdp = rdp;
 241                         old_rdp = rdp;
 242                         return 0;
 243                 }
 244                 rdp += RDP_STEP;
 245         }
 246         return -1;
 247 }
 248
 249 /* Set read port address */
 250 static inline void isapnp_set_rdp(void)
 251 {
 252         isapnp_write_byte(0x00, isapnp_rdp >> 2);
 253         udelay(100);
 254 }
 255
 256 /*
 257  *      Perform an isolation. The port selection code now tries to avoid
 258  *      "dangerous to read" ports.
 259  */
 260 static int __init isapnp_isolate_rdp_select(void)
 261 {
 262         isapnp_wait();
 263         isapnp_key();
 264
 265         /* Control: reset CSN and conditionally everything else too */
 266         isapnp_write_byte(0x02, isapnp_reset ? 0x05 : 0x04);
 267         mdelay(2);
 268
 269         isapnp_wait();
 270         isapnp_key();
 271         isapnp_wake(0x00);
 272
 273         if (isapnp_next_rdp() < 0) {
 274                 isapnp_wait();
 275                 return -1;
 276         }
 277
 278         isapnp_set_rdp();
 279         udelay(1000);
 280         write_address(0x01);
 281         udelay(1000);
 282         return 0;
 283 }
 284
 285 /*
 286  *  Isolate (assign uniqued CSN) to all ISA PnP devices.
 287  */
 288 static int __init isapnp_isolate(void)
 289 {
 290         unsigned char checksum = 0x6a;
 291         unsigned char chksum = 0x00;
 292         unsigned char bit = 0x00;
 293         int data;
 294         int csn = 0;
 295         int i;
 296         int iteration = 1;
 297
 298         isapnp_rdp = 0x213;
 299         if (isapnp_isolate_rdp_select() < 0)
 300                 return -1;
 301
 302         while (1) {
 303                 for (i = 1; i <= 64; i++) {
 304                         data = read_data() << 8;
 305                         udelay(250);
 306                         data = data | read_data();
 307                         udelay(250);
 308                         if (data == 0x55aa)
 309                                 bit = 0x01;
 310                         checksum =
 311                             ((((checksum ^ (checksum >> 1)) & 0x01) ^ bit) << 7)
 312                             | (checksum >> 1);
 313                         bit = 0x00;
 314                 }
 315                 for (i = 65; i <= 72; i++) {
 316                         data = read_data() << 8;
 317                         udelay(250);
 318                         data = data | read_data();
 319                         udelay(250);
 320                         if (data == 0x55aa)
 321                                 chksum |= (1 << (i - 65));
 322                 }
 323                 if (checksum != 0x00 && checksum == chksum) {
 324                         csn++;
 325
 326                         isapnp_write_byte(0x06, csn);
 327                         udelay(250);
 328                         iteration++;
 329                         isapnp_wake(0x00);
 330                         isapnp_set_rdp();
 331                         udelay(1000);
 332                         write_address(0x01);
 333                         udelay(1000);
 334                         goto __next;
 335                 }
 336                 if (iteration == 1) {
 337                         isapnp_rdp += RDP_STEP;
 338                         if (isapnp_isolate_rdp_select() < 0)
 339                                 return -1;
 340                 } else if (iteration > 1) {
 341                         break;
 342                 }
 343 __next:
 344                 if (csn == 255)
 345                         break;
 346                 checksum = 0x6a;
 347                 chksum = 0x00;
 348                 bit = 0x00;
 349         }
 350         isapnp_wait();
 351         isapnp_csn_count = csn;
 352         return csn;
 353 }
 354
 355 /*
 356  *  Read one tag from stream.
 357  */
 358 static int __init isapnp_read_tag(unsigned char *type, unsigned short *size)
 359 {
 360         unsigned char tag, tmp[2];
 361
 362         isapnp_peek(&tag, 1);
 363         if (tag == 0)           /* invalid tag */
 364                 return -1;
 365         if (tag & 0x80) {       /* large item */
 366                 *type = tag;
 367                 isapnp_peek(tmp, 2);
 368                 *size = (tmp[1] << 8) | tmp[0];
 369         } else {
 370                 *type = (tag >> 3) & 0x0f;
 371                 *size = tag & 0x07;
 372         }
 373 #if 0
 374         printk(KERN_DEBUG "tag = 0x%x, type = 0x%x, size = %i\n", tag, *type,
 375                *size);
 376 #endif
 377         if (*type == 0xff && *size == 0xffff)   /* probably invalid data */
 378                 return -1;
 379         return 0;
 380 }
 381
 382 /*
 383  *  Skip specified number of bytes from stream.
 384  */
 385 static void __init isapnp_skip_bytes(int count)
 386 {
 387         isapnp_peek(NULL, count);
 388 }
 389
 390 /*
 391  *  Parse EISA id.
 392  */
 393 static void isapnp_parse_id(struct pnp_dev *dev, unsigned short vendor,
 394                             unsigned short device)
 395 {
 396         struct pnp_id *id;
 397
 398         if (!dev)
 399                 return;
 400         id = kzalloc(sizeof(struct pnp_id), GFP_KERNEL);
 401         if (!id)
 402                 return;
 403         sprintf(id->id, "%c%c%c%x%x%x%x",
 404                 'A' + ((vendor >> 2) & 0x3f) - 1,
 405                 'A' + (((vendor & 3) << 3) | ((vendor >> 13) & 7)) - 1,
 406                 'A' + ((vendor >> 8) & 0x1f) - 1,
 407                 (device >> 4) & 0x0f,
 408                 device & 0x0f, (device >> 12) & 0x0f, (device >> 8) & 0x0f);
 409         pnp_add_id(id, dev);
 410 }
 411
 412 /*
 413  *  Parse logical device tag.
 414  */
 415 static struct pnp_dev *__init isapnp_parse_device(struct pnp_card *card,
 416                                                   int size, int number)
 417 {
 418         unsigned char tmp[6];
 419         struct pnp_dev *dev;
 420
 421         isapnp_peek(tmp, size);
 422         dev = kzalloc(sizeof(struct pnp_dev), GFP_KERNEL);
 423         if (!dev)
 424                 return NULL;
 425         dev->number = number;
 426         isapnp_parse_id(dev, (tmp[1] << 8) | tmp[0], (tmp[3] << 8) | tmp[2]);
 427         dev->regs = tmp[4];
 428         dev->card = card;
 429         if (size > 5)
 430                 dev->regs |= tmp[5] << 8;
 431         dev->protocol = &isapnp_protocol;
 432         dev->capabilities |= PNP_CONFIGURABLE;
 433         dev->capabilities |= PNP_READ;
 434         dev->capabilities |= PNP_WRITE;
 435         dev->capabilities |= PNP_DISABLE;
 436         pnp_init_resource_table(&dev->res);
 437         return dev;
 438 }
 439
 440 /*
 441  *  Add IRQ resource to resources list.
 442  */
 443 static void __init isapnp_parse_irq_resource(struct pnp_option *option,
 444                                              int size)
 445 {
 446         unsigned char tmp[3];
 447         struct pnp_irq *irq;
 448         unsigned long bits;
 449
 450         isapnp_peek(tmp, size);
 451         irq = kzalloc(sizeof(struct pnp_irq), GFP_KERNEL);
 452         if (!irq)
 453                 return;
 454         bits = (tmp[1] << 8) | tmp[0];
 455         bitmap_copy(irq->map, &bits, 16);
 456         if (size > 2)
 457                 irq->flags = tmp[2];
 458         else
 459                 irq->flags = IORESOURCE_IRQ_HIGHEDGE;
 460         pnp_register_irq_resource(option, irq);
 461 }
 462
 463 /*
 464  *  Add DMA resource to resources list.
 465  */
 466 static void __init isapnp_parse_dma_resource(struct pnp_option *option,
 467                                              int size)
 468 {
 469         unsigned char tmp[2];
 470         struct pnp_dma *dma;
 471
 472         isapnp_peek(tmp, size);
 473         dma = kzalloc(sizeof(struct pnp_dma), GFP_KERNEL);
 474         if (!dma)
 475                 return;
 476         dma->map = tmp[0];
 477         dma->flags = tmp[1];
 478         pnp_register_dma_resource(option, dma);
 479 }
 480
 481 /*
 482  *  Add port resource to resources list.
 483  */
 484 static void __init isapnp_parse_port_resource(struct pnp_option *option,
 485                                               int size)
 486 {
 487         unsigned char tmp[7];
 488         struct pnp_port *port;
 489
 490         isapnp_peek(tmp, size);
 491         port = kzalloc(sizeof(struct pnp_port), GFP_KERNEL);
 492         if (!port)
 493                 return;
 494         port->min = (tmp[2] << 8) | tmp[1];
 495         port->max = (tmp[4] << 8) | tmp[3];
 496         port->align = tmp[5];
 497         port->size = tmp[6];
 498         port->flags = tmp[0] ? PNP_PORT_FLAG_16BITADDR : 0;
 499         pnp_register_port_resource(option, port);
 500 }
 501
 502 /*
 503  *  Add fixed port resource to resources list.
 504  */
 505 static void __init isapnp_parse_fixed_port_resource(struct pnp_option *option,
 506                                                     int size)
 507 {
 508         unsigned char tmp[3];
 509         struct pnp_port *port;
 510
 511         isapnp_peek(tmp, size);
 512         port = kzalloc(sizeof(struct pnp_port), GFP_KERNEL);
 513         if (!port)
 514                 return;
 515         port->min = port->max = (tmp[1] << 8) | tmp[0];
 516         port->size = tmp[2];
 517         port->align = 0;
 518         port->flags = PNP_PORT_FLAG_FIXED;
 519         pnp_register_port_resource(option, port);
 520 }
 521
 522 /*
 523  *  Add memory resource to resources list.
 524  */
 525 static void __init isapnp_parse_mem_resource(struct pnp_option *option,
 526                                              int size)
 527 {
 528         unsigned char tmp[9];
 529         struct pnp_mem *mem;
 530
 531         isapnp_peek(tmp, size);
 532         mem = kzalloc(sizeof(struct pnp_mem), GFP_KERNEL);
 533         if (!mem)
 534                 return;
 535         mem->min = ((tmp[2] << 8) | tmp[1]) << 8;
 536         mem->max = ((tmp[4] << 8) | tmp[3]) << 8;
 537         mem->align = (tmp[6] << 8) | tmp[5];
 538         mem->size = ((tmp[8] << 8) | tmp[7]) << 8;
 539         mem->flags = tmp[0];
 540         pnp_register_mem_resource(option, mem);
 541 }
 542
 543 /*
 544  *  Add 32-bit memory resource to resources list.
 545  */
 546 static void __init isapnp_parse_mem32_resource(struct pnp_option *option,
 547                                                int size)
 548 {
 549         unsigned char tmp[17];
 550         struct pnp_mem *mem;
 551
 552         isapnp_peek(tmp, size);
 553         mem = kzalloc(sizeof(struct pnp_mem), GFP_KERNEL);
 554         if (!mem)
 555                 return;
 556         mem->min = (tmp[4] << 24) | (tmp[3] << 16) | (tmp[2] << 8) | tmp[1];
 557         mem->max = (tmp[8] << 24) | (tmp[7] << 16) | (tmp[6] << 8) | tmp[5];
 558         mem->align =
 559             (tmp[12] << 24) | (tmp[11] << 16) | (tmp[10] << 8) | tmp[9];
 560         mem->size =
 561             (tmp[16] << 24) | (tmp[15] << 16) | (tmp[14] << 8) | tmp[13];
 562         mem->flags = tmp[0];
 563         pnp_register_mem_resource(option, mem);
 564 }
 565
 566 /*
 567  *  Add 32-bit fixed memory resource to resources list.
 568  */
 569 static void __init isapnp_parse_fixed_mem32_resource(struct pnp_option *option,
 570                                                      int size)
 571 {
 572         unsigned char tmp[9];
 573         struct pnp_mem *mem;
 574
 575         isapnp_peek(tmp, size);
 576         mem = kzalloc(sizeof(struct pnp_mem), GFP_KERNEL);
 577         if (!mem)
 578                 return;
 579         mem->min = mem->max =
 580             (tmp[4] << 24) | (tmp[3] << 16) | (tmp[2] << 8) | tmp[1];
 581         mem->size = (tmp[8] << 24) | (tmp[7] << 16) | (tmp[6] << 8) | tmp[5];
 582         mem->align = 0;
 583         mem->flags = tmp[0];
 584         pnp_register_mem_resource(option, mem);
 585 }
 586
 587 /*
 588  *  Parse card name for ISA PnP device.
 589  */
 590 static void __init
 591 isapnp_parse_name(char *name, unsigned int name_max, unsigned short *size)
 592 {
 593         if (name[0] == '\0') {
 594                 unsigned short size1 =
 595                     *size >= name_max ? (name_max - 1) : *size;
 596                 isapnp_peek(name, size1);
 597                 name[size1] = '\0';
 598                 *size -= size1;
 599
 600                 /* clean whitespace from end of string */
 601                 while (size1 > 0 && name[--size1] == ' ')
 602                         name[size1] = '\0';
 603         }
 604 }
 605
 606 /*
 607  *  Parse resource map for logical device.
 608  */
 609 static int __init isapnp_create_device(struct pnp_card *card,
 610                                        unsigned short size)
 611 {
 612         int number = 0, skip = 0, priority = 0, compat = 0;
 613         unsigned char type, tmp[17];
 614         struct pnp_option *option;
 615         struct pnp_dev *dev;
 616
 617         if ((dev = isapnp_parse_device(card, size, number++)) == NULL)
 618                 return 1;
 619         option = pnp_register_independent_option(dev);
 620         if (!option) {
 621                 kfree(dev);
 622                 return 1;
 623         }
 624         pnp_add_card_device(card, dev);
 625
 626         while (1) {
 627                 if (isapnp_read_tag(&type, &size) < 0)
 628                         return 1;
 629                 if (skip && type != _STAG_LOGDEVID && type != _STAG_END)
 630                         goto __skip;
 631                 switch (type) {
 632                 case _STAG_LOGDEVID:
 633                         if (size >= 5 && size <= 6) {
 634                                 if ((dev =
 635                                      isapnp_parse_device(card, size,
 636                                                          number++)) == NULL)
 637                                         return 1;
 638                                 size = 0;
 639                                 skip = 0;
 640                                 option = pnp_register_independent_option(dev);
 641                                 if (!option) {
 642                                         kfree(dev);
 643                                         return 1;
 644                                 }
 645                                 pnp_add_card_device(card, dev);
 646                         } else {
 647                                 skip = 1;
 648                         }
 649                         priority = 0;
 650                         compat = 0;
 651                         break;
 652                 case _STAG_COMPATDEVID:
 653                         if (size == 4 && compat < DEVICE_COUNT_COMPATIBLE) {
 654                                 isapnp_peek(tmp, 4);
 655                                 isapnp_parse_id(dev, (tmp[1] << 8) | tmp[0],
 656                                                 (tmp[3] << 8) | tmp[2]);
 657                                 compat++;
 658                                 size = 0;
 659                         }
 660                         break;
 661                 case _STAG_IRQ:
 662                         if (size < 2 || size > 3)
 663                                 goto __skip;
 664                         isapnp_parse_irq_resource(option, size);
 665                         size = 0;
 666                         break;
 667                 case _STAG_DMA:
 668                         if (size != 2)
 669                                 goto __skip;
 670                         isapnp_parse_dma_resource(option, size);
 671                         size = 0;
 672                         break;
 673                 case _STAG_STARTDEP:
 674                         if (size > 1)
 675                                 goto __skip;
 676                         priority = 0x100 | PNP_RES_PRIORITY_ACCEPTABLE;
 677                         if (size > 0) {
 678                                 isapnp_peek(tmp, size);
 679                                 priority = 0x100 | tmp[0];
 680                                 size = 0;
 681                         }
 682                         option = pnp_register_dependent_option(dev, priority);
 683                         if (!option)
 684                                 return 1;
 685                         break;
 686                 case _STAG_ENDDEP:
 687                         if (size != 0)
 688                                 goto __skip;
 689                         priority = 0;
 690                         break;
 691                 case _STAG_IOPORT:
 692                         if (size != 7)
 693                                 goto __skip;
 694                         isapnp_parse_port_resource(option, size);
 695                         size = 0;
 696                         break;
 697                 case _STAG_FIXEDIO:
 698                         if (size != 3)
 699                                 goto __skip;
 700                         isapnp_parse_fixed_port_resource(option, size);
 701                         size = 0;
 702                         break;
 703                 case _STAG_VENDOR:
 704                         break;
 705                 case _LTAG_MEMRANGE:
 706                         if (size != 9)
 707                                 goto __skip;
 708                         isapnp_parse_mem_resource(option, size);
 709                         size = 0;
 710                         break;
 711                 case _LTAG_ANSISTR:
 712                         isapnp_parse_name(dev->name, sizeof(dev->name), &size);
 713                         break;
 714                 case _LTAG_UNICODESTR:
 715                         /* silently ignore */
 716                         /* who use unicode for hardware identification? */
 717                         break;
 718                 case _LTAG_VENDOR:
 719                         break;
 720                 case _LTAG_MEM32RANGE:
 721                         if (size != 17)
 722                                 goto __skip;
 723                         isapnp_parse_mem32_resource(option, size);
 724                         size = 0;
 725                         break;
 726                 case _LTAG_FIXEDMEM32RANGE:
 727                         if (size != 9)
 728                                 goto __skip;
 729                         isapnp_parse_fixed_mem32_resource(option, size);
 730                         size = 0;
 731                         break;
 732                 case _STAG_END:
 733                         if (size > 0)
 734                                 isapnp_skip_bytes(size);
 735                         return 1;
 736                 default:
 737                         printk(KERN_ERR
 738                                "isapnp: unexpected or unknown tag type 0x%x for logical device %i (device %i), ignored\n",
 739                                type, dev->number, card->number);
 740                 }
 741 __skip:
 742                 if (size > 0)
 743                         isapnp_skip_bytes(size);
 744         }
 745         return 0;
 746 }
 747
 748 /*
 749  *  Parse resource map for ISA PnP card.
 750  */
 751 static void __init isapnp_parse_resource_map(struct pnp_card *card)
 752 {
 753         unsigned char type, tmp[17];
 754         unsigned short size;
 755
 756         while (1) {
 757                 if (isapnp_read_tag(&type, &size) < 0)
 758                         return;
 759                 switch (type) {
 760                 case _STAG_PNPVERNO:
 761                         if (size != 2)
 762                                 goto __skip;
 763                         isapnp_peek(tmp, 2);
 764                         card->pnpver = tmp[0];
 765                         card->productver = tmp[1];
 766                         size = 0;
 767                         break;
 768                 case _STAG_LOGDEVID:
 769                         if (size >= 5 && size <= 6) {
 770                                 if (isapnp_create_device(card, size) == 1)
 771                                         return;
 772                                 size = 0;
 773                         }
 774                         break;
 775                 case _STAG_VENDOR:
 776                         break;
 777                 case _LTAG_ANSISTR:
 778                         isapnp_parse_name(card->name, sizeof(card->name),
 779                                           &size);
 780                         break;
 781                 case _LTAG_UNICODESTR:
 782                         /* silently ignore */
 783                         /* who use unicode for hardware identification? */
 784                         break;
 785                 case _LTAG_VENDOR:
 786                         break;
 787                 case _STAG_END:
 788                         if (size > 0)
 789                                 isapnp_skip_bytes(size);
 790                         return;
 791                 default:
 792                         printk(KERN_ERR
 793                                "isapnp: unexpected or unknown tag type 0x%x for device %i, ignored\n",
 794                                type, card->number);
 795                 }
 796 __skip:
 797                 if (size > 0)
 798                         isapnp_skip_bytes(size);
 799         }
 800 }
 801
 802 /*
 803  *  Compute ISA PnP checksum for first eight bytes.
 804  */
 805 static unsigned char __init isapnp_checksum(unsigned char *data)
 806 {
 807         int i, j;
 808         unsigned char checksum = 0x6a, bit, b;
 809
 810         for (i = 0; i < 8; i++) {
 811                 b = data[i];
 812                 for (j = 0; j < 8; j++) {
 813                         bit = 0;
 814                         if (b & (1 << j))
 815                                 bit = 1;
 816                         checksum =
 817                             ((((checksum ^ (checksum >> 1)) & 0x01) ^ bit) << 7)
 818                             | (checksum >> 1);
 819                 }
 820         }
 821         return checksum;
 822 }
 823
 824 /*
 825  *  Parse EISA id for ISA PnP card.
 826  */
 827 static void isapnp_parse_card_id(struct pnp_card *card, unsigned short vendor,
 828                                  unsigned short device)
 829 {
 830         struct pnp_id *id = kzalloc(sizeof(struct pnp_id), GFP_KERNEL);
 831
 832         if (!id)
 833                 return;
 834         sprintf(id->id, "%c%c%c%x%x%x%x",
 835                 'A' + ((vendor >> 2) & 0x3f) - 1,
 836                 'A' + (((vendor & 3) << 3) | ((vendor >> 13) & 7)) - 1,
 837                 'A' + ((vendor >> 8) & 0x1f) - 1,
 838                 (device >> 4) & 0x0f,
 839                 device & 0x0f, (device >> 12) & 0x0f, (device >> 8) & 0x0f);
 840         pnp_add_card_id(id, card);
 841 }
 842
 843 /*
 844  *  Build device list for all present ISA PnP devices.
 845  */
 846 static int __init isapnp_build_device_list(void)
 847 {
 848         int csn;
 849         unsigned char header[9], checksum;
 850         struct pnp_card *card;
 851
 852         isapnp_wait();
 853         isapnp_key();
 854         for (csn = 1; csn <= isapnp_csn_count; csn++) {
 855                 isapnp_wake(csn);
 856                 isapnp_peek(header, 9);
 857                 checksum = isapnp_checksum(header);
 858 #if 0
 859                 printk(KERN_DEBUG
 860                        "vendor: %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
 861                        header[0], header[1], header[2], header[3], header[4],
 862                        header[5], header[6], header[7], header[8]);
 863                 printk(KERN_DEBUG "checksum = 0x%x\n", checksum);
 864 #endif
 865                 if ((card =
 866                      kzalloc(sizeof(struct pnp_card), GFP_KERNEL)) == NULL)
 867                         continue;
 868
 869                 card->number = csn;
 870                 INIT_LIST_HEAD(&card->devices);
 871                 isapnp_parse_card_id(card, (header[1] << 8) | header[0],
 872                                      (header[3] << 8) | header[2]);
 873                 card->serial =
 874                     (header[7] << 24) | (header[6] << 16) | (header[5] << 8) |
 875                     header[4];
 876                 isapnp_checksum_value = 0x00;
 877                 isapnp_parse_resource_map(card);
 878                 if (isapnp_checksum_value != 0x00)
 879                         printk(KERN_ERR
 880                                "isapnp: checksum for device %i is not valid (0x%x)\n",
 881                                csn, isapnp_checksum_value);
 882                 card->checksum = isapnp_checksum_value;
 883                 card->protocol = &isapnp_protocol;
 884
 885                 pnp_add_card(card);
 886         }
 887         isapnp_wait();
 888         return 0;
 889 }
 890
 891 /*
 892  *  Basic configuration routines.
 893  */
 894
 895 int isapnp_present(void)
 896 {
 897         struct pnp_card *card;
 898
 899         pnp_for_each_card(card) {
 900                 if (card->protocol == &isapnp_protocol)
 901                         return 1;
 902         }
 903         return 0;
 904 }
 905
 906 int isapnp_cfg_begin(int csn, int logdev)
 907 {
 908         if (csn < 1 || csn > isapnp_csn_count || logdev > 10)
 909                 return -EINVAL;
 910         mutex_lock(&isapnp_cfg_mutex);
 911         isapnp_wait();
 912         isapnp_key();
 913         isapnp_wake(csn);
 914 #if 0
 915         /* to avoid malfunction when the isapnptools package is used */
 916         /* we must set RDP to our value again */
 917         /* it is possible to set RDP only in the isolation phase */
 918         /*   Jens Thoms Toerring <Jens.Toerring@physik.fu-berlin.de> */
 919         isapnp_write_byte(0x02, 0x04);  /* clear CSN of card */
 920         mdelay(2);              /* is this necessary? */
 921         isapnp_wake(csn);       /* bring card into sleep state */
 922         isapnp_wake(0);         /* bring card into isolation state */
 923         isapnp_set_rdp();       /* reset the RDP port */
 924         udelay(1000);           /* delay 1000us */
 925         isapnp_write_byte(0x06, csn);   /* reset CSN to previous value */
 926         udelay(250);            /* is this necessary? */
 927 #endif
 928         if (logdev >= 0)
 929                 isapnp_device(logdev);
 930         return 0;
 931 }
 932
 933 int isapnp_cfg_end(void)
 934 {
 935         isapnp_wait();
 936         mutex_unlock(&isapnp_cfg_mutex);
 937         return 0;
 938 }
 939
 940 /*
 941  *  Initialization.
 942  */
 943
 944 EXPORT_SYMBOL(isapnp_protocol);
 945 EXPORT_SYMBOL(isapnp_present);
 946 EXPORT_SYMBOL(isapnp_cfg_begin);
 947 EXPORT_SYMBOL(isapnp_cfg_end);
 948 EXPORT_SYMBOL(isapnp_write_byte);
 949
 950 static int isapnp_read_resources(struct pnp_dev *dev,
 951                                  struct pnp_resource_table *res)
 952 {
 953         int tmp, ret;
 954
 955         dev->active = isapnp_read_byte(ISAPNP_CFG_ACTIVATE);
 956         if (dev->active) {
 957                 for (tmp = 0; tmp < ISAPNP_MAX_PORT; tmp++) {
 958                         ret = isapnp_read_word(ISAPNP_CFG_PORT + (tmp << 1));
 959                         if (!ret)
 960                                 continue;
 961                         res->port_resource[tmp].start = ret;
 962                         res->port_resource[tmp].flags = IORESOURCE_IO;
 963                 }
 964                 for (tmp = 0; tmp < ISAPNP_MAX_MEM; tmp++) {
 965                         ret =
 966                             isapnp_read_word(ISAPNP_CFG_MEM + (tmp << 3)) << 8;
 967                         if (!ret)
 968                                 continue;
 969                         res->mem_resource[tmp].start = ret;
 970                         res->mem_resource[tmp].flags = IORESOURCE_MEM;
 971                 }
 972                 for (tmp = 0; tmp < ISAPNP_MAX_IRQ; tmp++) {
 973                         ret =
 974                             (isapnp_read_word(ISAPNP_CFG_IRQ + (tmp << 1)) >>
 975                              8);
 976                         if (!ret)
 977                                 continue;
 978                         res->irq_resource[tmp].start =
 979                             res->irq_resource[tmp].end = ret;
 980                         res->irq_resource[tmp].flags = IORESOURCE_IRQ;
 981                 }
 982                 for (tmp = 0; tmp < ISAPNP_MAX_DMA; tmp++) {
 983                         ret = isapnp_read_byte(ISAPNP_CFG_DMA + tmp);
 984                         if (ret == 4)
 985                                 continue;
 986                         res->dma_resource[tmp].start =
 987                             res->dma_resource[tmp].end = ret;
 988                         res->dma_resource[tmp].flags = IORESOURCE_DMA;
 989                 }
 990         }
 991         return 0;
 992 }
 993
 994 static int isapnp_get_resources(struct pnp_dev *dev,
 995                                 struct pnp_resource_table *res)
 996 {
 997         int ret;
 998
 999         pnp_init_resource_table(res);
1000         isapnp_cfg_begin(dev->card->number, dev->number);
1001         ret = isapnp_read_resources(dev, res);
1002         isapnp_cfg_end();
1003         return ret;
1004 }
1005
1006 static int isapnp_set_resources(struct pnp_dev *dev,
1007                                 struct pnp_resource_table *res)
1008 {
1009         int tmp;
1010
1011         isapnp_cfg_begin(dev->card->number, dev->number);
1012         dev->active = 1;
1013         for (tmp = 0;
1014              tmp < ISAPNP_MAX_PORT
1015              && (res->port_resource[tmp].
1016                  flags & (IORESOURCE_IO | IORESOURCE_UNSET)) == IORESOURCE_IO;
1017              tmp++)
1018                 isapnp_write_word(ISAPNP_CFG_PORT + (tmp << 1),
1019                                   res->port_resource[tmp].start);
1020         for (tmp = 0;
1021              tmp < ISAPNP_MAX_IRQ
1022              && (res->irq_resource[tmp].
1023                  flags & (IORESOURCE_IRQ | IORESOURCE_UNSET)) == IORESOURCE_IRQ;
1024              tmp++) {
1025                 int irq = res->irq_resource[tmp].start;
1026                 if (irq == 2)
1027                         irq = 9;
1028                 isapnp_write_byte(ISAPNP_CFG_IRQ + (tmp << 1), irq);
1029         }
1030         for (tmp = 0;
1031              tmp < ISAPNP_MAX_DMA
1032              && (res->dma_resource[tmp].
1033                  flags & (IORESOURCE_DMA | IORESOURCE_UNSET)) == IORESOURCE_DMA;
1034              tmp++)
1035                 isapnp_write_byte(ISAPNP_CFG_DMA + tmp,
1036                                   res->dma_resource[tmp].start);
1037         for (tmp = 0;
1038              tmp < ISAPNP_MAX_MEM
1039              && (res->mem_resource[tmp].
1040                  flags & (IORESOURCE_MEM | IORESOURCE_UNSET)) == IORESOURCE_MEM;
1041              tmp++)
1042                 isapnp_write_word(ISAPNP_CFG_MEM + (tmp << 3),
1043                                   (res->mem_resource[tmp].start >> 8) & 0xffff);
1044         /* FIXME: We aren't handling 32bit mems properly here */
1045         isapnp_activate(dev->number);
1046         isapnp_cfg_end();
1047         return 0;
1048 }
1049
1050 static int isapnp_disable_resources(struct pnp_dev *dev)
1051 {
1052         if (!dev->active)
1053                 return -EINVAL;
1054         isapnp_cfg_begin(dev->card->number, dev->number);
1055         isapnp_deactivate(dev->number);
1056         dev->active = 0;
1057         isapnp_cfg_end();
1058         return 0;
1059 }
1060
1061 struct pnp_protocol isapnp_protocol = {
1062         .name = "ISA Plug and Play",
1063         .get = isapnp_get_resources,
1064         .set = isapnp_set_resources,
1065         .disable = isapnp_disable_resources,
1066 };
1067
1068 static int __init isapnp_init(void)
1069 {
1070         int cards;
1071         struct pnp_card *card;
1072         struct pnp_dev *dev;
1073
1074         if (isapnp_disable) {
1075                 printk(KERN_INFO "isapnp: ISA Plug & Play support disabled\n");
1076                 return 0;
1077         }
1078 #ifdef CONFIG_PPC_MERGE
1079         if (check_legacy_ioport(_PIDXR) || check_legacy_ioport(_PNPWRP))
1080                 return -EINVAL;
1081 #endif
1082 #ifdef ISAPNP_REGION_OK
1083         if (!request_region(_PIDXR, 1, "isapnp index")) {
1084                 printk(KERN_ERR "isapnp: Index Register 0x%x already used\n",
1085                        _PIDXR);
1086                 return -EBUSY;
1087         }
1088 #endif
1089         if (!request_region(_PNPWRP, 1, "isapnp write")) {
1090                 printk(KERN_ERR
1091                        "isapnp: Write Data Register 0x%x already used\n",
1092                        _PNPWRP);
1093 #ifdef ISAPNP_REGION_OK
1094                 release_region(_PIDXR, 1);
1095 #endif
1096                 return -EBUSY;
1097         }
1098
1099         if (pnp_register_protocol(&isapnp_protocol) < 0)
1100                 return -EBUSY;
1101
1102         /*
1103          *      Print a message. The existing ISAPnP code is hanging machines
1104          *      so let the user know where.
1105          */
1106
1107         printk(KERN_INFO "isapnp: Scanning for PnP cards...\n");
1108         if (isapnp_rdp >= 0x203 && isapnp_rdp <= 0x3ff) {
1109                 isapnp_rdp |= 3;
1110                 if (!request_region(isapnp_rdp, 1, "isapnp read")) {
1111                         printk(KERN_ERR
1112                                "isapnp: Read Data Register 0x%x already used\n",
1113                                isapnp_rdp);
1114 #ifdef ISAPNP_REGION_OK
1115                         release_region(_PIDXR, 1);
1116 #endif
1117                         release_region(_PNPWRP, 1);
1118                         return -EBUSY;
1119                 }
1120                 isapnp_set_rdp();
1121         }
1122         if (isapnp_rdp < 0x203 || isapnp_rdp > 0x3ff) {
1123                 cards = isapnp_isolate();
1124                 if (cards < 0 || (isapnp_rdp < 0x203 || isapnp_rdp > 0x3ff)) {
1125 #ifdef ISAPNP_REGION_OK
1126                         release_region(_PIDXR, 1);
1127 #endif
1128                         release_region(_PNPWRP, 1);
1129                         printk(KERN_INFO
1130                                "isapnp: No Plug & Play device found\n");
1131                         return 0;
1132                 }
1133                 request_region(isapnp_rdp, 1, "isapnp read");
1134         }
1135         isapnp_build_device_list();
1136         cards = 0;
1137
1138         protocol_for_each_card(&isapnp_protocol, card) {
1139                 cards++;
1140                 if (isapnp_verbose) {
1141                         printk(KERN_INFO "isapnp: Card '%s'\n",
1142                                card->name[0] ? card->name : "Unknown");
1143                         if (isapnp_verbose < 2)
1144                                 continue;
1145                         card_for_each_dev(card, dev) {
1146                                 printk(KERN_INFO "isapnp:   Device '%s'\n",
1147                                        dev->name[0] ? dev->name : "Unknown");
1148                         }
1149                 }
1150         }
1151         if (cards)
1152                 printk(KERN_INFO
1153                        "isapnp: %i Plug & Play card%s detected total\n", cards,
1154                        cards > 1 ? "s" : "");
1155         else
1156                 printk(KERN_INFO "isapnp: No Plug & Play card found\n");
1157
1158         isapnp_proc_init();
1159         return 0;
1160 }
1161
1162 device_initcall(isapnp_init);
1163
1164 /* format is: noisapnp */
1165
1166 static int __init isapnp_setup_disable(char *str)
1167 {
1168         isapnp_disable = 1;
1169         return 1;
1170 }
1171
1172 __setup("noisapnp", isapnp_setup_disable);
1173
1174 /* format is: isapnp=rdp,reset,skip_pci_scan,verbose */
1175
1176 static int __init isapnp_setup_isapnp(char *str)
1177 {
1178         (void)((get_option(&str, &isapnp_rdp) == 2) &&
1179                (get_option(&str, &isapnp_reset) == 2) &&
1180                (get_option(&str, &isapnp_verbose) == 2));
1181         return 1;
1182 }
1183
1184 __setup("isapnp=", isapnp_setup_isapnp);