The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/dev/acpica/acpi_resource.c

Version: -  FREEBSD  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

    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  * $FreeBSD: src/sys/dev/acpica/acpi_resource.c,v 1.40.8.1 2009/04/15 03:14:26 kensmith Exp $
   28  */
   29 
   30 #include "opt_acpi.h"
   31 #include <sys/param.h>
   32 #include <sys/kernel.h>
   33 #include <sys/bus.h>
   34 #include <sys/malloc.h>
   35 #include <sys/module.h>
   36 #include <sys/resource.h>
   37 #include <sys/machintr.h>
   38 
   39 #include <sys/rman.h>
   40 
   41 #include "acpi.h"
   42 #include <dev/acpica/acpivar.h>
   43 
   44 /* Hooks for the ACPI CA debugging infrastructure */
   45 #define _COMPONENT      ACPI_BUS
   46 ACPI_MODULE_NAME("RESOURCE")
   47 
   48 struct lookup_irq_request {
   49     ACPI_RESOURCE *acpi_res;
   50     struct resource *res;
   51     int         counter;
   52     int         rid;
   53     int         found;
   54 };
   55 
   56 static ACPI_STATUS
   57 acpi_lookup_irq_handler(ACPI_RESOURCE *res, void *context)
   58 {
   59     struct lookup_irq_request *req;
   60     size_t len;
   61     u_int irqnum;
   62     u_int irq __debugvar;
   63 
   64     switch (res->Type) {
   65     case ACPI_RESOURCE_TYPE_IRQ:
   66         irqnum = res->Data.Irq.InterruptCount;
   67         irq = res->Data.Irq.Interrupts[0];
   68         len = ACPI_RS_SIZE(ACPI_RESOURCE_IRQ);
   69         break;
   70     case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
   71         irqnum = res->Data.ExtendedIrq.InterruptCount;
   72         irq = res->Data.ExtendedIrq.Interrupts[0];
   73         len = ACPI_RS_SIZE(ACPI_RESOURCE_EXTENDED_IRQ);
   74         break;
   75     default:
   76         return (AE_OK);
   77     }
   78     if (irqnum != 1)
   79         return (AE_OK);
   80     req = (struct lookup_irq_request *)context;
   81     if (req->counter != req->rid) {
   82         req->counter++;
   83         return (AE_OK);
   84     }
   85     req->found = 1;
   86     KASSERT(irq == rman_get_start(req->res),
   87         ("IRQ resources do not match"));
   88     bcopy(res, req->acpi_res, len);
   89     return (AE_CTRL_TERMINATE);
   90 }
   91 
   92 ACPI_STATUS
   93 acpi_lookup_irq_resource(device_t dev, int rid, struct resource *res,
   94     ACPI_RESOURCE *acpi_res)
   95 {
   96     struct lookup_irq_request req;
   97     ACPI_STATUS status;
   98 
   99     req.acpi_res = acpi_res;
  100     req.res = res;
  101     req.counter = 0;
  102     req.rid = rid;
  103     req.found = 0;
  104     status = AcpiWalkResources(acpi_get_handle(dev), "_CRS",
  105         acpi_lookup_irq_handler, &req);
  106     if (ACPI_SUCCESS(status) && req.found == 0)
  107         status = AE_NOT_FOUND;
  108     return (status);
  109 }
  110 
  111 void
  112 acpi_config_intr(device_t dev, ACPI_RESOURCE *res)
  113 {
  114     u_int irq;
  115     int pol, trig;
  116     enum intr_trigger trigger;
  117     enum intr_polarity polarity;
  118 
  119     switch (res->Type) {
  120     case ACPI_RESOURCE_TYPE_IRQ:
  121         KASSERT(res->Data.Irq.InterruptCount == 1,
  122             ("%s: multiple interrupts", __func__));
  123         irq = res->Data.Irq.Interrupts[0];
  124         trig = res->Data.Irq.Triggering;
  125         pol = res->Data.Irq.Polarity;
  126         break;
  127     case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
  128         KASSERT(res->Data.ExtendedIrq.InterruptCount == 1,
  129             ("%s: multiple interrupts", __func__));
  130         irq = res->Data.ExtendedIrq.Interrupts[0];
  131         trig = res->Data.ExtendedIrq.Triggering;
  132         pol = res->Data.ExtendedIrq.Polarity;
  133         break;
  134     default:
  135         panic("%s: bad resource type %u", __func__, res->Type);
  136     }
  137 
  138     if (trig == ACPI_EDGE_SENSITIVE)
  139         trigger = INTR_TRIGGER_EDGE;
  140     else
  141         trigger = INTR_TRIGGER_LEVEL;
  142 
  143     if (pol == ACPI_ACTIVE_HIGH)
  144         polarity = INTR_POLARITY_HIGH;
  145     else
  146         polarity = INTR_POLARITY_LOW;
  147 
  148     if (machintr_legacy_intr_find(irq, trigger, polarity) < 0)
  149         kprintf("acpi_config_intr: Skip irq %d config\n", irq);
  150     else
  151         BUS_CONFIG_INTR(dev, dev, irq, trigger, polarity);
  152 }
  153 
  154 /*
  155  * Fetch a device's resources and associate them with the device.
  156  *
  157  * Note that it might be nice to also locate ACPI-specific resource items, such
  158  * as GPE bits.
  159  *
  160  * We really need to split the resource-fetching code out from the
  161  * resource-parsing code, since we may want to use the parsing
  162  * code for _PRS someday.
  163  */
  164 ACPI_STATUS
  165 acpi_parse_resources(device_t dev, ACPI_HANDLE handle,
  166                      struct acpi_parse_resource_set *set, void *arg)
  167 {
  168     ACPI_BUFFER         buf;
  169     ACPI_RESOURCE       *res;
  170     char                *curr, *last;
  171     ACPI_STATUS         status;
  172     void                *context;
  173 
  174     ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
  175 
  176     /*
  177      * Special-case some devices that abuse _PRS/_CRS to mean
  178      * something other than "I consume this resource".
  179      *
  180      * XXX do we really need this?  It's only relevant once
  181      *     we start always-allocating these resources, and even
  182      *     then, the only special-cased device is likely to be
  183      *     the PCI interrupt link.
  184      */
  185 
  186     /* Fetch the device's current resources. */
  187     buf.Length = ACPI_ALLOCATE_BUFFER;
  188     if (ACPI_FAILURE((status = AcpiGetCurrentResources(handle, &buf)))) {
  189         if (status != AE_NOT_FOUND && status != AE_TYPE)
  190             kprintf("can't fetch resources for %s - %s\n",
  191                    acpi_name(handle), AcpiFormatException(status));
  192         return_ACPI_STATUS (status);
  193     }
  194     ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "%s - got %ld bytes of resources\n",
  195                      acpi_name(handle), (long)buf.Length));
  196     set->set_init(dev, arg, &context);
  197 
  198     /* Iterate through the resources */
  199     curr = buf.Pointer;
  200     last = (char *)buf.Pointer + buf.Length;
  201     while (curr < last) {
  202         res = (ACPI_RESOURCE *)curr;
  203         curr += res->Length;
  204 
  205         /* Handle the individual resource types */
  206         switch(res->Type) {
  207         case ACPI_RESOURCE_TYPE_END_TAG:
  208             ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "EndTag\n"));
  209             curr = last;
  210             break;
  211         case ACPI_RESOURCE_TYPE_FIXED_IO:
  212             if (res->Data.FixedIo.AddressLength <= 0)
  213                 break;
  214             ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "FixedIo 0x%x/%d\n",
  215                              res->Data.FixedIo.Address,
  216                              res->Data.FixedIo.AddressLength));
  217             set->set_ioport(dev, context,
  218                             res->Data.FixedIo.Address,
  219                             res->Data.FixedIo.AddressLength);
  220             break;
  221         case ACPI_RESOURCE_TYPE_IO:
  222             if (res->Data.Io.AddressLength <= 0)
  223                 break;
  224             if (res->Data.Io.Minimum == res->Data.Io.Maximum) {
  225                 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "Io 0x%x/%d\n",
  226                                  res->Data.Io.Minimum,
  227                                  res->Data.Io.AddressLength));
  228                 set->set_ioport(dev, context,
  229                                 res->Data.Io.Minimum,
  230                                 res->Data.Io.AddressLength);
  231             } else {
  232                 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "Io 0x%x-0x%x/%d\n",
  233                                  res->Data.Io.Minimum,
  234                                  res->Data.Io.Maximum, 
  235                                  res->Data.Io.AddressLength));
  236                 set->set_iorange(dev, context,
  237                                  res->Data.Io.Minimum,
  238                                  res->Data.Io.Maximum, 
  239                                  res->Data.Io.AddressLength,
  240                                  res->Data.Io.Alignment);
  241             }
  242             break;
  243         case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
  244             if (res->Data.FixedMemory32.AddressLength <= 0)
  245                 break;
  246             ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "FixedMemory32 0x%x/%d\n",
  247                               res->Data.FixedMemory32.Address, 
  248                               res->Data.FixedMemory32.AddressLength));
  249             set->set_memory(dev, context,
  250                             res->Data.FixedMemory32.Address, 
  251                             res->Data.FixedMemory32.AddressLength);
  252             break;
  253         case ACPI_RESOURCE_TYPE_MEMORY32:
  254             if (res->Data.Memory32.AddressLength <= 0)
  255                 break;
  256             if (res->Data.Memory32.Minimum ==
  257                 res->Data.Memory32.Maximum) {
  258 
  259                 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "Memory32 0x%x/%d\n",
  260                                   res->Data.Memory32.Minimum, 
  261                                   res->Data.Memory32.AddressLength));
  262                 set->set_memory(dev, context,
  263                                 res->Data.Memory32.Minimum,
  264                                 res->Data.Memory32.AddressLength);
  265             } else {
  266                 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "Memory32 0x%x-0x%x/%d\n",
  267                                  res->Data.Memory32.Minimum, 
  268                                  res->Data.Memory32.Maximum,
  269                                  res->Data.Memory32.AddressLength));
  270                 set->set_memoryrange(dev, context,
  271                                      res->Data.Memory32.Minimum,
  272                                      res->Data.Memory32.Maximum,
  273                                      res->Data.Memory32.AddressLength,
  274                                      res->Data.Memory32.Alignment);
  275             }
  276             break;
  277         case ACPI_RESOURCE_TYPE_MEMORY24:
  278             if (res->Data.Memory24.AddressLength <= 0)
  279                 break;
  280             if (res->Data.Memory24.Minimum ==
  281                 res->Data.Memory24.Maximum) {
  282 
  283                 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "Memory24 0x%x/%d\n",
  284                                  res->Data.Memory24.Minimum, 
  285                                  res->Data.Memory24.AddressLength));
  286                 set->set_memory(dev, context, res->Data.Memory24.Minimum,
  287                                 res->Data.Memory24.AddressLength);
  288             } else {
  289                 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "Memory24 0x%x-0x%x/%d\n",
  290                                  res->Data.Memory24.Minimum, 
  291                                  res->Data.Memory24.Maximum,
  292                                  res->Data.Memory24.AddressLength));
  293                 set->set_memoryrange(dev, context,
  294                                      res->Data.Memory24.Minimum,
  295                                      res->Data.Memory24.Maximum,
  296                                      res->Data.Memory24.AddressLength,
  297                                      res->Data.Memory24.Alignment);
  298             }
  299             break;
  300         case ACPI_RESOURCE_TYPE_IRQ:
  301             /*
  302              * from 1.0b 6.4.2 
  303              * "This structure is repeated for each separate interrupt
  304              * required"
  305              */
  306             set->set_irq(dev, context, res->Data.Irq.Interrupts,
  307                 res->Data.Irq.InterruptCount, res->Data.Irq.Triggering,
  308                 res->Data.Irq.Polarity);
  309             break;
  310         case ACPI_RESOURCE_TYPE_DMA:
  311             /*
  312              * from 1.0b 6.4.3 
  313              * "This structure is repeated for each separate dma channel
  314              * required"
  315              */
  316             set->set_drq(dev, context, res->Data.Dma.Channels,
  317                          res->Data.Dma.ChannelCount);
  318             break;
  319         case ACPI_RESOURCE_TYPE_START_DEPENDENT:
  320             ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "start dependent functions\n"));
  321             set->set_start_dependent(dev, context,
  322                                      res->Data.StartDpf.CompatibilityPriority);
  323             break;
  324         case ACPI_RESOURCE_TYPE_END_DEPENDENT:
  325             ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "end dependent functions\n"));
  326             set->set_end_dependent(dev, context);
  327             break;
  328         case ACPI_RESOURCE_TYPE_ADDRESS32:
  329             if (res->Data.Address32.AddressLength <= 0)
  330                 break;
  331             if (res->Data.Address32.ProducerConsumer != ACPI_CONSUMER) {
  332                 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
  333                     "ignored Address32 %s producer\n",
  334                     res->Data.Address32.ResourceType == ACPI_IO_RANGE ?
  335                     "IO" : "Memory"));
  336                 break;
  337             }
  338             if (res->Data.Address32.ResourceType != ACPI_MEMORY_RANGE &&
  339                 res->Data.Address32.ResourceType != ACPI_IO_RANGE) {
  340                 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
  341                     "ignored Address32 for non-memory, non-I/O\n"));
  342                 break;
  343             }
  344 
  345             if (res->Data.Address32.MinAddressFixed == ACPI_ADDRESS_FIXED &&
  346                 res->Data.Address32.MaxAddressFixed == ACPI_ADDRESS_FIXED) {
  347 
  348                 if (res->Data.Address32.ResourceType == ACPI_MEMORY_RANGE) {
  349                     ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
  350                                      "Address32/Memory 0x%x/%d\n",
  351                                      res->Data.Address32.Minimum,
  352                                      res->Data.Address32.AddressLength));
  353                     set->set_memory(dev, context,
  354                                     res->Data.Address32.Minimum,
  355                                     res->Data.Address32.AddressLength);
  356                 } else {
  357                     ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
  358                                      "Address32/IO 0x%x/%d\n",
  359                                      res->Data.Address32.Minimum,
  360                                      res->Data.Address32.AddressLength));
  361                     set->set_ioport(dev, context,
  362                                     res->Data.Address32.Minimum,
  363                                     res->Data.Address32.AddressLength);
  364                 }
  365             } else {
  366                 if (res->Data.Address32.ResourceType == ACPI_MEMORY_RANGE) {
  367                     ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
  368                                      "Address32/Memory 0x%x-0x%x/%d\n",
  369                                      res->Data.Address32.Minimum,
  370                                      res->Data.Address32.Maximum,
  371                                      res->Data.Address32.AddressLength));
  372                     set->set_memoryrange(dev, context,
  373                                           res->Data.Address32.Minimum,
  374                                           res->Data.Address32.Maximum,
  375                                           res->Data.Address32.AddressLength,
  376                                           res->Data.Address32.Granularity);
  377                 } else {
  378                     ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
  379                                      "Address32/IO 0x%x-0x%x/%d\n",
  380                                      res->Data.Address32.Minimum,
  381                                      res->Data.Address32.Maximum,
  382                                      res->Data.Address32.AddressLength));
  383                     set->set_iorange(dev, context,
  384                                      res->Data.Address32.Minimum,
  385                                      res->Data.Address32.Maximum,
  386                                      res->Data.Address32.AddressLength,
  387                                      res->Data.Address32.Granularity);
  388                 }
  389             }               
  390             break;
  391         case ACPI_RESOURCE_TYPE_ADDRESS16:
  392             if (res->Data.Address16.AddressLength <= 0)
  393                 break;
  394             if (res->Data.Address16.ProducerConsumer != ACPI_CONSUMER) {
  395                 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
  396                     "ignored Address16 %s producer\n",
  397                     res->Data.Address16.ResourceType == ACPI_IO_RANGE ?
  398                     "IO" : "Memory"));
  399                 break;
  400             }
  401             if (res->Data.Address16.ResourceType != ACPI_MEMORY_RANGE &&
  402                 res->Data.Address16.ResourceType != ACPI_IO_RANGE) {
  403                 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
  404                         "ignored Address16 for non-memory, non-I/O\n"));
  405                 break;
  406             }
  407 
  408             if (res->Data.Address16.MinAddressFixed == ACPI_ADDRESS_FIXED &&
  409                 res->Data.Address16.MaxAddressFixed == ACPI_ADDRESS_FIXED) {
  410 
  411                 if (res->Data.Address16.ResourceType == ACPI_MEMORY_RANGE) {
  412                     ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
  413                                      "Address16/Memory 0x%x/%d\n",
  414                                      res->Data.Address16.Minimum,
  415                                      res->Data.Address16.AddressLength));
  416                     set->set_memory(dev, context,
  417                                     res->Data.Address16.Minimum,
  418                                     res->Data.Address16.AddressLength);
  419                 } else {
  420                     ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
  421                                      "Address16/IO 0x%x/%d\n",
  422                                      res->Data.Address16.Minimum,
  423                                      res->Data.Address16.AddressLength));
  424                     set->set_ioport(dev, context,
  425                                     res->Data.Address16.Minimum,
  426                                     res->Data.Address16.AddressLength);
  427                 }
  428             } else {
  429                 if (res->Data.Address16.ResourceType == ACPI_MEMORY_RANGE) {
  430                     ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
  431                                      "Address16/Memory 0x%x-0x%x/%d\n",
  432                                      res->Data.Address16.Minimum,
  433                                      res->Data.Address16.Maximum,
  434                                      res->Data.Address16.AddressLength));
  435                     set->set_memoryrange(dev, context,
  436                                           res->Data.Address16.Minimum,
  437                                           res->Data.Address16.Maximum,
  438                                           res->Data.Address16.AddressLength,
  439                                           res->Data.Address16.Granularity);
  440                 } else {
  441                     ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
  442                                      "Address16/IO 0x%x-0x%x/%d\n",
  443                                      res->Data.Address16.Minimum,
  444                                      res->Data.Address16.Maximum,
  445                                      res->Data.Address16.AddressLength));
  446                     set->set_iorange(dev, context,
  447                                      res->Data.Address16.Minimum,
  448                                      res->Data.Address16.Maximum,
  449                                      res->Data.Address16.AddressLength,
  450                                      res->Data.Address16.Granularity);
  451                 }
  452             }               
  453             break;
  454         case ACPI_RESOURCE_TYPE_ADDRESS64:
  455             ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
  456                              "unimplemented Address64 resource\n"));
  457             break;
  458         case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
  459             if (res->Data.ExtendedIrq.ProducerConsumer != ACPI_CONSUMER) {
  460                 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
  461                     "ignored ExtIRQ producer\n"));
  462                 break;
  463             }
  464             set->set_ext_irq(dev, context, res->Data.ExtendedIrq.Interrupts,
  465                 res->Data.ExtendedIrq.InterruptCount,
  466                 res->Data.ExtendedIrq.Triggering,
  467                 res->Data.ExtendedIrq.Polarity);
  468             break;
  469         case ACPI_RESOURCE_TYPE_VENDOR:
  470             ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
  471                              "unimplemented VendorSpecific resource\n"));
  472             break;
  473         default:
  474             break;
  475         }
  476     }    
  477 
  478     AcpiOsFree(buf.Pointer);
  479     set->set_done(dev, context);
  480     return_ACPI_STATUS (AE_OK);
  481 }
  482 
  483 /*
  484  * Resource-set vectors used to attach _CRS-derived resources 
  485  * to an ACPI device.
  486  */
  487 static void     acpi_res_set_init(device_t dev, void *arg, void **context);
  488 static void     acpi_res_set_done(device_t dev, void *context);
  489 static void     acpi_res_set_ioport(device_t dev, void *context,
  490                                     u_int32_t base, u_int32_t length);
  491 static void     acpi_res_set_iorange(device_t dev, void *context,
  492                                      u_int32_t low, u_int32_t high, 
  493                                      u_int32_t length, u_int32_t align);
  494 static void     acpi_res_set_memory(device_t dev, void *context,
  495                                     u_int32_t base, u_int32_t length);
  496 static void     acpi_res_set_memoryrange(device_t dev, void *context,
  497                                          u_int32_t low, u_int32_t high, 
  498                                          u_int32_t length, u_int32_t align);
  499 static void     acpi_res_set_irq(device_t dev, void *context, u_int8_t *irq,
  500                                  int count, int trig, int pol);
  501 static void     acpi_res_set_ext_irq(device_t dev, void *context,
  502                                  u_int32_t *irq, int count, int trig, int pol);
  503 static void     acpi_res_set_drq(device_t dev, void *context, u_int8_t *drq,
  504                                  int count);
  505 static void     acpi_res_set_start_dependent(device_t dev, void *context,
  506                                              int preference);
  507 static void     acpi_res_set_end_dependent(device_t dev, void *context);
  508 
  509 struct acpi_parse_resource_set acpi_res_parse_set = {
  510     acpi_res_set_init,
  511     acpi_res_set_done,
  512     acpi_res_set_ioport,
  513     acpi_res_set_iorange,
  514     acpi_res_set_memory,
  515     acpi_res_set_memoryrange,
  516     acpi_res_set_irq,
  517     acpi_res_set_ext_irq,
  518     acpi_res_set_drq,
  519     acpi_res_set_start_dependent,
  520     acpi_res_set_end_dependent
  521 };
  522 
  523 struct acpi_res_context {
  524     int         ar_nio;
  525     int         ar_nmem;
  526     int         ar_nirq;
  527     int         ar_ndrq;
  528     void        *ar_parent;
  529 };
  530 
  531 static void
  532 acpi_res_set_init(device_t dev, void *arg, void **context)
  533 {
  534     struct acpi_res_context     *cp;
  535 
  536     if ((cp = AcpiOsAllocate(sizeof(*cp))) != NULL) {
  537         bzero(cp, sizeof(*cp));
  538         cp->ar_parent = arg;
  539         *context = cp;
  540     }
  541 }
  542 
  543 static void
  544 acpi_res_set_done(device_t dev, void *context)
  545 {
  546     struct acpi_res_context     *cp = (struct acpi_res_context *)context;
  547 
  548     if (cp == NULL)
  549         return;
  550     AcpiOsFree(cp);
  551 }
  552 
  553 static void
  554 acpi_res_set_ioport(device_t dev, void *context, u_int32_t base,
  555                     u_int32_t length)
  556 {
  557     struct acpi_res_context     *cp = (struct acpi_res_context *)context;
  558 
  559     if (cp == NULL)
  560         return;
  561     bus_set_resource(dev, SYS_RES_IOPORT, cp->ar_nio++, base, length, -1);
  562 }
  563 
  564 static void
  565 acpi_res_set_iorange(device_t dev, void *context, u_int32_t low,
  566                      u_int32_t high, u_int32_t length, u_int32_t align)
  567 {
  568     struct acpi_res_context     *cp = (struct acpi_res_context *)context;
  569 
  570     if (cp == NULL)
  571         return;
  572     device_printf(dev, "I/O range not supported\n");
  573 }
  574 
  575 static void
  576 acpi_res_set_memory(device_t dev, void *context, u_int32_t base,
  577                     u_int32_t length)
  578 {
  579     struct acpi_res_context     *cp = (struct acpi_res_context *)context;
  580 
  581     if (cp == NULL)
  582         return;
  583 
  584     bus_set_resource(dev, SYS_RES_MEMORY, cp->ar_nmem++, base, length, -1);
  585 }
  586 
  587 static void
  588 acpi_res_set_memoryrange(device_t dev, void *context, u_int32_t low,
  589                          u_int32_t high, u_int32_t length, u_int32_t align)
  590 {
  591     struct acpi_res_context     *cp = (struct acpi_res_context *)context;
  592 
  593     if (cp == NULL)
  594         return;
  595     device_printf(dev, "memory range not supported\n");
  596 }
  597 
  598 static void
  599 acpi_res_set_irq(device_t dev, void *context, u_int8_t *irq, int count,
  600     int trig, int pol)
  601 {
  602     struct acpi_res_context     *cp = (struct acpi_res_context *)context;
  603 
  604     if (cp == NULL || irq == NULL)
  605         return;
  606 
  607     /* This implements no resource relocation. */
  608     if (count != 1)
  609         return;
  610 
  611     bus_set_resource(dev, SYS_RES_IRQ, cp->ar_nirq++, *irq, 1,
  612         machintr_legacy_intr_cpuid(*irq));
  613 }
  614 
  615 static void
  616 acpi_res_set_ext_irq(device_t dev, void *context, u_int32_t *irq, int count,
  617     int trig, int pol)
  618 {
  619     struct acpi_res_context     *cp = (struct acpi_res_context *)context;
  620 
  621     if (cp == NULL || irq == NULL)
  622         return;
  623 
  624     /* This implements no resource relocation. */
  625     if (count != 1)
  626         return;
  627 
  628     bus_set_resource(dev, SYS_RES_IRQ, cp->ar_nirq++, *irq, 1,
  629         machintr_legacy_intr_cpuid(*irq));
  630 }
  631 
  632 static void
  633 acpi_res_set_drq(device_t dev, void *context, u_int8_t *drq, int count)
  634 {
  635     struct acpi_res_context     *cp = (struct acpi_res_context *)context;
  636 
  637     if (cp == NULL || drq == NULL)
  638         return;
  639     
  640     /* This implements no resource relocation. */
  641     if (count != 1)
  642         return;
  643 
  644     bus_set_resource(dev, SYS_RES_DRQ, cp->ar_ndrq++, *drq, 1, -1);
  645 }
  646 
  647 static void
  648 acpi_res_set_start_dependent(device_t dev, void *context, int preference)
  649 {
  650     struct acpi_res_context     *cp = (struct acpi_res_context *)context;
  651 
  652     if (cp == NULL)
  653         return;
  654     device_printf(dev, "dependent functions not supported\n");
  655 }
  656 
  657 static void
  658 acpi_res_set_end_dependent(device_t dev, void *context)
  659 {
  660     struct acpi_res_context     *cp = (struct acpi_res_context *)context;
  661 
  662     if (cp == NULL)
  663         return;
  664     device_printf(dev, "dependent functions not supported\n");
  665 }
  666 
  667 /*
  668  * Resource-owning placeholders for IO and memory pseudo-devices.
  669  *
  670  * This code allocates system resources that will be used by ACPI
  671  * child devices.  The acpi parent manages these resources through a
  672  * private rman.
  673  */
  674 
  675 static int      acpi_sysres_rid = 100;
  676 
  677 static int      acpi_sysres_probe(device_t dev);
  678 static int      acpi_sysres_attach(device_t dev);
  679 
  680 static device_method_t acpi_sysres_methods[] = {
  681     /* Device interface */
  682     DEVMETHOD(device_probe,     acpi_sysres_probe),
  683     DEVMETHOD(device_attach,    acpi_sysres_attach),
  684 
  685     DEVMETHOD_END
  686 };
  687 
  688 static driver_t acpi_sysres_driver = {
  689     "acpi_sysresource",
  690     acpi_sysres_methods,
  691     0,
  692 };
  693 
  694 static devclass_t acpi_sysres_devclass;
  695 DRIVER_MODULE(acpi_sysresource, acpi, acpi_sysres_driver, acpi_sysres_devclass,
  696     0, 0);
  697 MODULE_DEPEND(acpi_sysresource, acpi, 1, 1, 1);
  698 
  699 static int
  700 acpi_sysres_probe(device_t dev)
  701 {
  702     static char *sysres_ids[] = { "PNP0C01", "PNP0C02", NULL };
  703 
  704     if (acpi_disabled("sysresource") ||
  705         ACPI_ID_PROBE(device_get_parent(dev), dev, sysres_ids) == NULL)
  706         return (ENXIO);
  707 
  708     device_set_desc(dev, "System Resource");
  709     device_quiet(dev);
  710     return (BUS_PROBE_DEFAULT);
  711 }
  712 
  713 static int
  714 acpi_sysres_attach(device_t dev)
  715 {
  716     device_t bus;
  717     struct resource_list_entry *bus_rle, *dev_rle;
  718     struct resource_list *bus_rl, *dev_rl;
  719     int done, type;
  720     u_long start, end, count;
  721     /*
  722      * Loop through all current resources to see if the new one overlaps
  723      * any existing ones.  If so, grow the old one up and/or down
  724      * accordingly.  Discard any that are wholly contained in the old.  If
  725      * the resource is unique, add it to the parent.  It will later go into
  726      * the rman pool.
  727      */
  728     bus = device_get_parent(dev);
  729     dev_rl = BUS_GET_RESOURCE_LIST(bus, dev);
  730     bus_rl = BUS_GET_RESOURCE_LIST(device_get_parent(bus), bus);
  731     if(bus_rl)
  732         kprintf("busrl is not null!\n");
  733         SLIST_FOREACH(dev_rle, dev_rl, link) {
  734         if (dev_rle->type != SYS_RES_IOPORT && dev_rle->type != SYS_RES_MEMORY)
  735             continue;
  736 
  737         start = dev_rle->start;
  738         end = dev_rle->end;
  739         count = dev_rle->count;
  740         type = dev_rle->type;
  741         done = FALSE;
  742         if(bus_rl) {
  743         SLIST_FOREACH(bus_rle, bus_rl, link) {
  744             if (bus_rle->type != type)
  745                 continue;
  746 
  747             /* New resource wholly contained in old, discard. */
  748             if (start >= bus_rle->start && end <= bus_rle->end)
  749                 break;
  750 
  751             /* New tail overlaps old head, grow existing resource downward. */
  752             if (start < bus_rle->start && end >= bus_rle->start) {
  753                 bus_rle->count += bus_rle->start - start;
  754                 bus_rle->start = start;
  755                 done = TRUE;
  756             }
  757 
  758             /* New head overlaps old tail, grow existing resource upward. */
  759             if (start <= bus_rle->end && end > bus_rle->end) {
  760                 bus_rle->count += end - bus_rle->end;
  761                 bus_rle->end = end;
  762                 done = TRUE;
  763             }
  764 
  765             /* If we adjusted the old resource, we're finished. */
  766             if (done)
  767                 break;
  768         }
  769         } else bus_rle = NULL;
  770         /* If we didn't merge with anything, add this resource. */
  771         if (bus_rle == NULL) {
  772             bus_set_resource(bus, type, acpi_sysres_rid++, start, count, -1);
  773         }
  774     }
  775 
  776     /* After merging/moving resources to the parent, free the list. */
  777     resource_list_free(dev_rl);
  778 
  779     return (0);
  780 }

Cache object: b216bc6b2b76ccc1e633e13010ec4e89


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.