sys/dev/acpica/acpi_resource.c

   1 /*-
   2  * Copyright (c) 2000 Michael Smith
   3  * Copyright (c) 2000 BSDi
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  */
  27
  28 #include <sys/cdefs.h>
  29 __FBSDID("$FreeBSD$");
  30
  31 #include "opt_acpi.h"
  32 #include <sys/param.h>
  33 #include <sys/kernel.h>
  34 #include <sys/bus.h>
  35 #include <sys/limits.h>
  36 #include <sys/malloc.h>
  37 #include <sys/module.h>
  38
  39 #include <machine/bus.h>
  40 #include <machine/resource.h>
  41 #include <sys/rman.h>
  42
  43 #include <contrib/dev/acpica/include/acpi.h>
  44 #include <contrib/dev/acpica/include/accommon.h>
  45
  46 #include <dev/acpica/acpivar.h>
  47
  48 /* Hooks for the ACPI CA debugging infrastructure */
  49 #define _COMPONENT      ACPI_BUS
  50 ACPI_MODULE_NAME("RESOURCE")
  51
  52 struct lookup_irq_request {
  53     ACPI_RESOURCE *acpi_res;
  54     struct resource *res;
  55     int         counter;
  56     int         rid;
  57     int         found;
  58 };
  59
  60 static ACPI_STATUS
  61 acpi_lookup_irq_handler(ACPI_RESOURCE *res, void *context)
  62 {
  63     struct lookup_irq_request *req;
  64     size_t len;
  65     u_int irqnum, irq;
  66
  67     switch (res->Type) {
  68     case ACPI_RESOURCE_TYPE_IRQ:
  69         irqnum = res->Data.Irq.InterruptCount;
  70         irq = res->Data.Irq.Interrupts[0];
  71         len = ACPI_RS_SIZE(ACPI_RESOURCE_IRQ);
  72         break;
  73     case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
  74         irqnum = res->Data.ExtendedIrq.InterruptCount;
  75         irq = res->Data.ExtendedIrq.Interrupts[0];
  76         len = ACPI_RS_SIZE(ACPI_RESOURCE_EXTENDED_IRQ);
  77         break;
  78     default:
  79         return (AE_OK);
  80     }
  81     if (irqnum != 1)
  82         return (AE_OK);
  83     req = (struct lookup_irq_request *)context;
  84     if (req->counter != req->rid) {
  85         req->counter++;
  86         return (AE_OK);
  87     }
  88     req->found = 1;
  89     KASSERT(irq == rman_get_start(req->res),
  90         ("IRQ resources do not match"));
  91     bcopy(res, req->acpi_res, len);
  92     return (AE_CTRL_TERMINATE);
  93 }
  94
  95 ACPI_STATUS
  96 acpi_lookup_irq_resource(device_t dev, int rid, struct resource *res,
  97     ACPI_RESOURCE *acpi_res)
  98 {
  99     struct lookup_irq_request req;
 100     ACPI_STATUS status;
 101
 102     req.acpi_res = acpi_res;
 103     req.res = res;
 104     req.counter = 0;
 105     req.rid = rid;
 106     req.found = 0;
 107     status = AcpiWalkResources(acpi_get_handle(dev), "_CRS",
 108         acpi_lookup_irq_handler, &req);
 109     if (ACPI_SUCCESS(status) && req.found == 0)
 110         status = AE_NOT_FOUND;
 111     return (status);
 112 }
 113
 114 void
 115 acpi_config_intr(device_t dev, ACPI_RESOURCE *res)
 116 {
 117     u_int irq;
 118     int pol, trig;
 119
 120     switch (res->Type) {
 121     case ACPI_RESOURCE_TYPE_IRQ:
 122         KASSERT(res->Data.Irq.InterruptCount == 1,
 123             ("%s: multiple interrupts", __func__));
 124         irq = res->Data.Irq.Interrupts[0];
 125         trig = res->Data.Irq.Triggering;
 126         pol = res->Data.Irq.Polarity;
 127         break;
 128     case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
 129         KASSERT(res->Data.ExtendedIrq.InterruptCount == 1,
 130             ("%s: multiple interrupts", __func__));
 131         irq = res->Data.ExtendedIrq.Interrupts[0];
 132         trig = res->Data.ExtendedIrq.Triggering;
 133         pol = res->Data.ExtendedIrq.Polarity;
 134         break;
 135     default:
 136         panic("%s: bad resource type %u", __func__, res->Type);
 137     }
 138
 139 #if defined(__amd64__) || defined(__i386__)
 140     /*
 141      * XXX: Certain BIOSes have buggy AML that specify an IRQ that is
 142      * edge-sensitive and active-lo.  However, edge-sensitive IRQs
 143      * should be active-hi.  Force IRQs with an ISA IRQ value to be
 144      * active-hi instead.
 145      */
 146     if (irq < 16 && trig == ACPI_EDGE_SENSITIVE && pol == ACPI_ACTIVE_LOW)
 147         pol = ACPI_ACTIVE_HIGH;
 148 #endif
 149     BUS_CONFIG_INTR(dev, irq, (trig == ACPI_EDGE_SENSITIVE) ?
 150         INTR_TRIGGER_EDGE : INTR_TRIGGER_LEVEL, (pol == ACPI_ACTIVE_HIGH) ?
 151         INTR_POLARITY_HIGH : INTR_POLARITY_LOW);
 152 }
 153
 154 struct acpi_resource_context {
 155     struct acpi_parse_resource_set *set;
 156     device_t    dev;
 157     void        *context;
 158 };
 159
 160 #ifdef ACPI_DEBUG_OUTPUT
 161 static const char *
 162 acpi_address_range_name(UINT8 ResourceType)
 163 {
 164     static char buf[16];
 165
 166     switch (ResourceType) {
 167     case ACPI_MEMORY_RANGE:
 168             return ("Memory");
 169     case ACPI_IO_RANGE:
 170             return ("IO");
 171     case ACPI_BUS_NUMBER_RANGE:
 172             return ("Bus Number");
 173     default:
 174             snprintf(buf, sizeof(buf), "type %u", ResourceType);
 175             return (buf);
 176     }
 177 }
 178 #endif
 179
 180 static ACPI_STATUS
 181 acpi_parse_resource(ACPI_RESOURCE *res, void *context)
 182 {
 183     struct acpi_parse_resource_set *set;
 184     struct acpi_resource_context *arc;
 185     UINT64 min, max, length, gran;
 186 #ifdef ACPI_DEBUG
 187     const char *name;
 188 #endif
 189     device_t dev;
 190
 191     arc = context;
 192     dev = arc->dev;
 193     set = arc->set;
 194
 195     switch (res->Type) {
 196     case ACPI_RESOURCE_TYPE_END_TAG:
 197         ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "EndTag\n"));
 198         break;
 199     case ACPI_RESOURCE_TYPE_FIXED_IO:
 200         if (res->Data.FixedIo.AddressLength <= 0)
 201             break;
 202         ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "FixedIo 0x%x/%d\n",
 203             res->Data.FixedIo.Address, res->Data.FixedIo.AddressLength));
 204         set->set_ioport(dev, arc->context, res->Data.FixedIo.Address,
 205             res->Data.FixedIo.AddressLength);
 206         break;
 207     case ACPI_RESOURCE_TYPE_IO:
 208         if (res->Data.Io.AddressLength <= 0)
 209             break;
 210         if (res->Data.Io.Minimum == res->Data.Io.Maximum) {
 211             ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "Io 0x%x/%d\n",
 212                 res->Data.Io.Minimum, res->Data.Io.AddressLength));
 213             set->set_ioport(dev, arc->context, res->Data.Io.Minimum,
 214                 res->Data.Io.AddressLength);
 215         } else {
 216             ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "Io 0x%x-0x%x/%d\n",
 217                 res->Data.Io.Minimum, res->Data.Io.Maximum,
 218                 res->Data.Io.AddressLength));
 219             set->set_iorange(dev, arc->context, res->Data.Io.Minimum,
 220                 res->Data.Io.Maximum, res->Data.Io.AddressLength,
 221                 res->Data.Io.Alignment);
 222         }
 223         break;
 224     case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
 225         if (res->Data.FixedMemory32.AddressLength <= 0)
 226             break;
 227         ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "FixedMemory32 0x%x/%d\n",
 228             res->Data.FixedMemory32.Address,
 229             res->Data.FixedMemory32.AddressLength));
 230         set->set_memory(dev, arc->context, res->Data.FixedMemory32.Address,
 231             res->Data.FixedMemory32.AddressLength);
 232         break;
 233     case ACPI_RESOURCE_TYPE_MEMORY32:
 234         if (res->Data.Memory32.AddressLength <= 0)
 235             break;
 236         if (res->Data.Memory32.Minimum == res->Data.Memory32.Maximum) {
 237             ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "Memory32 0x%x/%d\n",
 238                 res->Data.Memory32.Minimum, res->Data.Memory32.AddressLength));
 239             set->set_memory(dev, arc->context, res->Data.Memory32.Minimum,
 240                 res->Data.Memory32.AddressLength);
 241         } else {
 242             ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "Memory32 0x%x-0x%x/%d\n",
 243                 res->Data.Memory32.Minimum, res->Data.Memory32.Maximum,
 244                 res->Data.Memory32.AddressLength));
 245             set->set_memoryrange(dev, arc->context, res->Data.Memory32.Minimum,
 246                 res->Data.Memory32.Maximum, res->Data.Memory32.AddressLength,
 247                 res->Data.Memory32.Alignment);
 248         }
 249         break;
 250     case ACPI_RESOURCE_TYPE_MEMORY24:
 251         if (res->Data.Memory24.AddressLength <= 0)
 252             break;
 253         if (res->Data.Memory24.Minimum == res->Data.Memory24.Maximum) {
 254             ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "Memory24 0x%x/%d\n",
 255                 res->Data.Memory24.Minimum, res->Data.Memory24.AddressLength));
 256             set->set_memory(dev, arc->context, res->Data.Memory24.Minimum,
 257                 res->Data.Memory24.AddressLength);
 258         } else {
 259             ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "Memory24 0x%x-0x%x/%d\n",
 260                 res->Data.Memory24.Minimum, res->Data.Memory24.Maximum,
 261                 res->Data.Memory24.AddressLength));
 262             set->set_memoryrange(dev, arc->context, res->Data.Memory24.Minimum,
 263                 res->Data.Memory24.Maximum, res->Data.Memory24.AddressLength,
 264                 res->Data.Memory24.Alignment);
 265         }
 266         break;
 267     case ACPI_RESOURCE_TYPE_IRQ:
 268         /*
 269          * from 1.0b 6.4.2
 270          * "This structure is repeated for each separate interrupt
 271          * required"
 272          */
 273         set->set_irq(dev, arc->context, res->Data.Irq.Interrupts,
 274             res->Data.Irq.InterruptCount, res->Data.Irq.Triggering,
 275             res->Data.Irq.Polarity);
 276         break;
 277     case ACPI_RESOURCE_TYPE_DMA:
 278         /*
 279          * from 1.0b 6.4.3
 280          * "This structure is repeated for each separate DMA channel
 281          * required"
 282          */
 283         set->set_drq(dev, arc->context, res->Data.Dma.Channels,
 284             res->Data.Dma.ChannelCount);
 285         break;
 286     case ACPI_RESOURCE_TYPE_START_DEPENDENT:
 287         ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "start dependent functions\n"));
 288         set->set_start_dependent(dev, arc->context,
 289             res->Data.StartDpf.CompatibilityPriority);
 290         break;
 291     case ACPI_RESOURCE_TYPE_END_DEPENDENT:
 292         ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "end dependent functions\n"));
 293         set->set_end_dependent(dev, arc->context);
 294         break;
 295     case ACPI_RESOURCE_TYPE_ADDRESS16:
 296     case ACPI_RESOURCE_TYPE_ADDRESS32:
 297     case ACPI_RESOURCE_TYPE_ADDRESS64:
 298     case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
 299         switch (res->Type) {
 300         case ACPI_RESOURCE_TYPE_ADDRESS16:
 301             gran = res->Data.Address16.Address.Granularity;
 302             min = res->Data.Address16.Address.Minimum;
 303             max = res->Data.Address16.Address.Maximum;
 304             length = res->Data.Address16.Address.AddressLength;
 305 #ifdef ACPI_DEBUG
 306             name = "Address16";
 307 #endif
 308             break;
 309         case ACPI_RESOURCE_TYPE_ADDRESS32:
 310             gran = res->Data.Address32.Address.Granularity;
 311             min = res->Data.Address32.Address.Minimum;
 312             max = res->Data.Address32.Address.Maximum;
 313             length = res->Data.Address32.Address.AddressLength;
 314 #ifdef ACPI_DEBUG
 315             name = "Address32";
 316 #endif
 317             break;
 318         case ACPI_RESOURCE_TYPE_ADDRESS64:
 319             gran = res->Data.Address64.Address.Granularity;
 320             min = res->Data.Address64.Address.Minimum;
 321             max = res->Data.Address64.Address.Maximum;
 322             length = res->Data.Address64.Address.AddressLength;
 323 #ifdef ACPI_DEBUG
 324             name = "Address64";
 325 #endif
 326             break;
 327         default:
 328             KASSERT(res->Type == ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64,
 329                 ("should never happen"));
 330             gran = res->Data.ExtAddress64.Address.Granularity;
 331             min = res->Data.ExtAddress64.Address.Minimum;
 332             max = res->Data.ExtAddress64.Address.Maximum;
 333             length = res->Data.ExtAddress64.Address.AddressLength;
 334 #ifdef ACPI_DEBUG
 335             name = "ExtAddress64";
 336 #endif
 337             break;
 338         }
 339         if (length <= 0)
 340             break;
 341         if (res->Data.Address.ProducerConsumer != ACPI_CONSUMER) {
 342             ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
 343                 "ignored %s %s producer\n", name,
 344                 acpi_address_range_name(res->Data.Address.ResourceType)));
 345             break;
 346         }
 347         if (res->Data.Address.ResourceType != ACPI_MEMORY_RANGE &&
 348             res->Data.Address.ResourceType != ACPI_IO_RANGE) {
 349             ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
 350                 "ignored %s for non-memory, non-I/O\n", name));
 351             break;
 352         }
 353
 354 #ifdef __i386__
 355         if (min > ULONG_MAX || (res->Data.Address.MaxAddressFixed && max >
 356             ULONG_MAX)) {
 357             ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "ignored %s above 4G\n",
 358                 name));
 359             break;
 360         }
 361         if (max > ULONG_MAX)
 362                 max = ULONG_MAX;
 363 #endif
 364         if (res->Data.Address.MinAddressFixed == ACPI_ADDRESS_FIXED &&
 365             res->Data.Address.MaxAddressFixed == ACPI_ADDRESS_FIXED) {
 366             if (res->Data.Address.ResourceType == ACPI_MEMORY_RANGE) {
 367                 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "%s/Memory 0x%jx/%ju\n",
 368                     name, (uintmax_t)min, (uintmax_t)length));
 369                 set->set_memory(dev, arc->context, min, length);
 370             } else {
 371                 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "%s/IO 0x%jx/%ju\n", name,
 372                     (uintmax_t)min, (uintmax_t)length));
 373                 set->set_ioport(dev, arc->context, min, length);
 374             }
 375         } else {
 376             if (res->Data.Address32.ResourceType == ACPI_MEMORY_RANGE) {
 377                 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
 378                     "%s/Memory 0x%jx-0x%jx/%ju\n", name, (uintmax_t)min,
 379                     (uintmax_t)max, (uintmax_t)length));
 380                 set->set_memoryrange(dev, arc->context, min, max, length, gran);
 381             } else {
 382                 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "%s/IO 0x%jx-0x%jx/%ju\n",
 383                     name, (uintmax_t)min, (uintmax_t)max, (uintmax_t)length));
 384                 set->set_iorange(dev, arc->context, min, max, length, gran);
 385             }
 386         }
 387         break;
 388     case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
 389         if (res->Data.ExtendedIrq.ProducerConsumer != ACPI_CONSUMER) {
 390             ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "ignored ExtIRQ producer\n"));
 391             break;
 392         }
 393         set->set_ext_irq(dev, arc->context, res->Data.ExtendedIrq.Interrupts,
 394             res->Data.ExtendedIrq.InterruptCount,
 395             res->Data.ExtendedIrq.Triggering, res->Data.ExtendedIrq.Polarity);
 396         break;
 397     case ACPI_RESOURCE_TYPE_VENDOR:
 398         ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
 399             "unimplemented VendorSpecific resource\n"));
 400         break;
 401     default:
 402         break;
 403     }
 404     return (AE_OK);
 405 }
 406
 407 /*
 408  * Fetch a device's resources and associate them with the device.
 409  *
 410  * Note that it might be nice to also locate ACPI-specific resource items, such
 411  * as GPE bits.
 412  *
 413  * We really need to split the resource-fetching code out from the
 414  * resource-parsing code, since we may want to use the parsing
 415  * code for _PRS someday.
 416  */
 417 ACPI_STATUS
 418 acpi_parse_resources(device_t dev, ACPI_HANDLE handle,
 419                      struct acpi_parse_resource_set *set, void *arg)
 420 {
 421     struct acpi_resource_context arc;
 422     ACPI_STATUS         status;
 423
 424     ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
 425
 426     set->set_init(dev, arg, &arc.context);
 427     arc.set = set;
 428     arc.dev = dev;
 429     status = AcpiWalkResources(handle, "_CRS", acpi_parse_resource, &arc);
 430     if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
 431         printf("can't fetch resources for %s - %s\n",
 432             acpi_name(handle), AcpiFormatException(status));
 433         return_ACPI_STATUS (status);
 434     }
 435     set->set_done(dev, arc.context);
 436     return_ACPI_STATUS (AE_OK);
 437 }
 438
 439 /*
 440  * Resource-set vectors used to attach _CRS-derived resources
 441  * to an ACPI device.
 442  */
 443 static void     acpi_res_set_init(device_t dev, void *arg, void **context);
 444 static void     acpi_res_set_done(device_t dev, void *context);
 445 static void     acpi_res_set_ioport(device_t dev, void *context,
 446                                     uint64_t base, uint64_t length);
 447 static void     acpi_res_set_iorange(device_t dev, void *context,
 448                                      uint64_t low, uint64_t high,
 449                                      uint64_t length, uint64_t align);
 450 static void     acpi_res_set_memory(device_t dev, void *context,
 451                                     uint64_t base, uint64_t length);
 452 static void     acpi_res_set_memoryrange(device_t dev, void *context,
 453                                          uint64_t low, uint64_t high,
 454                                          uint64_t length, uint64_t align);
 455 static void     acpi_res_set_irq(device_t dev, void *context, uint8_t *irq,
 456                                  int count, int trig, int pol);
 457 static void     acpi_res_set_ext_irq(device_t dev, void *context,
 458                                  uint32_t *irq, int count, int trig, int pol);
 459 static void     acpi_res_set_drq(device_t dev, void *context, uint8_t *drq,
 460                                  int count);
 461 static void     acpi_res_set_start_dependent(device_t dev, void *context,
 462                                              int preference);
 463 static void     acpi_res_set_end_dependent(device_t dev, void *context);
 464
 465 struct acpi_parse_resource_set acpi_res_parse_set = {
 466     acpi_res_set_init,
 467     acpi_res_set_done,
 468     acpi_res_set_ioport,
 469     acpi_res_set_iorange,
 470     acpi_res_set_memory,
 471     acpi_res_set_memoryrange,
 472     acpi_res_set_irq,
 473     acpi_res_set_ext_irq,
 474     acpi_res_set_drq,
 475     acpi_res_set_start_dependent,
 476     acpi_res_set_end_dependent
 477 };
 478
 479 struct acpi_res_context {
 480     int         ar_nio;
 481     int         ar_nmem;
 482     int         ar_nirq;
 483     int         ar_ndrq;
 484     void        *ar_parent;
 485 };
 486
 487 static void
 488 acpi_res_set_init(device_t dev, void *arg, void **context)
 489 {
 490     struct acpi_res_context     *cp;
 491
 492     if ((cp = AcpiOsAllocate(sizeof(*cp))) != NULL) {
 493         bzero(cp, sizeof(*cp));
 494         cp->ar_parent = arg;
 495         *context = cp;
 496     }
 497 }
 498
 499 static void
 500 acpi_res_set_done(device_t dev, void *context)
 501 {
 502     struct acpi_res_context     *cp = (struct acpi_res_context *)context;
 503
 504     if (cp == NULL)
 505         return;
 506     AcpiOsFree(cp);
 507 }
 508
 509 static void
 510 acpi_res_set_ioport(device_t dev, void *context, uint64_t base,
 511                     uint64_t length)
 512 {
 513     struct acpi_res_context     *cp = (struct acpi_res_context *)context;
 514
 515     if (cp == NULL)
 516         return;
 517     bus_set_resource(dev, SYS_RES_IOPORT, cp->ar_nio++, base, length);
 518 }
 519
 520 static void
 521 acpi_res_set_iorange(device_t dev, void *context, uint64_t low,
 522                      uint64_t high, uint64_t length, uint64_t align)
 523 {
 524     struct acpi_res_context     *cp = (struct acpi_res_context *)context;
 525
 526     if (cp == NULL)
 527         return;
 528     device_printf(dev, "I/O range not supported\n");
 529 }
 530
 531 static void
 532 acpi_res_set_memory(device_t dev, void *context, uint64_t base,
 533                     uint64_t length)
 534 {
 535     struct acpi_res_context     *cp = (struct acpi_res_context *)context;
 536
 537     if (cp == NULL)
 538         return;
 539
 540     bus_set_resource(dev, SYS_RES_MEMORY, cp->ar_nmem++, base, length);
 541 }
 542
 543 static void
 544 acpi_res_set_memoryrange(device_t dev, void *context, uint64_t low,
 545                          uint64_t high, uint64_t length, uint64_t align)
 546 {
 547     struct acpi_res_context     *cp = (struct acpi_res_context *)context;
 548
 549     if (cp == NULL)
 550         return;
 551     device_printf(dev, "memory range not supported\n");
 552 }
 553
 554 static void
 555 acpi_res_set_irq(device_t dev, void *context, uint8_t *irq, int count,
 556     int trig, int pol)
 557 {
 558     struct acpi_res_context     *cp = (struct acpi_res_context *)context;
 559
 560     if (cp == NULL || irq == NULL)
 561         return;
 562
 563     /* This implements no resource relocation. */
 564     if (count != 1)
 565         return;
 566
 567     bus_set_resource(dev, SYS_RES_IRQ, cp->ar_nirq++, *irq, 1);
 568 }
 569
 570 static void
 571 acpi_res_set_ext_irq(device_t dev, void *context, uint32_t *irq, int count,
 572     int trig, int pol)
 573 {
 574     struct acpi_res_context     *cp = (struct acpi_res_context *)context;
 575
 576     if (cp == NULL || irq == NULL)
 577         return;
 578
 579     /* This implements no resource relocation. */
 580     if (count != 1)
 581         return;
 582
 583     bus_set_resource(dev, SYS_RES_IRQ, cp->ar_nirq++, *irq, 1);
 584 }
 585
 586 static void
 587 acpi_res_set_drq(device_t dev, void *context, uint8_t *drq, int count)
 588 {
 589     struct acpi_res_context     *cp = (struct acpi_res_context *)context;
 590
 591     if (cp == NULL || drq == NULL)
 592         return;
 593
 594     /* This implements no resource relocation. */
 595     if (count != 1)
 596         return;
 597
 598     bus_set_resource(dev, SYS_RES_DRQ, cp->ar_ndrq++, *drq, 1);
 599 }
 600
 601 static void
 602 acpi_res_set_start_dependent(device_t dev, void *context, int preference)
 603 {
 604     struct acpi_res_context     *cp = (struct acpi_res_context *)context;
 605
 606     if (cp == NULL)
 607         return;
 608     device_printf(dev, "dependent functions not supported\n");
 609 }
 610
 611 static void
 612 acpi_res_set_end_dependent(device_t dev, void *context)
 613 {
 614     struct acpi_res_context     *cp = (struct acpi_res_context *)context;
 615
 616     if (cp == NULL)
 617         return;
 618     device_printf(dev, "dependent functions not supported\n");
 619 }
 620
 621 /*
 622  * Resource-owning placeholders for IO and memory pseudo-devices.
 623  *
 624  * This code allocates system resources that will be used by ACPI
 625  * child devices.  The acpi parent manages these resources through a
 626  * private rman.
 627  */
 628
 629 static int      acpi_sysres_rid = 100;
 630
 631 static int      acpi_sysres_probe(device_t dev);
 632 static int      acpi_sysres_attach(device_t dev);
 633
 634 static device_method_t acpi_sysres_methods[] = {
 635     /* Device interface */
 636     DEVMETHOD(device_probe,     acpi_sysres_probe),
 637     DEVMETHOD(device_attach,    acpi_sysres_attach),
 638
 639     DEVMETHOD_END
 640 };
 641
 642 static driver_t acpi_sysres_driver = {
 643     "acpi_sysresource",
 644     acpi_sysres_methods,
 645     0,
 646 };
 647
 648 static devclass_t acpi_sysres_devclass;
 649 DRIVER_MODULE(acpi_sysresource, acpi, acpi_sysres_driver, acpi_sysres_devclass,
 650     0, 0);
 651 MODULE_DEPEND(acpi_sysresource, acpi, 1, 1, 1);
 652
 653 static int
 654 acpi_sysres_probe(device_t dev)
 655 {
 656     static char *sysres_ids[] = { "PNP0C01", "PNP0C02", NULL };
 657
 658     if (acpi_disabled("sysresource") ||
 659         ACPI_ID_PROBE(device_get_parent(dev), dev, sysres_ids) == NULL)
 660         return (ENXIO);
 661
 662     device_set_desc(dev, "System Resource");
 663     device_quiet(dev);
 664     return (BUS_PROBE_DEFAULT);
 665 }
 666
 667 static int
 668 acpi_sysres_attach(device_t dev)
 669 {
 670     device_t bus;
 671     struct resource_list_entry *bus_rle, *dev_rle;
 672     struct resource_list *bus_rl, *dev_rl;
 673     int done, type;
 674     rman_res_t start, end, count;
 675
 676     /*
 677      * Loop through all current resources to see if the new one overlaps
 678      * any existing ones.  If so, grow the old one up and/or down
 679      * accordingly.  Discard any that are wholly contained in the old.  If
 680      * the resource is unique, add it to the parent.  It will later go into
 681      * the rman pool.
 682      */
 683     bus = device_get_parent(dev);
 684     dev_rl = BUS_GET_RESOURCE_LIST(bus, dev);
 685     bus_rl = BUS_GET_RESOURCE_LIST(device_get_parent(bus), bus);
 686     STAILQ_FOREACH(dev_rle, dev_rl, link) {
 687         if (dev_rle->type != SYS_RES_IOPORT && dev_rle->type != SYS_RES_MEMORY)
 688             continue;
 689
 690         start = dev_rle->start;
 691         end = dev_rle->end;
 692         count = dev_rle->count;
 693         type = dev_rle->type;
 694         done = FALSE;
 695
 696         STAILQ_FOREACH(bus_rle, bus_rl, link) {
 697             if (bus_rle->type != type)
 698                 continue;
 699
 700             /* New resource wholly contained in old, discard. */
 701             if (start >= bus_rle->start && end <= bus_rle->end)
 702                 break;
 703
 704             /* New tail overlaps old head, grow existing resource downward. */
 705             if (start < bus_rle->start && end >= bus_rle->start) {
 706                 bus_rle->count += bus_rle->start - start;
 707                 bus_rle->start = start;
 708                 done = TRUE;
 709             }
 710
 711             /* New head overlaps old tail, grow existing resource upward. */
 712             if (start <= bus_rle->end && end > bus_rle->end) {
 713                 bus_rle->count += end - bus_rle->end;
 714                 bus_rle->end = end;
 715                 done = TRUE;
 716             }
 717
 718             /* If we adjusted the old resource, we're finished. */
 719             if (done)
 720                 break;
 721         }
 722
 723         /* If we didn't merge with anything, add this resource. */
 724         if (bus_rle == NULL)
 725             bus_set_resource(bus, type, acpi_sysres_rid++, start, count);
 726     }
 727
 728     /* After merging/moving resources to the parent, free the list. */
 729     resource_list_free(dev_rl);
 730
 731     return (0);
 732 }