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 += align) { 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 * Return non-zero if the device has a single configuration, that is, 472 * a fixed set of resoruces. 473 */ 474 static int 475 isa_has_single_config(device_t dev) 476 { 477 struct isa_device *idev = DEVTOISA(dev); 478 struct isa_config_entry *ice; 479 uint32_t mask; 480 int i; 481 482 ice = TAILQ_FIRST(&idev->id_configs); 483 if (TAILQ_NEXT(ice, ice_link)) 484 return (0); 485 486 for (i = 0; i < ice->ice_config.ic_nmem; ++i) { 487 if (ice->ice_config.ic_mem[i].ir_size == 0) 488 continue; 489 if (ice->ice_config.ic_mem[i].ir_end != 490 ice->ice_config.ic_mem[i].ir_start + 491 ice->ice_config.ic_mem[i].ir_size - 1) 492 return (0); 493 } 494 for (i = 0; i < ice->ice_config.ic_nport; ++i) { 495 if (ice->ice_config.ic_port[i].ir_size == 0) 496 continue; 497 if (ice->ice_config.ic_port[i].ir_end != 498 ice->ice_config.ic_port[i].ir_start + 499 ice->ice_config.ic_port[i].ir_size - 1) 500 return (0); 501 } 502 for (i = 0; i < ice->ice_config.ic_nirq; ++i) { 503 mask = ice->ice_config.ic_irqmask[i]; 504 if (mask == 0) 505 continue; 506 if (find_next_bit(mask, find_first_bit(mask)) != -1) 507 return (0); 508 } 509 for (i = 0; i < ice->ice_config.ic_ndrq; ++i) { 510 mask = ice->ice_config.ic_drqmask[i]; 511 if (mask == 0) 512 continue; 513 if (find_next_bit(mask, find_first_bit(mask)) != -1) 514 return (0); 515 } 516 return (1); 517 } 518 519 /* 520 * Called after other devices have initialised to probe for isa devices. 521 */ 522 void 523 isa_probe_children(device_t dev) 524 { 525 device_t *children; 526 struct isa_config *cfg; 527 int nchildren, i; 528 529 /* 530 * Create all the children by calling driver's identify methods. 531 */ 532 bus_generic_probe(dev); 533 534 if (device_get_children(dev, &children, &nchildren)) 535 return; 536 537 /* 538 * First disable all pnp devices so that they don't get 539 * matched by legacy probes. 540 */ 541 if (bootverbose) 542 printf("isa_probe_children: disabling PnP devices\n"); 543 544 cfg = malloc(sizeof(*cfg), M_TEMP, M_NOWAIT|M_ZERO); 545 if (cfg == NULL) { 546 free(children, M_TEMP); 547 return; 548 } 549 550 for (i = 0; i < nchildren; i++) { 551 device_t child = children[i]; 552 struct isa_device *idev = DEVTOISA(child); 553 554 bzero(cfg, sizeof(*cfg)); 555 if (idev->id_config_cb) 556 idev->id_config_cb(idev->id_config_arg, cfg, 0); 557 } 558 559 free(cfg, M_TEMP); 560 561 /* 562 * Next probe all non-pnp devices so that they claim their 563 * resources first. 564 */ 565 if (bootverbose) 566 printf("isa_probe_children: probing non-PnP devices\n"); 567 for (i = 0; i < nchildren; i++) { 568 device_t child = children[i]; 569 struct isa_device *idev = DEVTOISA(child); 570 571 if (TAILQ_FIRST(&idev->id_configs)) 572 continue; 573 574 device_probe_and_attach(child); 575 } 576 577 /* 578 * Finally assign resource to pnp devices and probe them. 579 */ 580 if (bootverbose) 581 printf("isa_probe_children: probing PnP devices\n"); 582 for (i = 0; i < nchildren; i++) { 583 device_t child = children[i]; 584 struct isa_device* idev = DEVTOISA(child); 585 586 if (!TAILQ_FIRST(&idev->id_configs)) 587 continue; 588 589 if (isa_assign_resources(child)) { 590 struct resource_list *rl = &idev->id_resources; 591 struct resource_list_entry *rle; 592 593 device_probe_and_attach(child); 594 595 /* 596 * Claim any unallocated resources to keep other 597 * devices from using them. 598 */ 599 STAILQ_FOREACH(rle, rl, link) { 600 if (!rle->res) { 601 int rid = rle->rid; 602 resource_list_alloc(rl, dev, child, 603 rle->type, 604 &rid, 605 0, ~0, 1, 0); 606 } 607 } 608 } 609 } 610 611 free(children, M_TEMP); 612 613 isa_running = 1; 614 } 615 616 /* 617 * Add a new child with default ivars. 618 */ 619 static device_t 620 isa_add_child(device_t dev, int order, const char *name, int unit) 621 { 622 device_t child; 623 struct isa_device *idev; 624 625 child = device_add_child_ordered(dev, order, name, unit); 626 if (child == NULL) 627 return (child); 628 629 idev = malloc(sizeof(struct isa_device), M_ISADEV, M_NOWAIT | M_ZERO); 630 if (!idev) 631 return (0); 632 633 resource_list_init(&idev->id_resources); 634 TAILQ_INIT(&idev->id_configs); 635 636 device_set_ivars(child, idev); 637 638 return (child); 639 } 640 641 static int 642 isa_print_all_resources(device_t dev) 643 { 644 struct isa_device *idev = DEVTOISA(dev); 645 struct resource_list *rl = &idev->id_resources; 646 int retval = 0; 647 648 if (STAILQ_FIRST(rl) || device_get_flags(dev)) 649 retval += printf(" at"); 650 651 retval += resource_list_print_type(rl, "port", SYS_RES_IOPORT, "%#lx"); 652 retval += resource_list_print_type(rl, "iomem", SYS_RES_MEMORY, "%#lx"); 653 retval += resource_list_print_type(rl, "irq", SYS_RES_IRQ, "%ld"); 654 retval += resource_list_print_type(rl, "drq", SYS_RES_DRQ, "%ld"); 655 if (device_get_flags(dev)) 656 retval += printf(" flags %#x", device_get_flags(dev)); 657 #ifdef ISAPNP 658 if (idev->id_vendorid) 659 retval += printf(" pnpid %s", pnp_eisaformat(idev->id_vendorid)); 660 #endif 661 662 return (retval); 663 } 664 665 static int 666 isa_print_child(device_t bus, device_t dev) 667 { 668 int retval = 0; 669 670 retval += bus_print_child_header(bus, dev); 671 retval += isa_print_all_resources(dev); 672 retval += bus_print_child_footer(bus, dev); 673 674 return (retval); 675 } 676 677 static void 678 isa_probe_nomatch(device_t dev, device_t child) 679 { 680 if (bootverbose) { 681 bus_print_child_header(dev, child); 682 printf(" failed to probe"); 683 isa_print_all_resources(child); 684 bus_print_child_footer(dev, child); 685 } 686 687 return; 688 } 689 690 static int 691 isa_read_ivar(device_t bus, device_t dev, int index, uintptr_t * result) 692 { 693 struct isa_device* idev = DEVTOISA(dev); 694 struct resource_list *rl = &idev->id_resources; 695 struct resource_list_entry *rle; 696 697 switch (index) { 698 case ISA_IVAR_PORT_0: 699 rle = resource_list_find(rl, SYS_RES_IOPORT, 0); 700 if (rle) 701 *result = rle->start; 702 else 703 *result = -1; 704 break; 705 706 case ISA_IVAR_PORT_1: 707 rle = resource_list_find(rl, SYS_RES_IOPORT, 1); 708 if (rle) 709 *result = rle->start; 710 else 711 *result = -1; 712 break; 713 714 case ISA_IVAR_PORTSIZE_0: 715 rle = resource_list_find(rl, SYS_RES_IOPORT, 0); 716 if (rle) 717 *result = rle->count; 718 else 719 *result = 0; 720 break; 721 722 case ISA_IVAR_PORTSIZE_1: 723 rle = resource_list_find(rl, SYS_RES_IOPORT, 1); 724 if (rle) 725 *result = rle->count; 726 else 727 *result = 0; 728 break; 729 730 case ISA_IVAR_MADDR_0: 731 rle = resource_list_find(rl, SYS_RES_MEMORY, 0); 732 if (rle) 733 *result = rle->start; 734 else 735 *result = -1; 736 break; 737 738 case ISA_IVAR_MADDR_1: 739 rle = resource_list_find(rl, SYS_RES_MEMORY, 1); 740 if (rle) 741 *result = rle->start; 742 else 743 *result = -1; 744 break; 745 746 case ISA_IVAR_MEMSIZE_0: 747 rle = resource_list_find(rl, SYS_RES_MEMORY, 0); 748 if (rle) 749 *result = rle->count; 750 else 751 *result = 0; 752 break; 753 754 case ISA_IVAR_MEMSIZE_1: 755 rle = resource_list_find(rl, SYS_RES_MEMORY, 1); 756 if (rle) 757 *result = rle->count; 758 else 759 *result = 0; 760 break; 761 762 case ISA_IVAR_IRQ_0: 763 rle = resource_list_find(rl, SYS_RES_IRQ, 0); 764 if (rle) 765 *result = rle->start; 766 else 767 *result = -1; 768 break; 769 770 case ISA_IVAR_IRQ_1: 771 rle = resource_list_find(rl, SYS_RES_IRQ, 1); 772 if (rle) 773 *result = rle->start; 774 else 775 *result = -1; 776 break; 777 778 case ISA_IVAR_DRQ_0: 779 rle = resource_list_find(rl, SYS_RES_DRQ, 0); 780 if (rle) 781 *result = rle->start; 782 else 783 *result = -1; 784 break; 785 786 case ISA_IVAR_DRQ_1: 787 rle = resource_list_find(rl, SYS_RES_DRQ, 1); 788 if (rle) 789 *result = rle->start; 790 else 791 *result = -1; 792 break; 793 794 case ISA_IVAR_VENDORID: 795 *result = idev->id_vendorid; 796 break; 797 798 case ISA_IVAR_SERIAL: 799 *result = idev->id_serial; 800 break; 801 802 case ISA_IVAR_LOGICALID: 803 *result = idev->id_logicalid; 804 break; 805 806 case ISA_IVAR_COMPATID: 807 *result = idev->id_compatid; 808 break; 809 810 case ISA_IVAR_CONFIGATTR: 811 *result = idev->id_config_attr; 812 break; 813 814 default: 815 return (ENOENT); 816 } 817 818 return (0); 819 } 820 821 static int 822 isa_write_ivar(device_t bus, device_t dev, int index, uintptr_t value) 823 { 824 struct isa_device* idev = DEVTOISA(dev); 825 826 switch (index) { 827 case ISA_IVAR_PORT_0: 828 case ISA_IVAR_PORT_1: 829 case ISA_IVAR_PORTSIZE_0: 830 case ISA_IVAR_PORTSIZE_1: 831 case ISA_IVAR_MADDR_0: 832 case ISA_IVAR_MADDR_1: 833 case ISA_IVAR_MEMSIZE_0: 834 case ISA_IVAR_MEMSIZE_1: 835 case ISA_IVAR_IRQ_0: 836 case ISA_IVAR_IRQ_1: 837 case ISA_IVAR_DRQ_0: 838 case ISA_IVAR_DRQ_1: 839 return (EINVAL); 840 841 case ISA_IVAR_VENDORID: 842 idev->id_vendorid = value; 843 break; 844 845 case ISA_IVAR_SERIAL: 846 idev->id_serial = value; 847 break; 848 849 case ISA_IVAR_LOGICALID: 850 idev->id_logicalid = value; 851 break; 852 853 case ISA_IVAR_COMPATID: 854 idev->id_compatid = value; 855 break; 856 857 case ISA_IVAR_CONFIGATTR: 858 idev->id_config_attr = value; 859 break; 860 861 default: 862 return (ENOENT); 863 } 864 865 return (0); 866 } 867 868 /* 869 * Free any resources which the driver missed or which we were holding for 870 * it (see isa_probe_children). 871 */ 872 static void 873 isa_child_detached(device_t dev, device_t child) 874 { 875 struct isa_device* idev = DEVTOISA(child); 876 struct resource_list *rl = &idev->id_resources; 877 struct resource_list_entry *rle; 878 879 if (TAILQ_FIRST(&idev->id_configs)) { 880 /* 881 * Claim any unallocated resources to keep other 882 * devices from using them. 883 */ 884 STAILQ_FOREACH(rle, rl, link) { 885 if (!rle->res) { 886 int rid = rle->rid; 887 resource_list_alloc(rl, dev, child, 888 rle->type, 889 &rid, 0, ~0, 1, 0); 890 } 891 } 892 } 893 } 894 895 static void 896 isa_driver_added(device_t dev, driver_t *driver) 897 { 898 device_t *children; 899 int nchildren, i; 900 901 /* 902 * Don't do anything if drivers are dynamically 903 * added during autoconfiguration (cf. ymf724). 904 * since that would end up calling identify 905 * twice. 906 */ 907 if (!isa_running) 908 return; 909 910 DEVICE_IDENTIFY(driver, dev); 911 if (device_get_children(dev, &children, &nchildren)) 912 return; 913 914 for (i = 0; i < nchildren; i++) { 915 device_t child = children[i]; 916 struct isa_device *idev = DEVTOISA(child); 917 struct resource_list *rl = &idev->id_resources; 918 struct resource_list_entry *rle; 919 920 if (device_get_state(child) != DS_NOTPRESENT) 921 continue; 922 if (!device_is_enabled(child)) 923 continue; 924 925 /* 926 * Free resources which we were holding on behalf of 927 * the device. 928 */ 929 STAILQ_FOREACH(rle, &idev->id_resources, link) { 930 if (rle->res) 931 resource_list_release(rl, dev, child, 932 rle->type, 933 rle->rid, 934 rle->res); 935 } 936 937 if (TAILQ_FIRST(&idev->id_configs)) 938 if (!isa_assign_resources(child)) 939 continue; 940 941 device_probe_and_attach(child); 942 943 if (TAILQ_FIRST(&idev->id_configs)) { 944 /* 945 * Claim any unallocated resources to keep other 946 * devices from using them. 947 */ 948 STAILQ_FOREACH(rle, rl, link) { 949 if (!rle->res) { 950 int rid = rle->rid; 951 resource_list_alloc(rl, dev, child, 952 rle->type, 953 &rid, 0, ~0, 1, 0); 954 } 955 } 956 } 957 } 958 959 free(children, M_TEMP); 960 } 961 962 static int 963 isa_set_resource(device_t dev, device_t child, int type, int rid, 964 u_long start, u_long count) 965 { 966 struct isa_device* idev = DEVTOISA(child); 967 struct resource_list *rl = &idev->id_resources; 968 969 if (type != SYS_RES_IOPORT && type != SYS_RES_MEMORY 970 && type != SYS_RES_IRQ && type != SYS_RES_DRQ) 971 return (EINVAL); 972 if (rid < 0) 973 return (EINVAL); 974 if (type == SYS_RES_IOPORT && rid >= ISA_NPORT) 975 return (EINVAL); 976 if (type == SYS_RES_MEMORY && rid >= ISA_NMEM) 977 return (EINVAL); 978 if (type == SYS_RES_IRQ && rid >= ISA_NIRQ) 979 return (EINVAL); 980 if (type == SYS_RES_DRQ && rid >= ISA_NDRQ) 981 return (EINVAL); 982 983 resource_list_add(rl, type, rid, start, start + count - 1, count); 984 985 return (0); 986 } 987 988 static struct resource_list * 989 isa_get_resource_list (device_t dev, device_t child) 990 { 991 struct isa_device* idev = DEVTOISA(child); 992 struct resource_list *rl = &idev->id_resources; 993 994 if (!rl) 995 return (NULL); 996 997 return (rl); 998 } 999 1000 static int 1001 isa_add_config(device_t dev, device_t child, int priority, 1002 struct isa_config *config) 1003 { 1004 struct isa_device* idev = DEVTOISA(child); 1005 struct isa_config_entry *newice, *ice; 1006 1007 newice = malloc(sizeof *ice, M_DEVBUF, M_NOWAIT); 1008 if (!newice) 1009 return (ENOMEM); 1010 1011 newice->ice_priority = priority; 1012 newice->ice_config = *config; 1013 1014 TAILQ_FOREACH(ice, &idev->id_configs, ice_link) { 1015 if (ice->ice_priority > priority) 1016 break; 1017 } 1018 if (ice) 1019 TAILQ_INSERT_BEFORE(ice, newice, ice_link); 1020 else 1021 TAILQ_INSERT_TAIL(&idev->id_configs, newice, ice_link); 1022 1023 if (isa_has_single_config(child)) 1024 idev->id_config_attr &= ~ISACFGATTR_MULTI; 1025 else 1026 idev->id_config_attr |= ISACFGATTR_MULTI; 1027 1028 return (0); 1029 } 1030 1031 static void 1032 isa_set_config_callback(device_t dev, device_t child, isa_config_cb *fn, 1033 void *arg) 1034 { 1035 struct isa_device* idev = DEVTOISA(child); 1036 1037 idev->id_config_cb = fn; 1038 idev->id_config_arg = arg; 1039 } 1040 1041 static int 1042 isa_pnp_probe(device_t dev, device_t child, struct isa_pnp_id *ids) 1043 { 1044 struct isa_device* idev = DEVTOISA(child); 1045 1046 if (!idev->id_vendorid) 1047 return (ENOENT); 1048 1049 while (ids && ids->ip_id) { 1050 /* 1051 * Really ought to support >1 compat id per device. 1052 */ 1053 if (idev->id_logicalid == ids->ip_id 1054 || idev->id_compatid == ids->ip_id) { 1055 if (ids->ip_desc) 1056 device_set_desc(child, ids->ip_desc); 1057 return (0); 1058 } 1059 ids++; 1060 } 1061 1062 return (ENXIO); 1063 } 1064 1065 static int 1066 isa_child_pnpinfo_str(device_t bus, device_t child, char *buf, 1067 size_t buflen) 1068 { 1069 #ifdef ISAPNP 1070 struct isa_device *idev = DEVTOISA(child); 1071 1072 if (idev->id_vendorid) 1073 snprintf(buf, buflen, "pnpid=%s", 1074 pnp_eisaformat(idev->id_vendorid)); 1075 #endif 1076 return (0); 1077 } 1078 1079 static int 1080 isa_child_location_str(device_t bus, device_t child, char *buf, 1081 size_t buflen) 1082 { 1083 /* Nothing here yet */ 1084 *buf = '\0'; 1085 return (0); 1086 } 1087 1088 static device_method_t isa_methods[] = { 1089 /* Device interface */ 1090 DEVMETHOD(device_probe, isa_probe), 1091 DEVMETHOD(device_attach, isa_attach), 1092 DEVMETHOD(device_detach, bus_generic_detach), 1093 DEVMETHOD(device_shutdown, bus_generic_shutdown), 1094 DEVMETHOD(device_suspend, bus_generic_suspend), 1095 DEVMETHOD(device_resume, bus_generic_resume), 1096 1097 /* Bus interface */ 1098 DEVMETHOD(bus_add_child, isa_add_child), 1099 DEVMETHOD(bus_print_child, isa_print_child), 1100 DEVMETHOD(bus_probe_nomatch, isa_probe_nomatch), 1101 DEVMETHOD(bus_read_ivar, isa_read_ivar), 1102 DEVMETHOD(bus_write_ivar, isa_write_ivar), 1103 DEVMETHOD(bus_child_detached, isa_child_detached), 1104 DEVMETHOD(bus_driver_added, isa_driver_added), 1105 DEVMETHOD(bus_setup_intr, isa_setup_intr), 1106 DEVMETHOD(bus_teardown_intr, isa_teardown_intr), 1107 1108 DEVMETHOD(bus_get_resource_list,isa_get_resource_list), 1109 DEVMETHOD(bus_alloc_resource, isa_alloc_resource), 1110 DEVMETHOD(bus_release_resource, isa_release_resource), 1111 DEVMETHOD(bus_set_resource, isa_set_resource), 1112 DEVMETHOD(bus_get_resource, bus_generic_rl_get_resource), 1113 DEVMETHOD(bus_delete_resource, bus_generic_rl_delete_resource), 1114 DEVMETHOD(bus_activate_resource, bus_generic_activate_resource), 1115 DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource), 1116 DEVMETHOD(bus_child_pnpinfo_str, isa_child_pnpinfo_str), 1117 DEVMETHOD(bus_child_location_str, isa_child_location_str), 1118 1119 /* ISA interface */ 1120 DEVMETHOD(isa_add_config, isa_add_config), 1121 DEVMETHOD(isa_set_config_callback, isa_set_config_callback), 1122 DEVMETHOD(isa_pnp_probe, isa_pnp_probe), 1123 1124 { 0, 0 } 1125 }; 1126 1127 driver_t isa_driver = { 1128 "isa", 1129 isa_methods, 1130 1, /* no softc */ 1131 }; 1132 1133 devclass_t isa_devclass; 1134 1135 /* 1136 * ISA can be attached to a PCI-ISA bridge, or other locations on some 1137 * platforms. 1138 */ 1139 DRIVER_MODULE(isa, isab, isa_driver, isa_devclass, 0, 0); 1140 DRIVER_MODULE(isa, eisab, isa_driver, isa_devclass, 0, 0); 1141 MODULE_VERSION(isa, 1); 1142 1143 /* 1144 * Code common to ISA bridges. 1145 */ 1146 1147 devclass_t isab_devclass; 1148 1149 int 1150 isab_attach(device_t dev) 1151 { 1152 device_t child; 1153 1154 child = device_add_child(dev, "isa", 0); 1155 if (child != NULL) 1156 return (bus_generic_attach(dev)); 1157 return (ENXIO); 1158 } 1159