drivers/pnp/isapnp/core.c

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