sys/isa/isa_common.c

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