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 * $FreeBSD$ 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/param.h> 63 #include <sys/systm.h> 64 #include <sys/kernel.h> 65 #include <sys/bus.h> 66 #include <sys/malloc.h> 67 #include <sys/module.h> 68 #include <machine/bus.h> 69 #include <sys/rman.h> 70 71 #include <machine/resource.h> 72 73 #include <isa/isavar.h> 74 #include <isa/isa_common.h> 75 #ifdef __alpha__ /* XXX workaround a stupid warning */ 76 #include <alpha/isa/isavar.h> 77 #endif 78 79 MALLOC_DEFINE(M_ISADEV, "isadev", "ISA device"); 80 81 static devclass_t isa_devclass; 82 83 /* 84 * At 'probe' time, we add all the devices which we know about to the 85 * bus. The generic attach routine will probe and attach them if they 86 * are alive. 87 */ 88 static int 89 isa_probe(device_t dev) 90 { 91 device_set_desc(dev, "ISA bus"); 92 isa_init(); /* Allow machdep code to initialise */ 93 return bus_generic_probe(dev); 94 } 95 96 extern device_t isa_bus_device; 97 98 static int 99 isa_attach(device_t dev) 100 { 101 /* 102 * Arrange for isa_probe_children(dev) to be called later. XXX 103 */ 104 isa_bus_device = dev; 105 return 0; 106 } 107 108 /* 109 * Find a working set of memory regions for a child using the ranges 110 * in *config and return the regions in *result. Returns non-zero if 111 * a set of ranges was found. 112 */ 113 static int 114 isa_find_memory(device_t child, 115 struct isa_config *config, 116 struct isa_config *result) 117 { 118 device_t dev = device_get_parent(child); 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 ISA_DELETE_RESOURCE(dev, 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 u_int32_t start, end, size, align; 134 for (start = config->ic_mem[i].ir_start, 135 end = config->ic_mem[i].ir_end, 136 size = config->ic_mem[i].ir_size, 137 align = config->ic_mem[i].ir_align; 138 start + size - 1 <= end; 139 start += align) { 140 ISA_SET_RESOURCE(dev, child, SYS_RES_MEMORY, i, 141 start, size); 142 res[i] = bus_alloc_resource(child, 143 SYS_RES_MEMORY, &i, 144 0, ~0, 1, RF_ACTIVE); 145 if (res[i]) { 146 result->ic_mem[i].ir_start = start; 147 result->ic_mem[i].ir_end = start + size - 1; 148 result->ic_mem[i].ir_size = size; 149 result->ic_mem[i].ir_align = align; 150 break; 151 } 152 } 153 154 /* 155 * If we didn't find a place for memory range i, then 156 * give up now. 157 */ 158 if (!res[i]) { 159 success = 0; 160 break; 161 } 162 } 163 164 for (i = 0; i < ISA_NMEM; i++) { 165 if (res[i]) 166 bus_release_resource(child, SYS_RES_MEMORY, 167 i, res[i]); 168 } 169 170 return success; 171 } 172 173 /* 174 * Find a working set of port regions for a child using the ranges 175 * in *config and return the regions in *result. Returns non-zero if 176 * a set of ranges was found. 177 */ 178 static int 179 isa_find_port(device_t child, 180 struct isa_config *config, 181 struct isa_config *result) 182 { 183 device_t dev = device_get_parent(child); 184 int success, i; 185 struct resource *res[ISA_NPORT]; 186 187 /* 188 * First clear out any existing resource definitions. 189 */ 190 for (i = 0; i < ISA_NPORT; i++) { 191 ISA_DELETE_RESOURCE(dev, child, SYS_RES_IOPORT, i); 192 res[i] = NULL; 193 } 194 195 success = 1; 196 result->ic_nport = config->ic_nport; 197 for (i = 0; i < config->ic_nport; i++) { 198 u_int32_t start, end, size, align; 199 for (start = config->ic_port[i].ir_start, 200 end = config->ic_port[i].ir_end, 201 size = config->ic_port[i].ir_size, 202 align = config->ic_port[i].ir_align; 203 start + size - 1 <= end; 204 start += align) { 205 ISA_SET_RESOURCE(dev, child, SYS_RES_IOPORT, i, 206 start, size); 207 res[i] = bus_alloc_resource(child, 208 SYS_RES_IOPORT, &i, 209 0, ~0, 1, RF_ACTIVE); 210 if (res[i]) { 211 result->ic_port[i].ir_start = start; 212 result->ic_port[i].ir_end = start + size - 1; 213 result->ic_port[i].ir_size = size; 214 result->ic_port[i].ir_align = align; 215 break; 216 } 217 } 218 219 /* 220 * If we didn't find a place for port range i, then 221 * give up now. 222 */ 223 if (!res[i]) { 224 success = 0; 225 break; 226 } 227 } 228 229 for (i = 0; i < ISA_NPORT; i++) { 230 if (res[i]) 231 bus_release_resource(child, SYS_RES_IOPORT, 232 i, res[i]); 233 } 234 235 return success; 236 } 237 238 /* 239 * Return the index of the first bit in the mask (or -1 if mask is empty. 240 */ 241 static int 242 find_first_bit(u_int32_t mask) 243 { 244 return ffs(mask) - 1; 245 } 246 247 /* 248 * Return the index of the next bit in the mask, or -1 if there are no more. 249 */ 250 static int 251 find_next_bit(u_int32_t mask, int bit) 252 { 253 bit++; 254 while (bit < 32 && !(mask & (1 << bit))) 255 bit++; 256 if (bit != 32) 257 return bit; 258 return -1; 259 } 260 261 /* 262 * Find a working set of irqs for a child using the masks in *config 263 * and return the regions in *result. Returns non-zero if a set of 264 * irqs was found. 265 */ 266 static int 267 isa_find_irq(device_t child, 268 struct isa_config *config, 269 struct isa_config *result) 270 { 271 device_t dev = device_get_parent(child); 272 int success, i; 273 struct resource *res[ISA_NIRQ]; 274 275 /* 276 * First clear out any existing resource definitions. 277 */ 278 for (i = 0; i < ISA_NIRQ; i++) { 279 ISA_DELETE_RESOURCE(dev, child, SYS_RES_IRQ, i); 280 res[i] = NULL; 281 } 282 283 success = 1; 284 result->ic_nirq = config->ic_nirq; 285 for (i = 0; i < config->ic_nirq; i++) { 286 u_int32_t mask = config->ic_irqmask[i]; 287 int irq; 288 for (irq = find_first_bit(mask); 289 irq != -1; 290 irq = find_next_bit(mask, irq)) { 291 ISA_SET_RESOURCE(dev, child, SYS_RES_IRQ, i, 292 irq, 1); 293 res[i] = bus_alloc_resource(child, 294 SYS_RES_IRQ, &i, 295 0, ~0, 1, RF_ACTIVE); 296 if (res[i]) { 297 result->ic_irqmask[i] = (1 << irq); 298 break; 299 } 300 } 301 302 /* 303 * If we didn't find a place for irq range i, then 304 * give up now. 305 */ 306 if (!res[i]) { 307 success = 0; 308 break; 309 } 310 } 311 312 for (i = 0; i < ISA_NIRQ; i++) { 313 if (res[i]) 314 bus_release_resource(child, SYS_RES_IRQ, 315 i, res[i]); 316 } 317 318 return success; 319 } 320 321 /* 322 * Find a working set of drqs for a child using the masks in *config 323 * and return the regions in *result. Returns non-zero if a set of 324 * drqs was found. 325 */ 326 static int 327 isa_find_drq(device_t child, 328 struct isa_config *config, 329 struct isa_config *result) 330 { 331 device_t dev = device_get_parent(child); 332 int success, i; 333 struct resource *res[ISA_NDRQ]; 334 335 /* 336 * First clear out any existing resource definitions. 337 */ 338 for (i = 0; i < ISA_NDRQ; i++) { 339 ISA_DELETE_RESOURCE(dev, child, SYS_RES_DRQ, i); 340 res[i] = NULL; 341 } 342 343 success = 1; 344 result->ic_ndrq = config->ic_ndrq; 345 for (i = 0; i < config->ic_ndrq; i++) { 346 u_int32_t mask = config->ic_drqmask[i]; 347 int drq; 348 for (drq = find_first_bit(mask); 349 drq != -1; 350 drq = find_next_bit(mask, drq)) { 351 ISA_SET_RESOURCE(dev, child, SYS_RES_DRQ, i, 352 drq, 1); 353 res[i] = bus_alloc_resource(child, 354 SYS_RES_DRQ, &i, 355 0, ~0, 1, RF_ACTIVE); 356 if (res[i]) { 357 result->ic_drqmask[i] = (1 << drq); 358 break; 359 } 360 } 361 362 /* 363 * If we didn't find a place for drq range i, then 364 * give up now. 365 */ 366 if (!res[i]) { 367 success = 0; 368 break; 369 } 370 } 371 372 for (i = 0; i < ISA_NDRQ; i++) { 373 if (res[i]) 374 bus_release_resource(child, SYS_RES_DRQ, 375 i, res[i]); 376 } 377 378 return success; 379 } 380 381 /* 382 * Attempt to find a working set of resources for a device. Return 383 * non-zero if a working configuration is found. 384 */ 385 static int 386 isa_assign_resources(device_t child) 387 { 388 struct isa_device *idev = DEVTOISA(child); 389 struct isa_config_entry *ice; 390 struct isa_config config; 391 392 bzero(&config, sizeof config); 393 TAILQ_FOREACH(ice, &idev->id_configs, ice_link) { 394 if (!isa_find_memory(child, &ice->ice_config, &config)) 395 continue; 396 if (!isa_find_port(child, &ice->ice_config, &config)) 397 continue; 398 if (!isa_find_irq(child, &ice->ice_config, &config)) 399 continue; 400 if (!isa_find_drq(child, &ice->ice_config, &config)) 401 continue; 402 403 /* 404 * A working configuration was found enable the device 405 * with this configuration. 406 */ 407 if (idev->id_config_cb) { 408 idev->id_config_cb(idev->id_config_arg, 409 &config, 1); 410 return 1; 411 } 412 } 413 414 /* 415 * Disable the device. 416 */ 417 bzero(&config, sizeof config); 418 if (idev->id_config_cb) 419 idev->id_config_cb(idev->id_config_arg, &config, 0); 420 device_disable(child); 421 422 return 0; 423 } 424 425 /* 426 * Called after other devices have initialised to probe for isa devices. 427 */ 428 void 429 isa_probe_children(device_t dev) 430 { 431 device_t *children; 432 int nchildren, i; 433 434 if (device_get_children(dev, &children, &nchildren)) 435 return; 436 437 /* 438 * First probe all non-pnp devices so that they claim their 439 * resources first. 440 */ 441 for (i = 0; i < nchildren; i++) { 442 device_t child = children[i]; 443 struct isa_device *idev = DEVTOISA(child); 444 445 if (TAILQ_FIRST(&idev->id_configs)) 446 continue; 447 448 device_probe_and_attach(child); 449 } 450 451 /* 452 * Next assign resource to pnp devices and probe them. 453 */ 454 for (i = 0; i < nchildren; i++) { 455 device_t child = children[i]; 456 struct isa_device* idev = DEVTOISA(child); 457 458 if (!TAILQ_FIRST(&idev->id_configs)) 459 continue; 460 461 if (isa_assign_resources(child)) { 462 struct resource_list_entry *rle; 463 464 device_probe_and_attach(child); 465 466 /* 467 * Claim any unallocated resources to keep other 468 * devices from using them. 469 */ 470 SLIST_FOREACH(rle, &idev->id_resources, link) { 471 if (!rle->res) { 472 int rid = rle->rid; 473 resource_list_alloc(dev, child, 474 rle->type, 475 &rid, 476 0, ~0, 1, 477 RF_ACTIVE); 478 } 479 } 480 } 481 } 482 483 free(children, M_TEMP); 484 } 485 486 /* 487 * Add a new child with default ivars. 488 */ 489 static device_t 490 isa_add_child(device_t dev, int order, const char *name, int unit) 491 { 492 struct isa_device *idev; 493 494 idev = malloc(sizeof(struct isa_device), M_ISADEV, M_NOWAIT); 495 if (!idev) 496 return 0; 497 bzero(idev, sizeof *idev); 498 499 resource_list_init(&idev->id_resources); 500 idev->id_flags = 0; 501 TAILQ_INIT(&idev->id_configs); 502 503 return device_add_child_ordered(dev, order, name, unit, idev); 504 } 505 506 static void 507 isa_print_resources(struct resource_list *rl, const char *name, int type, 508 const char *format) 509 { 510 struct resource_list_entry *rle; 511 int printed; 512 int i; 513 514 printed = 0; 515 for (i = 0; i < 16; i++) { 516 rle = resource_list_find(rl, type, i); 517 if (rle) { 518 if (printed == 0) 519 printf(" %s ", name); 520 else if (printed > 0) 521 printf(","); 522 printed++; 523 printf(format, rle->start); 524 if (rle->count > 1) { 525 printf("-"); 526 printf(format, rle->start + rle->count - 1); 527 } 528 } else if (i > 3) { 529 /* check the first few regardless */ 530 break; 531 } 532 } 533 } 534 535 static int 536 isa_print_child(device_t bus, device_t dev) 537 { 538 struct isa_device *idev = DEVTOISA(dev); 539 struct resource_list *rl = &idev->id_resources; 540 int retval = 0; 541 542 retval += bus_print_child_header(bus, dev); 543 544 if (SLIST_FIRST(rl) || idev->id_flags) 545 retval += printf(" at"); 546 547 isa_print_resources(rl, "port", SYS_RES_IOPORT, "%#lx"); 548 isa_print_resources(rl, "iomem", SYS_RES_MEMORY, "%#lx"); 549 isa_print_resources(rl, "irq", SYS_RES_IRQ, "%ld"); 550 isa_print_resources(rl, "drq", SYS_RES_DRQ, "%ld"); 551 if (idev->id_flags) 552 retval += printf(" flags %#x", idev->id_flags); 553 554 retval += bus_print_child_footer(bus, dev); 555 556 return (retval); 557 } 558 559 static int 560 isa_read_ivar(device_t bus, device_t dev, int index, uintptr_t * result) 561 { 562 struct isa_device* idev = DEVTOISA(dev); 563 struct resource_list *rl = &idev->id_resources; 564 struct resource_list_entry *rle; 565 566 switch (index) { 567 case ISA_IVAR_PORT_0: 568 rle = resource_list_find(rl, SYS_RES_IOPORT, 0); 569 if (rle) 570 *result = rle->start; 571 else 572 *result = -1; 573 break; 574 575 case ISA_IVAR_PORT_1: 576 rle = resource_list_find(rl, SYS_RES_IOPORT, 1); 577 if (rle) 578 *result = rle->start; 579 else 580 *result = -1; 581 break; 582 583 case ISA_IVAR_PORTSIZE_0: 584 rle = resource_list_find(rl, SYS_RES_IOPORT, 0); 585 if (rle) 586 *result = rle->count; 587 else 588 *result = 0; 589 break; 590 591 case ISA_IVAR_PORTSIZE_1: 592 rle = resource_list_find(rl, SYS_RES_IOPORT, 1); 593 if (rle) 594 *result = rle->count; 595 else 596 *result = 0; 597 break; 598 599 case ISA_IVAR_MADDR_0: 600 rle = resource_list_find(rl, SYS_RES_MEMORY, 0); 601 if (rle) 602 *result = rle->start; 603 else 604 *result = -1; 605 break; 606 607 case ISA_IVAR_MADDR_1: 608 rle = resource_list_find(rl, SYS_RES_MEMORY, 1); 609 if (rle) 610 *result = rle->start; 611 else 612 *result = -1; 613 break; 614 615 case ISA_IVAR_MSIZE_0: 616 rle = resource_list_find(rl, SYS_RES_MEMORY, 0); 617 if (rle) 618 *result = rle->count; 619 else 620 *result = 0; 621 break; 622 623 case ISA_IVAR_MSIZE_1: 624 rle = resource_list_find(rl, SYS_RES_MEMORY, 1); 625 if (rle) 626 *result = rle->count; 627 else 628 *result = 0; 629 break; 630 631 case ISA_IVAR_IRQ_0: 632 rle = resource_list_find(rl, SYS_RES_IRQ, 0); 633 if (rle) 634 *result = rle->start; 635 else 636 *result = -1; 637 break; 638 639 case ISA_IVAR_IRQ_1: 640 rle = resource_list_find(rl, SYS_RES_IRQ, 1); 641 if (rle) 642 *result = rle->start; 643 else 644 *result = -1; 645 break; 646 647 case ISA_IVAR_DRQ_0: 648 rle = resource_list_find(rl, SYS_RES_DRQ, 0); 649 if (rle) 650 *result = rle->start; 651 else 652 *result = -1; 653 break; 654 655 case ISA_IVAR_DRQ_1: 656 rle = resource_list_find(rl, SYS_RES_DRQ, 1); 657 if (rle) 658 *result = rle->start; 659 else 660 *result = -1; 661 break; 662 663 case ISA_IVAR_FLAGS: 664 *result = idev->id_flags; 665 break; 666 667 case ISA_IVAR_VENDORID: 668 *result = idev->id_vendorid; 669 break; 670 671 case ISA_IVAR_SERIAL: 672 *result = idev->id_serial; 673 break; 674 675 case ISA_IVAR_LOGICALID: 676 *result = idev->id_logicalid; 677 break; 678 679 case ISA_IVAR_COMPATID: 680 *result = idev->id_compatid; 681 break; 682 683 default: 684 return ENOENT; 685 } 686 687 return 0; 688 } 689 690 static int 691 isa_write_ivar(device_t bus, device_t dev, 692 int index, uintptr_t value) 693 { 694 struct isa_device* idev = DEVTOISA(dev); 695 696 switch (index) { 697 case ISA_IVAR_PORT_0: 698 case ISA_IVAR_PORT_1: 699 case ISA_IVAR_PORTSIZE_0: 700 case ISA_IVAR_PORTSIZE_1: 701 case ISA_IVAR_MADDR_0: 702 case ISA_IVAR_MADDR_1: 703 case ISA_IVAR_MSIZE_0: 704 case ISA_IVAR_MSIZE_1: 705 case ISA_IVAR_IRQ_0: 706 case ISA_IVAR_IRQ_1: 707 case ISA_IVAR_DRQ_0: 708 case ISA_IVAR_DRQ_1: 709 return EINVAL; 710 711 case ISA_IVAR_FLAGS: 712 idev->id_flags = value; 713 break; 714 715 case ISA_IVAR_VENDORID: 716 idev->id_vendorid = value; 717 break; 718 719 case ISA_IVAR_SERIAL: 720 idev->id_serial = value; 721 break; 722 723 case ISA_IVAR_LOGICALID: 724 idev->id_logicalid = value; 725 break; 726 727 case ISA_IVAR_COMPATID: 728 idev->id_compatid = value; 729 break; 730 731 default: 732 return (ENOENT); 733 } 734 735 return (0); 736 } 737 738 /* 739 * Free any resources which the driver missed or which we were holding for 740 * it (see isa_probe_children). 741 */ 742 static void 743 isa_child_detached(device_t dev, device_t child) 744 { 745 struct isa_device* idev = DEVTOISA(child); 746 struct resource_list_entry *rle; 747 748 SLIST_FOREACH(rle, &idev->id_resources, link) { 749 if (rle->res) 750 resource_list_release(dev, child, 751 rle->type, 752 rle->rid, 753 rle->res); 754 } 755 } 756 757 static int 758 isa_set_resource(device_t dev, device_t child, int type, int rid, 759 u_long start, u_long count) 760 { 761 struct isa_device* idev = DEVTOISA(child); 762 struct resource_list *rl = &idev->id_resources; 763 764 if (type != SYS_RES_IOPORT && type != SYS_RES_MEMORY 765 && type != SYS_RES_IRQ && type != SYS_RES_DRQ) 766 return EINVAL; 767 if (rid < 0) 768 return EINVAL; 769 if (type == SYS_RES_IOPORT && rid >= ISA_NPORT) 770 return EINVAL; 771 if (type == SYS_RES_MEMORY && rid >= ISA_NMEM) 772 return EINVAL; 773 if (type == SYS_RES_IRQ && rid >= ISA_NIRQ) 774 return EINVAL; 775 if (type == SYS_RES_DRQ && rid >= ISA_NDRQ) 776 return EINVAL; 777 778 resource_list_add(rl, type, rid, start, start + count - 1, count); 779 780 return 0; 781 } 782 783 static int 784 isa_get_resource(device_t dev, device_t child, int type, int rid, 785 u_long *startp, u_long *countp) 786 { 787 struct isa_device* idev = DEVTOISA(child); 788 struct resource_list *rl = &idev->id_resources; 789 struct resource_list_entry *rle; 790 791 rle = resource_list_find(rl, type, rid); 792 if (!rle) 793 return ENOENT; 794 795 *startp = rle->start; 796 *countp = rle->count; 797 798 return 0; 799 } 800 801 static void 802 isa_delete_resource(device_t dev, device_t child, int type, int rid) 803 { 804 struct isa_device* idev = DEVTOISA(child); 805 struct resource_list *rl = &idev->id_resources; 806 resource_list_delete(rl, type, rid); 807 } 808 809 static int 810 isa_add_config(device_t dev, device_t child, 811 int priority, struct isa_config *config) 812 { 813 struct isa_device* idev = DEVTOISA(child); 814 struct isa_config_entry *newice, *ice; 815 816 newice = malloc(sizeof *ice, M_DEVBUF, M_NOWAIT); 817 if (!newice) 818 return ENOMEM; 819 820 newice->ice_priority = priority; 821 newice->ice_config = *config; 822 823 TAILQ_FOREACH(ice, &idev->id_configs, ice_link) { 824 if (ice->ice_priority > priority) 825 break; 826 } 827 if (ice) 828 TAILQ_INSERT_BEFORE(ice, newice, ice_link); 829 else 830 TAILQ_INSERT_TAIL(&idev->id_configs, newice, ice_link); 831 832 return 0; 833 } 834 835 static void 836 isa_set_config_callback(device_t dev, device_t child, 837 isa_config_cb *fn, void *arg) 838 { 839 struct isa_device* idev = DEVTOISA(child); 840 841 idev->id_config_cb = fn; 842 idev->id_config_arg = arg; 843 } 844 845 static int 846 isa_pnp_probe(device_t dev, device_t child, struct isa_pnp_id *ids) 847 { 848 struct isa_device* idev = DEVTOISA(child); 849 850 if (!idev->id_vendorid) 851 return ENOENT; 852 853 while (ids->ip_id) { 854 /* 855 * Really ought to support >1 compat id per device. 856 */ 857 if (idev->id_logicalid == ids->ip_id 858 || idev->id_compatid == ids->ip_id) { 859 device_set_desc(child, ids->ip_desc); 860 return 0; 861 } 862 ids++; 863 } 864 865 return ENXIO; 866 } 867 868 static device_method_t isa_methods[] = { 869 /* Device interface */ 870 DEVMETHOD(device_probe, isa_probe), 871 DEVMETHOD(device_attach, isa_attach), 872 DEVMETHOD(device_detach, bus_generic_detach), 873 DEVMETHOD(device_shutdown, bus_generic_shutdown), 874 DEVMETHOD(device_suspend, bus_generic_suspend), 875 DEVMETHOD(device_resume, bus_generic_resume), 876 877 /* Bus interface */ 878 DEVMETHOD(bus_add_child, isa_add_child), 879 DEVMETHOD(bus_print_child, isa_print_child), 880 DEVMETHOD(bus_read_ivar, isa_read_ivar), 881 DEVMETHOD(bus_write_ivar, isa_write_ivar), 882 DEVMETHOD(bus_child_detached, isa_child_detached), 883 DEVMETHOD(bus_alloc_resource, isa_alloc_resource), 884 DEVMETHOD(bus_release_resource, isa_release_resource), 885 DEVMETHOD(bus_activate_resource, bus_generic_activate_resource), 886 DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource), 887 DEVMETHOD(bus_setup_intr, isa_setup_intr), 888 DEVMETHOD(bus_teardown_intr, isa_teardown_intr), 889 890 /* ISA interface */ 891 DEVMETHOD(isa_set_resource, isa_set_resource), 892 DEVMETHOD(isa_get_resource, isa_get_resource), 893 DEVMETHOD(isa_delete_resource, isa_delete_resource), 894 DEVMETHOD(isa_add_config, isa_add_config), 895 DEVMETHOD(isa_set_config_callback, isa_set_config_callback), 896 DEVMETHOD(isa_pnp_probe, isa_pnp_probe), 897 898 { 0, 0 } 899 }; 900 901 static driver_t isa_driver = { 902 "isa", 903 isa_methods, 904 1, /* no softc */ 905 }; 906 907 /* 908 * ISA can be attached to a PCI-ISA bridge or directly to the nexus. 909 */ 910 DRIVER_MODULE(isa, isab, isa_driver, isa_devclass, 0, 0); 911 #ifdef __i386__ 912 DRIVER_MODULE(isa, nexus, isa_driver, isa_devclass, 0, 0); 913 #endif 914 915 /* 916 * A fallback driver for reporting un-matched pnp devices. 917 */ 918 919 static int 920 unknown_probe(device_t dev) 921 { 922 /* 923 * Only match pnp devices. 924 */ 925 if (isa_get_vendorid(dev) != 0) 926 return -100; 927 return ENXIO; 928 } 929 930 static int 931 unknown_attach(device_t dev) 932 { 933 return 0; 934 } 935 936 static int 937 unknown_detach(device_t dev) 938 { 939 return 0; 940 } 941 942 static device_method_t unknown_methods[] = { 943 /* Device interface */ 944 DEVMETHOD(device_probe, unknown_probe), 945 DEVMETHOD(device_attach, unknown_attach), 946 DEVMETHOD(device_detach, unknown_detach), 947 948 { 0, 0 } 949 }; 950 951 static driver_t unknown_driver = { 952 "unknown", 953 unknown_methods, 954 1, /* no softc */ 955 }; 956 957 static devclass_t unknown_devclass; 958 959 DRIVER_MODULE(unknown, isa, unknown_driver, unknown_devclass, 0, 0); 960