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_ec.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
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: releng/5.0/sys/dev/acpica/acpi_ec.c 107328 2002-11-27 18:09:20Z iwasaki $
   28  */
   29 /******************************************************************************
   30  *
   31  * 1. Copyright Notice
   32  *
   33  * Some or all of this work - Copyright (c) 1999, Intel Corp.  All rights
   34  * reserved.
   35  *
   36  * 2. License
   37  *
   38  * 2.1. This is your license from Intel Corp. under its intellectual property
   39  * rights.  You may have additional license terms from the party that provided
   40  * you this software, covering your right to use that party's intellectual
   41  * property rights.
   42  *
   43  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
   44  * copy of the source code appearing in this file ("Covered Code") an
   45  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
   46  * base code distributed originally by Intel ("Original Intel Code") to copy,
   47  * make derivatives, distribute, use and display any portion of the Covered
   48  * Code in any form, with the right to sublicense such rights; and
   49  *
   50  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
   51  * license (with the right to sublicense), under only those claims of Intel
   52  * patents that are infringed by the Original Intel Code, to make, use, sell,
   53  * offer to sell, and import the Covered Code and derivative works thereof
   54  * solely to the minimum extent necessary to exercise the above copyright
   55  * license, and in no event shall the patent license extend to any additions
   56  * to or modifications of the Original Intel Code.  No other license or right
   57  * is granted directly or by implication, estoppel or otherwise;
   58  *
   59  * The above copyright and patent license is granted only if the following
   60  * conditions are met:
   61  *
   62  * 3. Conditions 
   63  *
   64  * 3.1. Redistribution of Source with Rights to Further Distribute Source.  
   65  * Redistribution of source code of any substantial portion of the Covered
   66  * Code or modification with rights to further distribute source must include
   67  * the above Copyright Notice, the above License, this list of Conditions,
   68  * and the following Disclaimer and Export Compliance provision.  In addition,
   69  * Licensee must cause all Covered Code to which Licensee contributes to
   70  * contain a file documenting the changes Licensee made to create that Covered
   71  * Code and the date of any change.  Licensee must include in that file the
   72  * documentation of any changes made by any predecessor Licensee.  Licensee 
   73  * must include a prominent statement that the modification is derived,
   74  * directly or indirectly, from Original Intel Code.
   75  *
   76  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.  
   77  * Redistribution of source code of any substantial portion of the Covered
   78  * Code or modification without rights to further distribute source must
   79  * include the following Disclaimer and Export Compliance provision in the
   80  * documentation and/or other materials provided with distribution.  In
   81  * addition, Licensee may not authorize further sublicense of source of any
   82  * portion of the Covered Code, and must include terms to the effect that the
   83  * license from Licensee to its licensee is limited to the intellectual
   84  * property embodied in the software Licensee provides to its licensee, and
   85  * not to intellectual property embodied in modifications its licensee may
   86  * make.
   87  *
   88  * 3.3. Redistribution of Executable. Redistribution in executable form of any
   89  * substantial portion of the Covered Code or modification must reproduce the
   90  * above Copyright Notice, and the following Disclaimer and Export Compliance
   91  * provision in the documentation and/or other materials provided with the
   92  * distribution.
   93  *
   94  * 3.4. Intel retains all right, title, and interest in and to the Original
   95  * Intel Code.
   96  *
   97  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
   98  * Intel shall be used in advertising or otherwise to promote the sale, use or
   99  * other dealings in products derived from or relating to the Covered Code
  100  * without prior written authorization from Intel.
  101  *
  102  * 4. Disclaimer and Export Compliance
  103  *
  104  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  105  * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  106  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
  107  * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
  108  * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
  109  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  110  * PARTICULAR PURPOSE. 
  111  *
  112  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  113  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  114  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  115  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  116  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  117  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
  118  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  119  * LIMITED REMEDY.
  120  *
  121  * 4.3. Licensee shall not export, either directly or indirectly, any of this
  122  * software or system incorporating such software without first obtaining any
  123  * required license or other approval from the U. S. Department of Commerce or
  124  * any other agency or department of the United States Government.  In the
  125  * event Licensee exports any such software from the United States or
  126  * re-exports any such software from a foreign destination, Licensee shall
  127  * ensure that the distribution and export/re-export of the software is in
  128  * compliance with all laws, regulations, orders, or other restrictions of the
  129  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
  130  * any of its subsidiaries will export/re-export any technical data, process,
  131  * software, or service, directly or indirectly, to any country for which the
  132  * United States government or any agency thereof requires an export license,
  133  * other governmental approval, or letter of assurance, without first obtaining
  134  * such license, approval or letter.
  135  *
  136  *****************************************************************************/
  137 
  138 #include "opt_acpi.h"
  139 #include <sys/param.h>
  140 #include <sys/kernel.h>
  141 #include <sys/bus.h>
  142 
  143 #include <machine/bus.h>
  144 #include <machine/resource.h>
  145 #include <sys/rman.h>
  146 
  147 #include "acpi.h"
  148 
  149 #include <dev/acpica/acpivar.h>
  150 
  151 /*
  152  * Hooks for the ACPI CA debugging infrastructure
  153  */
  154 #define _COMPONENT      ACPI_EC
  155 ACPI_MODULE_NAME("EC")
  156 
  157 /*
  158  * EC_COMMAND:
  159  * -----------
  160  */
  161 typedef UINT8                           EC_COMMAND;
  162 
  163 #define EC_COMMAND_UNKNOWN              ((EC_COMMAND) 0x00)
  164 #define EC_COMMAND_READ                 ((EC_COMMAND) 0x80)
  165 #define EC_COMMAND_WRITE                ((EC_COMMAND) 0x81)
  166 #define EC_COMMAND_BURST_ENABLE         ((EC_COMMAND) 0x82)
  167 #define EC_COMMAND_BURST_DISABLE        ((EC_COMMAND) 0x83)
  168 #define EC_COMMAND_QUERY                ((EC_COMMAND) 0x84)
  169 
  170 /* 
  171  * EC_STATUS:
  172  * ----------
  173  * The encoding of the EC status register is illustrated below.
  174  * Note that a set bit (1) indicates the property is TRUE
  175  * (e.g. if bit 0 is set then the output buffer is full).
  176  * +-+-+-+-+-+-+-+-+
  177  * |7|6|5|4|3|2|1|0|    
  178  * +-+-+-+-+-+-+-+-+
  179  *  | | | | | | | |
  180  *  | | | | | | | +- Output Buffer Full?
  181  *  | | | | | | +--- Input Buffer Full?
  182  *  | | | | | +----- <reserved>
  183  *  | | | | +------- Data Register is Command Byte?
  184  *  | | | +--------- Burst Mode Enabled?
  185  *  | | +----------- SCI Event?
  186  *  | +------------- SMI Event?
  187  *  +--------------- <Reserved>
  188  *
  189  */
  190 typedef UINT8                           EC_STATUS;
  191 
  192 #define EC_FLAG_OUTPUT_BUFFER           ((EC_STATUS) 0x01)
  193 #define EC_FLAG_INPUT_BUFFER            ((EC_STATUS) 0x02)
  194 #define EC_FLAG_BURST_MODE              ((EC_STATUS) 0x10)
  195 #define EC_FLAG_SCI                     ((EC_STATUS) 0x20)
  196 
  197 /*
  198  * EC_EVENT:
  199  * ---------
  200  */
  201 typedef UINT8                           EC_EVENT;
  202 
  203 #define EC_EVENT_UNKNOWN                ((EC_EVENT) 0x00)
  204 #define EC_EVENT_OUTPUT_BUFFER_FULL     ((EC_EVENT) 0x01)
  205 #define EC_EVENT_INPUT_BUFFER_EMPTY     ((EC_EVENT) 0x02)
  206 #define EC_EVENT_SCI                    ((EC_EVENT) 0x20)
  207 
  208 /*
  209  * Register access primitives
  210  */
  211 #define EC_GET_DATA(sc)                                                 \
  212         bus_space_read_1((sc)->ec_data_tag, (sc)->ec_data_handle, 0)
  213 
  214 #define EC_SET_DATA(sc, v)                                              \
  215         bus_space_write_1((sc)->ec_data_tag, (sc)->ec_data_handle, 0, (v))
  216 
  217 #define EC_GET_CSR(sc)                                                  \
  218         bus_space_read_1((sc)->ec_csr_tag, (sc)->ec_csr_handle, 0)
  219 
  220 #define EC_SET_CSR(sc, v)                                               \
  221         bus_space_write_1((sc)->ec_csr_tag, (sc)->ec_csr_handle, 0, (v))
  222 
  223 /*
  224  * Driver softc.
  225  */
  226 struct acpi_ec_softc {
  227     device_t            ec_dev;
  228     ACPI_HANDLE         ec_handle;
  229     UINT32              ec_gpebit;
  230     
  231     int                 ec_data_rid;
  232     struct resource     *ec_data_res;
  233     bus_space_tag_t     ec_data_tag;
  234     bus_space_handle_t  ec_data_handle;
  235 
  236     int                 ec_csr_rid;
  237     struct resource     *ec_csr_res;
  238     bus_space_tag_t     ec_csr_tag;
  239     bus_space_handle_t  ec_csr_handle;
  240 
  241     int                 ec_locked;
  242     int                 ec_lockhandle;
  243     int                 ec_pendquery;
  244     int                 ec_csrvalue;
  245 };
  246 
  247 static int                       acpi_ec_event_driven = 0;
  248 TUNABLE_INT("hw.acpi.ec.event_driven", &acpi_ec_event_driven);
  249 
  250 #define EC_LOCK_TIMEOUT 1000    /* 1ms */
  251 
  252 static __inline ACPI_STATUS
  253 EcLock(struct acpi_ec_softc *sc)
  254 {
  255     ACPI_STATUS status;
  256 
  257     /* XXX ACPI_WAIT_FOREVER is probably a bad idea, what is a better time? */
  258     if (ACPI_SUCCESS(status = AcpiAcquireGlobalLock(ACPI_WAIT_FOREVER, &sc->ec_lockhandle)))
  259         (sc)->ec_locked = 1;
  260 
  261     return(status);
  262 }
  263 
  264 static __inline void
  265 EcUnlock(struct acpi_ec_softc *sc)
  266 {
  267     (sc)->ec_locked = 0; 
  268     AcpiReleaseGlobalLock(sc->ec_lockhandle);
  269 }
  270 
  271 static __inline int
  272 EcIsLocked(struct acpi_ec_softc *sc)
  273 {
  274     return((sc)->ec_locked != 0);
  275 }
  276 
  277 typedef struct
  278 {
  279     EC_COMMAND              Command;
  280     UINT8                   Address;
  281     UINT8                   Data;
  282 } EC_REQUEST;
  283 
  284 static void             EcGpeHandler(void *Context);
  285 static ACPI_STATUS      EcSpaceSetup(ACPI_HANDLE Region, UINT32 Function, 
  286                                            void *Context, void **return_Context);
  287 static ACPI_STATUS      EcSpaceHandler(UINT32 Function, ACPI_PHYSICAL_ADDRESS Address, UINT32 width, ACPI_INTEGER *Value, 
  288                                       void *Context, void *RegionContext);
  289 
  290 static ACPI_STATUS      EcWaitEvent(struct acpi_ec_softc *sc, EC_EVENT Event);
  291 static ACPI_STATUS      EcQuery(struct acpi_ec_softc *sc, UINT8 *Data);
  292 static ACPI_STATUS      EcTransaction(struct acpi_ec_softc *sc, EC_REQUEST *EcRequest);
  293 static ACPI_STATUS      EcRead(struct acpi_ec_softc *sc, UINT8 Address, UINT8 *Data);
  294 static ACPI_STATUS      EcWrite(struct acpi_ec_softc *sc, UINT8 Address, UINT8 *Data);
  295 
  296 static void             acpi_ec_identify(driver_t driver, device_t bus);
  297 static int              acpi_ec_probe(device_t dev);
  298 static int              acpi_ec_attach(device_t dev);
  299 
  300 static device_method_t acpi_ec_methods[] = {
  301     /* Device interface */
  302     DEVMETHOD(device_identify,  acpi_ec_identify),
  303     DEVMETHOD(device_probe,     acpi_ec_probe),
  304     DEVMETHOD(device_attach,    acpi_ec_attach),
  305 
  306     {0, 0}
  307 };
  308 
  309 static driver_t acpi_ec_driver = {
  310     "acpi_ec",
  311     acpi_ec_methods,
  312     sizeof(struct acpi_ec_softc),
  313 };
  314 
  315 static devclass_t acpi_ec_devclass;
  316 DRIVER_MODULE(acpi_ec, acpi, acpi_ec_driver, acpi_ec_devclass, 0, 0);
  317 
  318 /*
  319  * Look for an ECDT table and if we find one, set up a default EC 
  320  * space handler to catch possible attempts to access EC space before
  321  * we have a real driver instance in place.
  322  * We're not really an identify routine, but because we get called 
  323  * before most other things, this works out OK.
  324  */
  325 static void
  326 acpi_ec_identify(driver_t driver, device_t bus)
  327 {
  328     ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
  329 
  330     /* XXX implement - need an ACPI 2.0 system to test this */
  331 
  332     return_VOID;
  333 }
  334 
  335 /*
  336  * We could setup resources in the probe routine in order to have them printed 
  337  * when the device is attached.
  338  */
  339 static int
  340 acpi_ec_probe(device_t dev)
  341 {
  342 
  343     if ((acpi_get_type(dev) == ACPI_TYPE_DEVICE) &&
  344         !acpi_disabled("ec") &&
  345         acpi_MatchHid(dev, "PNP0C09")) {
  346 
  347         /*
  348          * Set device description 
  349          */
  350         device_set_desc(dev, "embedded controller");
  351 
  352         return(0);
  353     }
  354     return(ENXIO);
  355 }
  356 
  357 static int
  358 acpi_ec_attach(device_t dev)
  359 {
  360     struct acpi_ec_softc        *sc;
  361     ACPI_STATUS                 Status;
  362     int errval = 0;
  363 
  364     ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
  365 
  366     /*
  367      * Fetch/initialise softc
  368      */
  369     sc = device_get_softc(dev);
  370     bzero(sc, sizeof(*sc));
  371     sc->ec_dev = dev;
  372     sc->ec_handle = acpi_get_handle(dev);
  373 
  374     /* 
  375      * Attach bus resources
  376      */
  377     sc->ec_data_rid = 0;
  378     if ((sc->ec_data_res = bus_alloc_resource(sc->ec_dev, SYS_RES_IOPORT, &sc->ec_data_rid,
  379                                               0, ~0, 1, RF_ACTIVE)) == NULL) {
  380         device_printf(dev, "can't allocate data port\n");
  381         errval = ENXIO;
  382         goto out;
  383     }
  384     sc->ec_data_tag = rman_get_bustag(sc->ec_data_res);
  385     sc->ec_data_handle = rman_get_bushandle(sc->ec_data_res);
  386 
  387     sc->ec_csr_rid = 1;
  388     if ((sc->ec_csr_res = bus_alloc_resource(sc->ec_dev, SYS_RES_IOPORT, &sc->ec_csr_rid,
  389                                              0, ~0, 1, RF_ACTIVE)) == NULL) {
  390         device_printf(dev, "can't allocate command/status port\n");
  391         errval = ENXIO;
  392         goto out;
  393     }
  394     sc->ec_csr_tag = rman_get_bustag(sc->ec_csr_res);
  395     sc->ec_csr_handle = rman_get_bushandle(sc->ec_csr_res);
  396 
  397     /*
  398      * Install GPE handler
  399      *
  400      * Evaluate the _GPE method to find the GPE bit used by the EC to signal
  401      * status (SCI).
  402      */
  403     ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "attaching GPE\n"));
  404     if (ACPI_FAILURE(Status = acpi_EvaluateInteger(sc->ec_handle, "_GPE", &sc->ec_gpebit))) {
  405         device_printf(dev, "can't evaluate _GPE - %s\n", AcpiFormatException(Status));
  406         errval =ENXIO;
  407         goto out;
  408     }
  409 
  410     /*
  411      * Install a handler for this EC's GPE bit.  Note that EC SCIs are 
  412      * treated as both edge- and level-triggered interrupts; in other words
  413      * we clear the status bit immediately after getting an EC-SCI, then
  414      * again after we're done processing the event.  This guarantees that
  415      * events we cause while performing a transaction (e.g. IBE/OBF) get 
  416      * cleared before re-enabling the GPE.
  417      */
  418     if (ACPI_FAILURE(Status = AcpiInstallGpeHandler(sc->ec_gpebit,
  419                                                     ACPI_EVENT_LEVEL_TRIGGERED |
  420                                                     ACPI_EVENT_EDGE_TRIGGERED, 
  421                                                     EcGpeHandler, sc))) {
  422         device_printf(dev, "can't install GPE handler for %s - %s\n",
  423                       acpi_name(sc->ec_handle), AcpiFormatException(Status));
  424         errval = ENXIO;
  425         goto out;
  426     }
  427 
  428     /* 
  429      * Install address space handler
  430      */
  431     ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "attaching address space handler\n"));
  432     if (ACPI_FAILURE(Status = AcpiInstallAddressSpaceHandler(sc->ec_handle,
  433                                                              ACPI_ADR_SPACE_EC,
  434                                                              EcSpaceHandler,
  435                                                              EcSpaceSetup,
  436                                                              sc))) {
  437         device_printf(dev, "can't install address space handler for %s - %s\n",
  438                       acpi_name(sc->ec_handle), AcpiFormatException(Status));
  439         panic("very suck");
  440         errval = ENXIO;
  441         goto out;
  442     }
  443     ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "attach complete\n"));
  444     return_VALUE(0);
  445  out:
  446     if(sc->ec_csr_res)
  447         bus_release_resource(sc->ec_dev, SYS_RES_IOPORT, sc->ec_csr_rid, 
  448                              sc->ec_csr_res);
  449     if(sc->ec_data_res)
  450         bus_release_resource(sc->ec_dev, SYS_RES_IOPORT, sc->ec_data_rid,
  451                              sc->ec_data_res);
  452     return_VALUE(errval);
  453 }
  454 
  455 static void
  456 EcGpeQueryHandler(void *Context)
  457 {
  458     struct acpi_ec_softc        *sc = (struct acpi_ec_softc *)Context;
  459     UINT8                       Data;
  460     ACPI_STATUS                 Status;
  461     char                        qxx[5];
  462 
  463     ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
  464 
  465     for (;;) {
  466 
  467         /*
  468          * Check EC_SCI.
  469          * 
  470          * Bail out if the EC_SCI bit of the status register is not set.
  471          * Note that this function should only be called when
  472          * this bit is set (polling is used to detect IBE/OBF events).
  473          *
  474          * It is safe to do this without locking the controller, as it's
  475          * OK to call EcQuery when there's no data ready; in the worst
  476          * case we should just find nothing waiting for us and bail.
  477          */
  478         if (!(EC_GET_CSR(sc) & EC_EVENT_SCI))
  479             break;
  480 
  481         /*
  482          * Find out why the EC is signalling us
  483          */
  484         Status = EcQuery(sc, &Data);
  485             
  486         /*
  487          * If we failed to get anything from the EC, give up
  488          */
  489         if (ACPI_FAILURE(Status)) {
  490             ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
  491                 "GPE query failed - %s\n", AcpiFormatException(Status));
  492             break;
  493         }
  494 
  495         /*
  496          * Evaluate _Qxx to respond to the controller.
  497          */
  498         sprintf(qxx, "_Q%02x", Data);
  499         strupr(qxx);
  500         Status = AcpiEvaluateObject(sc->ec_handle, qxx, NULL, NULL);
  501         /*
  502          * Ignore spurious query requests.
  503          */
  504         if (ACPI_FAILURE(Status) && (Data != 0 || Status != AE_NOT_FOUND)) {
  505             ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
  506                 "evaluation of GPE query method %s failed - %s\n", 
  507                         qxx, AcpiFormatException(Status));
  508         }
  509     }
  510         /* I know I request Level trigger cleanup */
  511     if (ACPI_FAILURE(AcpiClearEvent(sc->ec_gpebit, ACPI_EVENT_GPE)))
  512             printf("EcGpeQueryHandler:ClearEvent Failed\n");
  513     if (ACPI_FAILURE(AcpiEnableEvent(sc->ec_gpebit, ACPI_EVENT_GPE, 0)))
  514             printf("EcGpeQueryHandler:EnableEvent Failed\n");
  515     return_VOID;
  516 }
  517 
  518 /*
  519  * Handle a GPE sent to us.
  520  */
  521 static void
  522 EcGpeHandler(void *Context)
  523 {
  524     struct acpi_ec_softc *sc = Context;
  525     int csrvalue;
  526 
  527     /* 
  528      * If EC is locked, the intr must process EcRead/Write wait only.
  529      * Query request must be pending.
  530      */
  531     if (EcIsLocked(sc)){
  532         csrvalue = EC_GET_CSR(sc);
  533         if (csrvalue & EC_EVENT_SCI)
  534             sc->ec_pendquery = 1;
  535         if ((csrvalue & EC_FLAG_OUTPUT_BUFFER)
  536             || !(csrvalue & EC_FLAG_INPUT_BUFFER)) {
  537             sc->ec_csrvalue = csrvalue;
  538             wakeup((void *)&sc->ec_csrvalue);
  539         }
  540     }else{
  541         /* Queue GpeQuery Handler */
  542         if (ACPI_FAILURE(AcpiOsQueueForExecution(OSD_PRIORITY_HIGH,
  543                                     EcGpeQueryHandler,Context))) {
  544             printf("QueryHandler Queuing Failed\n");
  545         }
  546     }
  547     return;
  548 }
  549 
  550 static ACPI_STATUS
  551 EcSpaceSetup(ACPI_HANDLE Region, UINT32 Function, void *Context, void **RegionContext)
  552 {
  553 
  554     ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
  555 
  556     /*
  557      * Just pass the context through, there's nothing to do here.
  558      */
  559     *RegionContext = Context;
  560 
  561     return_ACPI_STATUS(AE_OK);
  562 }
  563 
  564 static ACPI_STATUS
  565 EcSpaceHandler(UINT32 Function, ACPI_PHYSICAL_ADDRESS Address, UINT32 width, ACPI_INTEGER *Value, 
  566                void *Context, void *RegionContext)
  567 {
  568     struct acpi_ec_softc        *sc = (struct acpi_ec_softc *)Context;
  569     ACPI_STATUS                 Status = AE_OK;
  570     EC_REQUEST                  EcRequest;
  571     int                         i;
  572 
  573     ACPI_FUNCTION_TRACE_U32((char *)(uintptr_t)__func__, (UINT32)Address);
  574 
  575     if ((Address > 0xFF) || (width % 8 != 0) || (Value == NULL) || (Context == NULL))
  576         return_ACPI_STATUS(AE_BAD_PARAMETER);
  577 
  578     switch (Function) {
  579     case ACPI_READ:
  580         EcRequest.Command = EC_COMMAND_READ;
  581         EcRequest.Address = Address;
  582         (*Value) = 0;
  583         break;
  584 
  585     case ACPI_WRITE:
  586         EcRequest.Command = EC_COMMAND_WRITE;
  587         EcRequest.Address = Address;
  588         break;
  589 
  590     default:
  591         device_printf(sc->ec_dev, "invalid Address Space function %d\n", Function);
  592         return_ACPI_STATUS(AE_BAD_PARAMETER);
  593     }
  594 
  595     /*
  596      * Perform the transaction.
  597      */
  598     for (i = 0; i < width; i += 8) {
  599         if (Function == ACPI_READ)
  600             EcRequest.Data = 0;
  601         else
  602             EcRequest.Data = (UINT8)((*Value) >> i);
  603         if (ACPI_FAILURE(Status = EcTransaction(sc, &EcRequest)))
  604             break;
  605         (*Value) |= (ACPI_INTEGER)EcRequest.Data << i;
  606         if (++EcRequest.Address == 0)
  607             return_ACPI_STATUS(AE_BAD_PARAMETER);
  608     }
  609     return_ACPI_STATUS(Status);
  610 }
  611 
  612 /*
  613  * Wait for an event interrupt for a specific condition.
  614  */
  615 static ACPI_STATUS
  616 EcWaitEventIntr(struct acpi_ec_softc *sc, EC_EVENT Event)
  617 {
  618     EC_STATUS   EcStatus;
  619     int         i;
  620 
  621     ACPI_FUNCTION_TRACE_U32((char *)(uintptr_t)__func__, (UINT32)Event);
  622 
  623     /* XXX this should test whether interrupts are available some other way */
  624     if (cold || acpi_ec_event_driven)
  625         return_ACPI_STATUS(EcWaitEvent(sc, Event));
  626 
  627     if (!EcIsLocked(sc))
  628         ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
  629             "EcWaitEventIntr called without EC lock!\n");
  630 
  631     EcStatus = EC_GET_CSR(sc);
  632 
  633     /* XXX waiting too long? */
  634     for(i = 0; i < 10; i++){
  635         /*
  636          * Check EC status against the desired event.
  637          */
  638         if ((Event == EC_EVENT_OUTPUT_BUFFER_FULL) &&
  639             (EcStatus & EC_FLAG_OUTPUT_BUFFER))
  640             return_ACPI_STATUS(AE_OK);
  641       
  642         if ((Event == EC_EVENT_INPUT_BUFFER_EMPTY) && 
  643             !(EcStatus & EC_FLAG_INPUT_BUFFER))
  644             return_ACPI_STATUS(AE_OK);
  645         
  646         sc->ec_csrvalue = 0;
  647         if (ACPI_MSLEEP(&sc->ec_csrvalue, &acpi_mutex, PZERO, "EcWait", 1) != EWOULDBLOCK){
  648             EcStatus = sc->ec_csrvalue;
  649         }else{
  650             EcStatus = EC_GET_CSR(sc);
  651         }
  652     }
  653     return_ACPI_STATUS(AE_ERROR);
  654 }
  655 
  656 static ACPI_STATUS
  657 EcWaitEvent(struct acpi_ec_softc *sc, EC_EVENT Event)
  658 {
  659     EC_STATUS   EcStatus;
  660     UINT32      i = 0;
  661 
  662     if (!EcIsLocked(sc))
  663         ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
  664             "EcWaitEvent called without EC lock!\n");
  665 
  666     /*
  667      * Stall 1us:
  668      * ----------
  669      * Stall for 1 microsecond before reading the status register
  670      * for the first time.  This allows the EC to set the IBF/OBF
  671      * bit to its proper state.
  672      *
  673      * XXX it is not clear why we read the CSR twice.
  674      */
  675     AcpiOsStall(1);
  676     EcStatus = EC_GET_CSR(sc);
  677 
  678     /*
  679      * Wait For Event:
  680      * ---------------
  681      * Poll the EC status register to detect completion of the last
  682      * command.  Wait up to 10ms (in 10us chunks) for this to occur.
  683      */
  684     for (i = 0; i < 1000; i++) {
  685         EcStatus = EC_GET_CSR(sc);
  686 
  687         if ((Event == EC_EVENT_OUTPUT_BUFFER_FULL) &&
  688             (EcStatus & EC_FLAG_OUTPUT_BUFFER))
  689             return(AE_OK);
  690 
  691         if ((Event == EC_EVENT_INPUT_BUFFER_EMPTY) && 
  692             !(EcStatus & EC_FLAG_INPUT_BUFFER))
  693             return(AE_OK);
  694         
  695         AcpiOsStall(10);
  696     }
  697 
  698     return(AE_ERROR);
  699 }    
  700 
  701 static ACPI_STATUS
  702 EcQuery(struct acpi_ec_softc *sc, UINT8 *Data)
  703 {
  704     ACPI_STATUS Status;
  705 
  706     if (ACPI_FAILURE(Status = EcLock(sc)))
  707         return(Status);
  708 
  709     EC_SET_CSR(sc, EC_COMMAND_QUERY);
  710     if (ACPI_SUCCESS(Status = EcWaitEvent(sc, EC_EVENT_OUTPUT_BUFFER_FULL)))
  711         *Data = EC_GET_DATA(sc);
  712 
  713     EcUnlock(sc);
  714 
  715     if (ACPI_FAILURE(Status))
  716         ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
  717             "timeout waiting for EC to respond to EC_COMMAND_QUERY\n");
  718     return(Status);
  719 }    
  720 
  721 static ACPI_STATUS
  722 EcTransaction(struct acpi_ec_softc *sc, EC_REQUEST *EcRequest)
  723 {
  724     ACPI_STATUS Status;
  725 
  726     /*
  727      * Lock the EC
  728      */
  729     if (ACPI_FAILURE(Status = EcLock(sc)))
  730         return(Status);
  731 
  732     /*
  733      * Perform the transaction.
  734      */
  735     switch (EcRequest->Command) {
  736     case EC_COMMAND_READ:
  737         Status = EcRead(sc, EcRequest->Address, &(EcRequest->Data));
  738         break;
  739 
  740     case EC_COMMAND_WRITE:
  741         Status = EcWrite(sc, EcRequest->Address, &(EcRequest->Data));
  742         break;
  743 
  744     default:
  745         Status = AE_SUPPORT;
  746         break;
  747     }
  748 
  749     /*
  750      * Unlock the EC
  751      */
  752     EcUnlock(sc);
  753     
  754     /*
  755      * Clear & Re-Enable the EC GPE:
  756      * -----------------------------
  757      * 'Consume' any EC GPE events that we generated while performing
  758      * the transaction (e.g. IBF/OBF).  Clearing the GPE here shouldn't
  759      * have an adverse affect on outstanding EC-SCI's, as the source
  760      * (EC-SCI) will still be high and thus should trigger the GPE
  761      * immediately after we re-enabling it.
  762      */
  763     if (sc->ec_pendquery){
  764         if (ACPI_FAILURE(AcpiOsQueueForExecution(OSD_PRIORITY_HIGH,
  765                                                  EcGpeQueryHandler, sc)))
  766             printf("Pend Query Queuing Failed\n");
  767         sc->ec_pendquery = 0;
  768     }
  769 
  770     if (ACPI_FAILURE(AcpiClearEvent(sc->ec_gpebit, ACPI_EVENT_GPE)))
  771         ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
  772             "EcRequest: Unable to clear the EC GPE.\n");
  773     if (ACPI_FAILURE(AcpiEnableEvent(sc->ec_gpebit, ACPI_EVENT_GPE, 0)))
  774         ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
  775             "EcRequest: Unable to re-enable the EC GPE.\n");
  776 
  777     return(Status);
  778 }
  779 
  780 
  781 static ACPI_STATUS
  782 EcRead(struct acpi_ec_softc *sc, UINT8 Address, UINT8 *Data)
  783 {
  784     ACPI_STATUS Status;
  785 
  786     if (!EcIsLocked(sc))
  787         ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
  788             "EcRead called without EC lock!\n");
  789 
  790     /*EcBurstEnable(EmbeddedController);*/
  791 
  792     EC_SET_CSR(sc, EC_COMMAND_READ);
  793     if (ACPI_FAILURE(Status = EcWaitEventIntr(sc, EC_EVENT_INPUT_BUFFER_EMPTY))) {
  794         ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
  795             "EcRead: Failed waiting for EC to process read command.\n");
  796         return(Status);
  797     }
  798 
  799     EC_SET_DATA(sc, Address);
  800     if (ACPI_FAILURE(Status = EcWaitEventIntr(sc, EC_EVENT_OUTPUT_BUFFER_FULL))) {
  801         ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
  802             "EcRead: Failed waiting for EC to send data.\n");
  803         return(Status);
  804     }
  805 
  806     (*Data) = EC_GET_DATA(sc);
  807 
  808     /*EcBurstDisable(EmbeddedController);*/
  809 
  810     return(AE_OK);
  811 }    
  812 
  813 static ACPI_STATUS
  814 EcWrite(struct acpi_ec_softc *sc, UINT8 Address, UINT8 *Data)
  815 {
  816     ACPI_STATUS Status;
  817 
  818     if (!EcIsLocked(sc))
  819         ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
  820             "EcWrite called without EC lock!\n");
  821 
  822     /*EcBurstEnable(EmbeddedController);*/
  823 
  824     EC_SET_CSR(sc, EC_COMMAND_WRITE);
  825     if (ACPI_FAILURE(Status = EcWaitEventIntr(sc, EC_EVENT_INPUT_BUFFER_EMPTY))) {
  826         ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
  827             "EcWrite: Failed waiting for EC to process write command.\n");
  828         return(Status);
  829     }
  830 
  831     EC_SET_DATA(sc, Address);
  832     if (ACPI_FAILURE(Status = EcWaitEventIntr(sc, EC_EVENT_INPUT_BUFFER_EMPTY))) {
  833         ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
  834             "EcRead: Failed waiting for EC to process address.\n");
  835         return(Status);
  836     }
  837 
  838     EC_SET_DATA(sc, *Data);
  839     if (ACPI_FAILURE(Status = EcWaitEventIntr(sc, EC_EVENT_INPUT_BUFFER_EMPTY))) {
  840         ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
  841             "EcWrite: Failed waiting for EC to process data.\n");
  842         return(Status);
  843     }
  844 
  845     /*EcBurstDisable(EmbeddedController);*/
  846 
  847     return(AE_OK);
  848 }

Cache object: 576b353ac75b10e5c9cae4a747069621


[ 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.