1 /*- 2 * Copyright (c) 1999 Doug Rabson 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 */ 26 /* 27 * Modifications for Intel architecture by Garrett A. Wollman. 28 * Copyright 1998 Massachusetts Institute of Technology 29 * 30 * Permission to use, copy, modify, and distribute this software and 31 * its documentation for any purpose and without fee is hereby 32 * granted, provided that both the above copyright notice and this 33 * permission notice appear in all copies, that both the above 34 * copyright notice and this permission notice appear in all 35 * supporting documentation, and that the name of M.I.T. not be used 36 * in advertising or publicity pertaining to distribution of the 37 * software without specific, written prior permission. M.I.T. makes 38 * no representations about the suitability of this software for any 39 * purpose. It is provided "as is" without express or implied 40 * warranty. 41 * 42 * THIS SOFTWARE IS PROVIDED BY M.I.T. ``AS IS''. M.I.T. DISCLAIMS 43 * ALL EXPRESS OR IMPLIED WARRANTIES WITH REGARD TO THIS SOFTWARE, 44 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 45 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT 46 * SHALL M.I.T. BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 47 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 48 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF 49 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 50 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 51 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 52 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 53 * SUCH DAMAGE. 54 */ 55 56 /* 57 * Parts of the ISA bus implementation common to all architectures. 58 */ 59 60 #include <sys/cdefs.h> 61 __FBSDID("$FreeBSD$"); 62 63 #include "opt_isa.h" 64 65 #include <sys/param.h> 66 #include <sys/systm.h> 67 #include <sys/kernel.h> 68 #include <sys/bus.h> 69 #include <sys/malloc.h> 70 #include <sys/module.h> 71 #include <machine/bus.h> 72 #include <sys/rman.h> 73 74 #include <machine/resource.h> 75 76 #include <isa/isavar.h> 77 #include <isa/isa_common.h> 78 79 static int isa_print_child(device_t bus, device_t dev); 80 81 static MALLOC_DEFINE(M_ISADEV, "isadev", "ISA device"); 82 83 static int isa_running; 84 85 /* 86 * At 'probe' time, we add all the devices which we know about to the 87 * bus. The generic attach routine will probe and attach them if they 88 * are alive. 89 */ 90 static int 91 isa_probe(device_t dev) 92 { 93 device_set_desc(dev, "ISA bus"); 94 isa_init(dev); /* Allow machdep code to initialise */ 95 return (0); 96 } 97 98 extern device_t isa_bus_device; 99 100 static int 101 isa_attach(device_t dev) 102 { 103 /* 104 * Arrange for isa_probe_children(dev) to be called later. XXX 105 */ 106 isa_bus_device = dev; 107 return (0); 108 } 109 110 /* 111 * Find a working set of memory regions for a child using the ranges 112 * in *config and return the regions in *result. Returns non-zero if 113 * a set of ranges was found. 114 */ 115 static int 116 isa_find_memory(device_t child, struct isa_config *config, 117 struct isa_config *result) 118 { 119 int success, i; 120 struct resource *res[ISA_NMEM]; 121 122 /* 123 * First clear out any existing resource definitions. 124 */ 125 for (i = 0; i < ISA_NMEM; i++) { 126 bus_delete_resource(child, SYS_RES_MEMORY, i); 127 res[i] = NULL; 128 } 129 130 success = 1; 131 result->ic_nmem = config->ic_nmem; 132 for (i = 0; i < config->ic_nmem; i++) { 133 uint32_t start, end, size, align; 134 135 size = config->ic_mem[i].ir_size; 136 137 /* the PnP device may have a null resource as filler */ 138 if (size == 0) { 139 result->ic_mem[i].ir_start = 0; 140 result->ic_mem[i].ir_end = 0; 141 result->ic_mem[i].ir_size = 0; 142 result->ic_mem[i].ir_align = 0; 143 continue; 144 } 145 146 for (start = config->ic_mem[i].ir_start, 147 end = config->ic_mem[i].ir_end, 148 align = config->ic_mem[i].ir_align; 149 start + size - 1 <= end && start + size > start; 150 start += MAX(align, 1)) { 151 bus_set_resource(child, SYS_RES_MEMORY, i, 152 start, size); 153 res[i] = bus_alloc_resource(child, 154 SYS_RES_MEMORY, &i, 0, ~0, 1, 155 rman_make_alignment_flags(align) /* !RF_ACTIVE */); 156 if (res[i]) { 157 result->ic_mem[i].ir_start = start; 158 result->ic_mem[i].ir_end = start + size - 1; 159 result->ic_mem[i].ir_size = size; 160 result->ic_mem[i].ir_align = align; 161 break; 162 } 163 } 164 165 /* 166 * If we didn't find a place for memory range i, then 167 * give up now. 168 */ 169 if (!res[i]) { 170 success = 0; 171 break; 172 } 173 } 174 175 for (i = 0; i < ISA_NMEM; i++) { 176 if (res[i]) 177 bus_release_resource(child, SYS_RES_MEMORY, 178 i, res[i]); 179 } 180 181 return (success); 182 } 183 184 /* 185 * Find a working set of port regions for a child using the ranges 186 * in *config and return the regions in *result. Returns non-zero if 187 * a set of ranges was found. 188 */ 189 static int 190 isa_find_port(device_t child, struct isa_config *config, 191 struct isa_config *result) 192 { 193 int success, i; 194 struct resource *res[ISA_NPORT]; 195 196 /* 197 * First clear out any existing resource definitions. 198 */ 199 for (i = 0; i < ISA_NPORT; i++) { 200 bus_delete_resource(child, SYS_RES_IOPORT, i); 201 res[i] = NULL; 202 } 203 204 success = 1; 205 result->ic_nport = config->ic_nport; 206 for (i = 0; i < config->ic_nport; i++) { 207 uint32_t start, end, size, align; 208 209 size = config->ic_port[i].ir_size; 210 211 /* the PnP device may have a null resource as filler */ 212 if (size == 0) { 213 result->ic_port[i].ir_start = 0; 214 result->ic_port[i].ir_end = 0; 215 result->ic_port[i].ir_size = 0; 216 result->ic_port[i].ir_align = 0; 217 continue; 218 } 219 220 for (start = config->ic_port[i].ir_start, 221 end = config->ic_port[i].ir_end, 222 align = config->ic_port[i].ir_align; 223 start + size - 1 <= end; 224 start += align) { 225 bus_set_resource(child, SYS_RES_IOPORT, i, 226 start, size); 227 res[i] = bus_alloc_resource(child, 228 SYS_RES_IOPORT, &i, 0, ~0, 1, 229 rman_make_alignment_flags(align) /* !RF_ACTIVE */); 230 if (res[i]) { 231 result->ic_port[i].ir_start = start; 232 result->ic_port[i].ir_end = start + size - 1; 233 result->ic_port[i].ir_size = size; 234 result->ic_port[i].ir_align = align; 235 break; 236 } 237 } 238 239 /* 240 * If we didn't find a place for port range i, then 241 * give up now. 242 */ 243 if (!res[i]) { 244 success = 0; 245 break; 246 } 247 } 248 249 for (i = 0; i < ISA_NPORT; i++) { 250 if (res[i]) 251 bus_release_resource(child, SYS_RES_IOPORT, 252 i, res[i]); 253 } 254 255 return success; 256 } 257 258 /* 259 * Return the index of the first bit in the mask (or -1 if mask is empty. 260 */ 261 static int 262 find_first_bit(uint32_t mask) 263 { 264 return (ffs(mask) - 1); 265 } 266 267 /* 268 * Return the index of the next bit in the mask, or -1 if there are no more. 269 */ 270 static int 271 find_next_bit(uint32_t mask, int bit) 272 { 273 bit++; 274 while (bit < 32 && !(mask & (1 << bit))) 275 bit++; 276 if (bit != 32) 277 return (bit); 278 return (-1); 279 } 280 281 /* 282 * Find a working set of irqs for a child using the masks in *config 283 * and return the regions in *result. Returns non-zero if a set of 284 * irqs was found. 285 */ 286 static int 287 isa_find_irq(device_t child, struct isa_config *config, 288 struct isa_config *result) 289 { 290 int success, i; 291 struct resource *res[ISA_NIRQ]; 292 293 /* 294 * First clear out any existing resource definitions. 295 */ 296 for (i = 0; i < ISA_NIRQ; i++) { 297 bus_delete_resource(child, SYS_RES_IRQ, i); 298 res[i] = NULL; 299 } 300 301 success = 1; 302 result->ic_nirq = config->ic_nirq; 303 for (i = 0; i < config->ic_nirq; i++) { 304 uint32_t mask = config->ic_irqmask[i]; 305 int irq; 306 307 /* the PnP device may have a null resource as filler */ 308 if (mask == 0) { 309 result->ic_irqmask[i] = 0; 310 continue; 311 } 312 313 for (irq = find_first_bit(mask); 314 irq != -1; 315 irq = find_next_bit(mask, irq)) { 316 bus_set_resource(child, SYS_RES_IRQ, i, 317 irq, 1); 318 res[i] = bus_alloc_resource_any(child, 319 SYS_RES_IRQ, &i, 320 0 /* !RF_ACTIVE */ ); 321 if (res[i]) { 322 result->ic_irqmask[i] = (1 << irq); 323 break; 324 } 325 } 326 327 /* 328 * If we didn't find a place for irq range i, then 329 * give up now. 330 */ 331 if (!res[i]) { 332 success = 0; 333 break; 334 } 335 } 336 337 for (i = 0; i < ISA_NIRQ; i++) { 338 if (res[i]) 339 bus_release_resource(child, SYS_RES_IRQ, 340 i, res[i]); 341 } 342 343 return (success); 344 } 345 346 /* 347 * Find a working set of drqs for a child using the masks in *config 348 * and return the regions in *result. Returns non-zero if a set of 349 * drqs was found. 350 */ 351 static int 352 isa_find_drq(device_t child, struct isa_config *config, 353 struct isa_config *result) 354 { 355 int success, i; 356 struct resource *res[ISA_NDRQ]; 357 358 /* 359 * First clear out any existing resource definitions. 360 */ 361 for (i = 0; i < ISA_NDRQ; i++) { 362 bus_delete_resource(child, SYS_RES_DRQ, i); 363 res[i] = NULL; 364 } 365 366 success = 1; 367 result->ic_ndrq = config->ic_ndrq; 368 for (i = 0; i < config->ic_ndrq; i++) { 369 uint32_t mask = config->ic_drqmask[i]; 370 int drq; 371 372 /* the PnP device may have a null resource as filler */ 373 if (mask == 0) { 374 result->ic_drqmask[i] = 0; 375 continue; 376 } 377 378 for (drq = find_first_bit(mask); 379 drq != -1; 380 drq = find_next_bit(mask, drq)) { 381 bus_set_resource(child, SYS_RES_DRQ, i, 382 drq, 1); 383 res[i] = bus_alloc_resource_any(child, 384 SYS_RES_DRQ, &i, 385 0 /* !RF_ACTIVE */); 386 if (res[i]) { 387 result->ic_drqmask[i] = (1 << drq); 388 break; 389 } 390 } 391 392 /* 393 * If we didn't find a place for drq range i, then 394 * give up now. 395 */ 396 if (!res[i]) { 397 success = 0; 398 break; 399 } 400 } 401 402 for (i = 0; i < ISA_NDRQ; i++) { 403 if (res[i]) 404 bus_release_resource(child, SYS_RES_DRQ, 405 i, res[i]); 406 } 407 408 return (success); 409 } 410 411 /* 412 * Attempt to find a working set of resources for a device. Return 413 * non-zero if a working configuration is found. 414 */ 415 static int 416 isa_assign_resources(device_t child) 417 { 418 struct isa_device *idev = DEVTOISA(child); 419 struct isa_config_entry *ice; 420 struct isa_config *cfg; 421 const char *reason; 422 423 reason = "Empty ISA id_configs"; 424 cfg = malloc(sizeof(struct isa_config), M_TEMP, M_NOWAIT|M_ZERO); 425 if (cfg == NULL) 426 return(0); 427 TAILQ_FOREACH(ice, &idev->id_configs, ice_link) { 428 reason = "memory"; 429 if (!isa_find_memory(child, &ice->ice_config, cfg)) 430 continue; 431 reason = "port"; 432 if (!isa_find_port(child, &ice->ice_config, cfg)) 433 continue; 434 reason = "irq"; 435 if (!isa_find_irq(child, &ice->ice_config, cfg)) 436 continue; 437 reason = "drq"; 438 if (!isa_find_drq(child, &ice->ice_config, cfg)) 439 continue; 440 441 /* 442 * A working configuration was found enable the device 443 * with this configuration. 444 */ 445 reason = "no callback"; 446 if (idev->id_config_cb) { 447 idev->id_config_cb(idev->id_config_arg, 448 cfg, 1); 449 free(cfg, M_TEMP); 450 return (1); 451 } 452 } 453 454 /* 455 * Disable the device. 456 */ 457 bus_print_child_header(device_get_parent(child), child); 458 printf(" can't assign resources (%s)\n", reason); 459 if (bootverbose) 460 isa_print_child(device_get_parent(child), child); 461 bzero(cfg, sizeof (*cfg)); 462 if (idev->id_config_cb) 463 idev->id_config_cb(idev->id_config_arg, cfg, 0); 464 device_disable(child); 465 466 free(cfg, M_TEMP); 467 return (0); 468 } 469 470 /* 471 * Called after other devices have initialised to probe for isa devices. 472 */ 473 void 474 isa_probe_children(device_t dev) 475 { 476 device_t *children; 477 struct isa_config *cfg; 478 int nchildren, i; 479 480 /* 481 * Create all the children by calling driver's identify methods. 482 */ 483 bus_generic_probe(dev); 484 485 if (device_get_children(dev, &children, &nchildren)) 486 return; 487 488 /* 489 * First disable all pnp devices so that they don't get 490 * matched by legacy probes. 491 */ 492 if (bootverbose) 493 printf("isa_probe_children: disabling PnP devices\n"); 494 495 cfg = malloc(sizeof(*cfg), M_TEMP, M_NOWAIT|M_ZERO); 496 if (cfg == NULL) { 497 free(children, M_TEMP); 498 return; 499 } 500 501 for (i = 0; i < nchildren; i++) { 502 device_t child = children[i]; 503 struct isa_device *idev = DEVTOISA(child); 504 505 bzero(cfg, sizeof(*cfg)); 506 if (idev->id_config_cb) 507 idev->id_config_cb(idev->id_config_arg, cfg, 0); 508 } 509 510 free(cfg, M_TEMP); 511 512 /* 513 * Next probe all non-pnp devices so that they claim their 514 * resources first. 515 */ 516 if (bootverbose) 517 printf("isa_probe_children: probing non-PnP devices\n"); 518 for (i = 0; i < nchildren; i++) { 519 device_t child = children[i]; 520 struct isa_device *idev = DEVTOISA(child); 521 522 if (TAILQ_FIRST(&idev->id_configs)) 523 continue; 524 525 device_probe_and_attach(child); 526 } 527 528 /* 529 * Finally assign resource to pnp devices and probe them. 530 */ 531 if (bootverbose) 532 printf("isa_probe_children: probing PnP devices\n"); 533 for (i = 0; i < nchildren; i++) { 534 device_t child = children[i]; 535 struct isa_device* idev = DEVTOISA(child); 536 537 if (!TAILQ_FIRST(&idev->id_configs)) 538 continue; 539 540 if (isa_assign_resources(child)) { 541 struct resource_list *rl = &idev->id_resources; 542 struct resource_list_entry *rle; 543 544 device_probe_and_attach(child); 545 546 /* 547 * Claim any unallocated resources to keep other 548 * devices from using them. 549 */ 550 STAILQ_FOREACH(rle, rl, link) { 551 if (!rle->res) { 552 int rid = rle->rid; 553 resource_list_alloc(rl, dev, child, 554 rle->type, 555 &rid, 556 0, ~0, 1, 0); 557 } 558 } 559 } 560 } 561 562 free(children, M_TEMP); 563 564 isa_running = 1; 565 } 566 567 /* 568 * Add a new child with default ivars. 569 */ 570 static device_t 571 isa_add_child(device_t dev, int order, const char *name, int unit) 572 { 573 device_t child; 574 struct isa_device *idev; 575 576 child = device_add_child_ordered(dev, order, name, unit); 577 if (child == NULL) 578 return (child); 579 580 idev = malloc(sizeof(struct isa_device), M_ISADEV, M_NOWAIT | M_ZERO); 581 if (!idev) 582 return (0); 583 584 resource_list_init(&idev->id_resources); 585 TAILQ_INIT(&idev->id_configs); 586 587 device_set_ivars(child, idev); 588 589 return (child); 590 } 591 592 static int 593 isa_print_all_resources(device_t dev) 594 { 595 struct isa_device *idev = DEVTOISA(dev); 596 struct resource_list *rl = &idev->id_resources; 597 int retval = 0; 598 599 if (STAILQ_FIRST(rl) || device_get_flags(dev)) 600 retval += printf(" at"); 601 602 retval += resource_list_print_type(rl, "port", SYS_RES_IOPORT, "%#lx"); 603 retval += resource_list_print_type(rl, "iomem", SYS_RES_MEMORY, "%#lx"); 604 retval += resource_list_print_type(rl, "irq", SYS_RES_IRQ, "%ld"); 605 retval += resource_list_print_type(rl, "drq", SYS_RES_DRQ, "%ld"); 606 if (device_get_flags(dev)) 607 retval += printf(" flags %#x", device_get_flags(dev)); 608 #ifdef ISAPNP 609 if (idev->id_vendorid) 610 retval += printf(" pnpid %s", pnp_eisaformat(idev->id_vendorid)); 611 #endif 612 613 return (retval); 614 } 615 616 static int 617 isa_print_child(device_t bus, device_t dev) 618 { 619 int retval = 0; 620 621 retval += bus_print_child_header(bus, dev); 622 retval += isa_print_all_resources(dev); 623 retval += bus_print_child_footer(bus, dev); 624 625 return (retval); 626 } 627 628 static void 629 isa_probe_nomatch(device_t dev, device_t child) 630 { 631 if (bootverbose) { 632 bus_print_child_header(dev, child); 633 printf(" failed to probe"); 634 isa_print_all_resources(child); 635 bus_print_child_footer(dev, child); 636 } 637 638 return; 639 } 640 641 static int 642 isa_read_ivar(device_t bus, device_t dev, int index, uintptr_t * result) 643 { 644 struct isa_device* idev = DEVTOISA(dev); 645 struct resource_list *rl = &idev->id_resources; 646 struct resource_list_entry *rle; 647 648 switch (index) { 649 case ISA_IVAR_PORT_0: 650 rle = resource_list_find(rl, SYS_RES_IOPORT, 0); 651 if (rle) 652 *result = rle->start; 653 else 654 *result = -1; 655 break; 656 657 case ISA_IVAR_PORT_1: 658 rle = resource_list_find(rl, SYS_RES_IOPORT, 1); 659 if (rle) 660 *result = rle->start; 661 else 662 *result = -1; 663 break; 664 665 case ISA_IVAR_PORTSIZE_0: 666 rle = resource_list_find(rl, SYS_RES_IOPORT, 0); 667 if (rle) 668 *result = rle->count; 669 else 670 *result = 0; 671 break; 672 673 case ISA_IVAR_PORTSIZE_1: 674 rle = resource_list_find(rl, SYS_RES_IOPORT, 1); 675 if (rle) 676 *result = rle->count; 677 else 678 *result = 0; 679 break; 680 681 case ISA_IVAR_MADDR_0: 682 rle = resource_list_find(rl, SYS_RES_MEMORY, 0); 683 if (rle) 684 *result = rle->start; 685 else 686 *result = -1; 687 break; 688 689 case ISA_IVAR_MADDR_1: 690 rle = resource_list_find(rl, SYS_RES_MEMORY, 1); 691 if (rle) 692 *result = rle->start; 693 else 694 *result = -1; 695 break; 696 697 case ISA_IVAR_MEMSIZE_0: 698 rle = resource_list_find(rl, SYS_RES_MEMORY, 0); 699 if (rle) 700 *result = rle->count; 701 else 702 *result = 0; 703 break; 704 705 case ISA_IVAR_MEMSIZE_1: 706 rle = resource_list_find(rl, SYS_RES_MEMORY, 1); 707 if (rle) 708 *result = rle->count; 709 else 710 *result = 0; 711 break; 712 713 case ISA_IVAR_IRQ_0: 714 rle = resource_list_find(rl, SYS_RES_IRQ, 0); 715 if (rle) 716 *result = rle->start; 717 else 718 *result = -1; 719 break; 720 721 case ISA_IVAR_IRQ_1: 722 rle = resource_list_find(rl, SYS_RES_IRQ, 1); 723 if (rle) 724 *result = rle->start; 725 else 726 *result = -1; 727 break; 728 729 case ISA_IVAR_DRQ_0: 730 rle = resource_list_find(rl, SYS_RES_DRQ, 0); 731 if (rle) 732 *result = rle->start; 733 else 734 *result = -1; 735 break; 736 737 case ISA_IVAR_DRQ_1: 738 rle = resource_list_find(rl, SYS_RES_DRQ, 1); 739 if (rle) 740 *result = rle->start; 741 else 742 *result = -1; 743 break; 744 745 case ISA_IVAR_VENDORID: 746 *result = idev->id_vendorid; 747 break; 748 749 case ISA_IVAR_SERIAL: 750 *result = idev->id_serial; 751 break; 752 753 case ISA_IVAR_LOGICALID: 754 *result = idev->id_logicalid; 755 break; 756 757 case ISA_IVAR_COMPATID: 758 *result = idev->id_compatid; 759 break; 760 761 case ISA_IVAR_CONFIGATTR: 762 *result = idev->id_config_attr; 763 break; 764 765 default: 766 return (ENOENT); 767 } 768 769 return (0); 770 } 771 772 static int 773 isa_write_ivar(device_t bus, device_t dev, int index, uintptr_t value) 774 { 775 struct isa_device* idev = DEVTOISA(dev); 776 777 switch (index) { 778 case ISA_IVAR_PORT_0: 779 case ISA_IVAR_PORT_1: 780 case ISA_IVAR_PORTSIZE_0: 781 case ISA_IVAR_PORTSIZE_1: 782 case ISA_IVAR_MADDR_0: 783 case ISA_IVAR_MADDR_1: 784 case ISA_IVAR_MEMSIZE_0: 785 case ISA_IVAR_MEMSIZE_1: 786 case ISA_IVAR_IRQ_0: 787 case ISA_IVAR_IRQ_1: 788 case ISA_IVAR_DRQ_0: 789 case ISA_IVAR_DRQ_1: 790 return (EINVAL); 791 792 case ISA_IVAR_VENDORID: 793 idev->id_vendorid = value; 794 break; 795 796 case ISA_IVAR_SERIAL: 797 idev->id_serial = value; 798 break; 799 800 case ISA_IVAR_LOGICALID: 801 idev->id_logicalid = value; 802 break; 803 804 case ISA_IVAR_COMPATID: 805 idev->id_compatid = value; 806 break; 807 808 case ISA_IVAR_CONFIGATTR: 809 idev->id_config_attr = value; 810 break; 811 812 default: 813 return (ENOENT); 814 } 815 816 return (0); 817 } 818 819 /* 820 * Free any resources which the driver missed or which we were holding for 821 * it (see isa_probe_children). 822 */ 823 static void 824 isa_child_detached(device_t dev, device_t child) 825 { 826 struct isa_device* idev = DEVTOISA(child); 827 struct resource_list *rl = &idev->id_resources; 828 struct resource_list_entry *rle; 829 830 if (TAILQ_FIRST(&idev->id_configs)) { 831 /* 832 * Claim any unallocated resources to keep other 833 * devices from using them. 834 */ 835 STAILQ_FOREACH(rle, rl, link) { 836 if (!rle->res) { 837 int rid = rle->rid; 838 resource_list_alloc(rl, dev, child, 839 rle->type, 840 &rid, 0, ~0, 1, 0); 841 } 842 } 843 } 844 } 845 846 static void 847 isa_driver_added(device_t dev, driver_t *driver) 848 { 849 device_t *children; 850 int nchildren, i; 851 852 /* 853 * Don't do anything if drivers are dynamically 854 * added during autoconfiguration (cf. ymf724). 855 * since that would end up calling identify 856 * twice. 857 */ 858 if (!isa_running) 859 return; 860 861 DEVICE_IDENTIFY(driver, dev); 862 if (device_get_children(dev, &children, &nchildren)) 863 return; 864 865 for (i = 0; i < nchildren; i++) { 866 device_t child = children[i]; 867 struct isa_device *idev = DEVTOISA(child); 868 struct resource_list *rl = &idev->id_resources; 869 struct resource_list_entry *rle; 870 871 if (device_get_state(child) != DS_NOTPRESENT) 872 continue; 873 if (!device_is_enabled(child)) 874 continue; 875 876 /* 877 * Free resources which we were holding on behalf of 878 * the device. 879 */ 880 STAILQ_FOREACH(rle, &idev->id_resources, link) { 881 if (rle->res) 882 resource_list_release(rl, dev, child, 883 rle->type, 884 rle->rid, 885 rle->res); 886 } 887 888 if (TAILQ_FIRST(&idev->id_configs)) 889 if (!isa_assign_resources(child)) 890 continue; 891 892 device_probe_and_attach(child); 893 894 if (TAILQ_FIRST(&idev->id_configs)) { 895 /* 896 * Claim any unallocated resources to keep other 897 * devices from using them. 898 */ 899 STAILQ_FOREACH(rle, rl, link) { 900 if (!rle->res) { 901 int rid = rle->rid; 902 resource_list_alloc(rl, dev, child, 903 rle->type, 904 &rid, 0, ~0, 1, 0); 905 } 906 } 907 } 908 } 909 910 free(children, M_TEMP); 911 } 912 913 static int 914 isa_set_resource(device_t dev, device_t child, int type, int rid, 915 u_long start, u_long count) 916 { 917 struct isa_device* idev = DEVTOISA(child); 918 struct resource_list *rl = &idev->id_resources; 919 920 if (type != SYS_RES_IOPORT && type != SYS_RES_MEMORY 921 && type != SYS_RES_IRQ && type != SYS_RES_DRQ) 922 return (EINVAL); 923 if (rid < 0) 924 return (EINVAL); 925 if (type == SYS_RES_IOPORT && rid >= ISA_NPORT) 926 return (EINVAL); 927 if (type == SYS_RES_MEMORY && rid >= ISA_NMEM) 928 return (EINVAL); 929 if (type == SYS_RES_IRQ && rid >= ISA_NIRQ) 930 return (EINVAL); 931 if (type == SYS_RES_DRQ && rid >= ISA_NDRQ) 932 return (EINVAL); 933 934 resource_list_add(rl, type, rid, start, start + count - 1, count); 935 936 return (0); 937 } 938 939 static struct resource_list * 940 isa_get_resource_list (device_t dev, device_t child) 941 { 942 struct isa_device* idev = DEVTOISA(child); 943 struct resource_list *rl = &idev->id_resources; 944 945 if (!rl) 946 return (NULL); 947 948 return (rl); 949 } 950 951 static int 952 isa_add_config(device_t dev, device_t child, int priority, 953 struct isa_config *config) 954 { 955 struct isa_device* idev = DEVTOISA(child); 956 struct isa_config_entry *newice, *ice; 957 958 newice = malloc(sizeof *ice, M_DEVBUF, M_NOWAIT); 959 if (!newice) 960 return (ENOMEM); 961 962 newice->ice_priority = priority; 963 newice->ice_config = *config; 964 965 TAILQ_FOREACH(ice, &idev->id_configs, ice_link) { 966 if (ice->ice_priority > priority) 967 break; 968 } 969 if (ice) 970 TAILQ_INSERT_BEFORE(ice, newice, ice_link); 971 else 972 TAILQ_INSERT_TAIL(&idev->id_configs, newice, ice_link); 973 974 return (0); 975 } 976 977 static void 978 isa_set_config_callback(device_t dev, device_t child, isa_config_cb *fn, 979 void *arg) 980 { 981 struct isa_device* idev = DEVTOISA(child); 982 983 idev->id_config_cb = fn; 984 idev->id_config_arg = arg; 985 } 986 987 static int 988 isa_pnp_probe(device_t dev, device_t child, struct isa_pnp_id *ids) 989 { 990 struct isa_device* idev = DEVTOISA(child); 991 992 if (!idev->id_vendorid) 993 return (ENOENT); 994 995 while (ids && ids->ip_id) { 996 /* 997 * Really ought to support >1 compat id per device. 998 */ 999 if (idev->id_logicalid == ids->ip_id 1000 || idev->id_compatid == ids->ip_id) { 1001 if (ids->ip_desc) 1002 device_set_desc(child, ids->ip_desc); 1003 return (0); 1004 } 1005 ids++; 1006 } 1007 1008 return (ENXIO); 1009 } 1010 1011 static int 1012 isa_child_pnpinfo_str(device_t bus, device_t child, char *buf, 1013 size_t buflen) 1014 { 1015 #ifdef ISAPNP 1016 struct isa_device *idev = DEVTOISA(child); 1017 1018 if (idev->id_vendorid) 1019 snprintf(buf, buflen, "pnpid=%s", 1020 pnp_eisaformat(idev->id_vendorid)); 1021 #endif 1022 return (0); 1023 } 1024 1025 static int 1026 isa_child_location_str(device_t bus, device_t child, char *buf, 1027 size_t buflen) 1028 { 1029 /* Nothing here yet */ 1030 *buf = '\0'; 1031 return (0); 1032 } 1033 1034 static device_method_t isa_methods[] = { 1035 /* Device interface */ 1036 DEVMETHOD(device_probe, isa_probe), 1037 DEVMETHOD(device_attach, isa_attach), 1038 DEVMETHOD(device_detach, bus_generic_detach), 1039 DEVMETHOD(device_shutdown, bus_generic_shutdown), 1040 DEVMETHOD(device_suspend, bus_generic_suspend), 1041 DEVMETHOD(device_resume, bus_generic_resume), 1042 1043 /* Bus interface */ 1044 DEVMETHOD(bus_add_child, isa_add_child), 1045 DEVMETHOD(bus_print_child, isa_print_child), 1046 DEVMETHOD(bus_probe_nomatch, isa_probe_nomatch), 1047 DEVMETHOD(bus_read_ivar, isa_read_ivar), 1048 DEVMETHOD(bus_write_ivar, isa_write_ivar), 1049 DEVMETHOD(bus_child_detached, isa_child_detached), 1050 DEVMETHOD(bus_driver_added, isa_driver_added), 1051 DEVMETHOD(bus_setup_intr, isa_setup_intr), 1052 DEVMETHOD(bus_teardown_intr, isa_teardown_intr), 1053 1054 DEVMETHOD(bus_get_resource_list,isa_get_resource_list), 1055 DEVMETHOD(bus_alloc_resource, isa_alloc_resource), 1056 DEVMETHOD(bus_release_resource, isa_release_resource), 1057 DEVMETHOD(bus_set_resource, isa_set_resource), 1058 DEVMETHOD(bus_get_resource, bus_generic_rl_get_resource), 1059 DEVMETHOD(bus_delete_resource, bus_generic_rl_delete_resource), 1060 DEVMETHOD(bus_activate_resource, bus_generic_activate_resource), 1061 DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource), 1062 DEVMETHOD(bus_child_pnpinfo_str, isa_child_pnpinfo_str), 1063 DEVMETHOD(bus_child_location_str, isa_child_location_str), 1064 1065 /* ISA interface */ 1066 DEVMETHOD(isa_add_config, isa_add_config), 1067 DEVMETHOD(isa_set_config_callback, isa_set_config_callback), 1068 DEVMETHOD(isa_pnp_probe, isa_pnp_probe), 1069 1070 { 0, 0 } 1071 }; 1072 1073 driver_t isa_driver = { 1074 "isa", 1075 isa_methods, 1076 1, /* no softc */ 1077 }; 1078 1079 devclass_t isa_devclass; 1080 1081 /* 1082 * ISA can be attached to a PCI-ISA bridge, or other locations on some 1083 * platforms. 1084 */ 1085 DRIVER_MODULE(isa, isab, isa_driver, isa_devclass, 0, 0); 1086 DRIVER_MODULE(isa, eisab, isa_driver, isa_devclass, 0, 0); 1087 MODULE_VERSION(isa, 1); 1088 1089 /* 1090 * Code common to ISA bridges. 1091 */ 1092 1093 devclass_t isab_devclass; 1094 1095 int 1096 isab_attach(device_t dev) 1097 { 1098 device_t child; 1099 1100 child = device_add_child(dev, "isa", 0); 1101 if (child != NULL) 1102 return (bus_generic_attach(dev)); 1103 return (ENXIO); 1104 } 1105