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