sys/isa/isa_common.c

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