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