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