talexander
/
freebsd_amp_hwpstate
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Initial FreeBSD OSPM (operating system power management) modules for 

ACPICA.  Most of these are still works in progress.  Support exists for:

 - Fixed feature and control method power, lid and sleep buttons.
 - Detection of ISA PnP devices using ACPI namespace.
 - Detection of PCI root busses using ACPI namespace.
 - CPU throttling and sleep states (incomplete)
 - Thermal monitoring and cooling control (incomplete)
 - Interface to platform embedded controllers (mostly complete)
 - ACPI timer (incomplete)
 - Simple userland control of sleep states.
 - Shutdown and poweroff.
This commit is contained in:
Mike Smith 2000-10-28 06:59:48 +00:00
parent fd660059d9
commit 15e32d5d03
15 changed files with 4893 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1124
sys/dev/acpica/acpi.c Normal file
View File

File diff suppressed because it is too large Load Diff

159
sys/dev/acpica/acpi_apic.c Normal file
View File

@ -0,0 +1,159 @@
/*-
* Copyright (c) 2000 Michael Smith
* Copyright (c) 2000 BSDi
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $FreeBSD$
*/
/*
* XXX This is all pretty dubious, since we really want the APIC and co.
* up and running long before attaching interrupts, etc.
*/
#include "opt_acpi.h"
#include <sys/param.h>
#include <sys/kernel.h>
#include <sys/bus.h>
#include "acpi.h"
#include <dev/acpica/acpivar.h>
#define APIC_MAGIC 0x43495041 /* "APIC" */
struct acpi_apic_softc {
device_t apic_dev;
IO_APIC *apic_ioapic;
};
static void acpi_apic_identify(driver_t *driver, device_t bus);
static int acpi_apic_probe(device_t dev);
static int acpi_apic_attach(device_t dev);
static device_method_t acpi_apic_methods[] = {
/* Device interface */
DEVMETHOD(device_identify, acpi_apic_identify),
DEVMETHOD(device_probe, acpi_apic_probe),
DEVMETHOD(device_attach, acpi_apic_attach),
{0, 0}
};
static driver_t acpi_apic_driver = {
"acpi_apic",
acpi_apic_methods,
sizeof(struct acpi_apic_softc),
};
devclass_t acpi_apic_devclass;
DRIVER_MODULE(acpi_apic, acpi, acpi_apic_driver, acpi_apic_devclass, 0, 0);
static void
acpi_apic_identify(driver_t *driver, device_t bus)
{
ACPI_BUFFER buf;
ACPI_STATUS status;
APIC_HEADER *hdr;
APIC_TABLE *tbl;
device_t child;
int len;
void *private;
/*
* Perform the tedious double-get to fetch the actual table.
*/
buf.Length = 0;
buf.Pointer = NULL;
if ((status = AcpiGetTable(ACPI_TABLE_APIC, 1, &buf)) != AE_BUFFER_OVERFLOW) {
if (status != AE_NOT_EXIST)
device_printf(bus, "error sizing APIC table - %s\n", acpi_strerror(status));
return;
}
if ((buf.Pointer = AcpiOsAllocate(buf.Length)) == NULL)
return;
if ((status = AcpiGetTable(ACPI_TABLE_APIC, 1, &buf)) != AE_OK) {
device_printf(bus, "error fetching APIC table - %s\n", acpi_strerror(status));
return;
}
/*
* Scan the tables, create child devices for each I/O APIC found
*/
tbl = (APIC_TABLE *)buf.Pointer;
len = tbl->header.Length - sizeof(APIC_TABLE);
hdr = (APIC_HEADER *)((char *)buf.Pointer + sizeof(APIC_TABLE));
while(len > 0) {
if (hdr->Length > len) {
device_printf(bus, "APIC header corrupt (claims %d bytes where only %d left in structure)\n",
hdr->Length, len);
break;
}
switch (hdr->Type) {
case APIC_IO:
if ((child = BUS_ADD_CHILD(bus, 0, "acpi_apic", -1)) == NULL) {
device_printf(bus, "could not create I/O APIC device");
break;
}
if ((private = AcpiOsAllocate(hdr->Length)) == NULL) {
device_printf(bus, "could not allocate memory for APIC child");
break;
}
bcopy(hdr, private, hdr->Length);
acpi_set_magic(child, APIC_MAGIC);
acpi_set_private(child, private);
device_set_desc(child, "I/O APIC");
break;
}
len -= hdr->Length;
hdr = (APIC_HEADER *)((char *)hdr + hdr->Length);
}
AcpiOsFree(buf.Pointer);
}
static int
acpi_apic_probe(device_t dev)
{
if (acpi_get_magic(dev) == APIC_MAGIC)
return(0);
return(ENXIO);
}
static int
acpi_apic_attach(device_t dev)
{
struct acpi_apic_softc *sc;
sc = device_get_softc(dev);
sc->apic_dev = dev;
/*
* Fetch our parameters.
*/
sc->apic_ioapic = acpi_get_private(dev);
device_printf(dev, "I/O APIC ID %d at 0x%08x vectors 0%x\n",
sc->apic_ioapic->IoApicId, sc->apic_ioapic->IoApicAddress, sc->apic_ioapic->Vector);
return(0);
}

182
sys/dev/acpica/acpi_button.c Normal file
View File

@ -0,0 +1,182 @@
/*-
* Copyright (c) 2000 Mitsaru IWASAKI <iwasaki@jp.freebsd.org>
* Copyright (c) 2000 Michael Smith <msmith@freebsd.org>
* Copyright (c) 2000 BSDi
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $FreeBSD$
*/
#include "opt_acpi.h"
#include <sys/param.h>
#include <sys/kernel.h>
#include <sys/bus.h>
#include "acpi.h"
#include <dev/acpica/acpivar.h>
struct acpi_button_softc {
device_t button_dev;
ACPI_HANDLE button_handle;
#define ACPI_POWER_BUTTON 0
#define ACPI_SLEEP_BUTTON 1
boolean_t button_type; /* Power or Sleep Button */
};
static int acpi_button_probe(device_t dev);
static int acpi_button_attach(device_t dev);
static void acpi_button_notify_handler(ACPI_HANDLE h,UINT32 notify, void *context);
static void acpi_button_notify_pressed_for_sleep(void *arg);
static void acpi_button_notify_pressed_for_wakeup(void *arg);
static device_method_t acpi_button_methods[] = {
/* Device interface */
DEVMETHOD(device_probe, acpi_button_probe),
DEVMETHOD(device_attach, acpi_button_attach),
{0, 0}
};
static driver_t acpi_button_driver = {
"acpi_button",
acpi_button_methods,
sizeof(struct acpi_button_softc),
};
devclass_t acpi_button_devclass;
DRIVER_MODULE(acpi_button, acpi, acpi_button_driver, acpi_button_devclass, 0, 0);
static int
acpi_button_probe(device_t dev)
{
struct acpi_button_softc *sc;
sc = device_get_softc(dev);
if (acpi_get_type(dev) == ACPI_TYPE_DEVICE) {
if (acpi_MatchHid(dev, "PNP0C0C")) {
device_set_desc(dev, "Control Method Power Button Device");
sc->button_type = ACPI_POWER_BUTTON;
return(0);
}
if (acpi_MatchHid(dev, "PNP0C0E")) {
device_set_desc(dev, "Control Method Sleep Button Device");
sc->button_type = ACPI_SLEEP_BUTTON;
return(0);
}
return(ENXIO);
}
return(ENXIO);
}
static int
acpi_button_attach(device_t dev)
{
struct acpi_button_softc *sc;
ACPI_STATUS status;
sc = device_get_softc(dev);
sc->button_dev = dev;
sc->button_handle = acpi_get_handle(dev);
if ((status = AcpiInstallNotifyHandler(sc->button_handle, ACPI_DEVICE_NOTIFY,
acpi_button_notify_handler, sc)) != AE_OK) {
device_printf(sc->button_dev, "couldn't install Notify handler - %s\n", acpi_strerror(status));
return(ENXIO);
}
return(0);
}
static void
acpi_button_notify_pressed_for_sleep(void *arg)
{
struct acpi_button_softc *sc;
struct acpi_softc *acpi_sc;
sc = (struct acpi_button_softc *)arg;
acpi_sc = acpi_device_get_parent_softc(sc->button_dev);
if (acpi_sc == NULL) {
return;
}
switch (sc->button_type) {
case ACPI_POWER_BUTTON:
acpi_eventhandler_power_button_for_sleep((void *)acpi_sc);
break;
case ACPI_SLEEP_BUTTON:
acpi_eventhandler_sleep_button_for_sleep((void *)acpi_sc);
break;
default:
return; /* unknown button type */
}
}
static void
acpi_button_notify_pressed_for_wakeup(void *arg)
{
struct acpi_button_softc *sc;
struct acpi_softc *acpi_sc;
sc = (struct acpi_button_softc *)arg;
acpi_sc = acpi_device_get_parent_softc(sc->button_dev);
if (acpi_sc == NULL) {
return;
}
switch (sc->button_type) {
case ACPI_POWER_BUTTON:
acpi_eventhandler_power_button_for_wakeup((void *)acpi_sc);
break;
case ACPI_SLEEP_BUTTON:
acpi_eventhandler_sleep_button_for_wakeup((void *)acpi_sc);
break;
default:
return; /* unknown button type */
}
}
/* XXX maybe not here */
#define ACPI_NOTIFY_BUTTON_PRESSED_FOR_SLEEP 0x80
#define ACPI_NOTIFY_BUTTON_PRESSED_FOR_WAKEUP 0x02
static void
acpi_button_notify_handler(ACPI_HANDLE h, UINT32 notify, void *context)
{
struct acpi_button_softc *sc = (struct acpi_button_softc *)context;
switch (notify) {
case ACPI_NOTIFY_BUTTON_PRESSED_FOR_SLEEP:
AcpiOsQueueForExecution(OSD_PRIORITY_LO, acpi_button_notify_pressed_for_sleep, sc);
device_printf(sc->button_dev, "pressed for sleep, button type: %d\n", sc->button_type);
break;
case ACPI_NOTIFY_BUTTON_PRESSED_FOR_WAKEUP:
AcpiOsQueueForExecution(OSD_PRIORITY_LO, acpi_button_notify_pressed_for_wakeup, sc);
device_printf(sc->button_dev, "pressed for wakeup, button type: %d\n", sc->button_type);
break;
default:
return; /* unknown notification value */
}
}

710
sys/dev/acpica/acpi_ec.c Normal file
View File

@ -0,0 +1,710 @@
/*-
* Copyright (c) 2000 Michael Smith
* Copyright (c) 2000 BSDi
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $FreeBSD$
*/
/******************************************************************************
*
* 1. Copyright Notice
*
* Some or all of this work - Copyright (c) 1999, Intel Corp. All rights
* reserved.
*
* 2. License
*
* 2.1. This is your license from Intel Corp. under its intellectual property
* rights. You may have additional license terms from the party that provided
* you this software, covering your right to use that party's intellectual
* property rights.
*
* 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
* copy of the source code appearing in this file ("Covered Code") an
* irrevocable, perpetual, worldwide license under Intel's copyrights in the
* base code distributed originally by Intel ("Original Intel Code") to copy,
* make derivatives, distribute, use and display any portion of the Covered
* Code in any form, with the right to sublicense such rights; and
*
* 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
* license (with the right to sublicense), under only those claims of Intel
* patents that are infringed by the Original Intel Code, to make, use, sell,
* offer to sell, and import the Covered Code and derivative works thereof
* solely to the minimum extent necessary to exercise the above copyright
* license, and in no event shall the patent license extend to any additions
* to or modifications of the Original Intel Code. No other license or right
* is granted directly or by implication, estoppel or otherwise;
*
* The above copyright and patent license is granted only if the following
* conditions are met:
*
* 3. Conditions
*
* 3.1. Redistribution of Source with Rights to Further Distribute Source.
* Redistribution of source code of any substantial portion of the Covered
* Code or modification with rights to further distribute source must include
* the above Copyright Notice, the above License, this list of Conditions,
* and the following Disclaimer and Export Compliance provision. In addition,
* Licensee must cause all Covered Code to which Licensee contributes to
* contain a file documenting the changes Licensee made to create that Covered
* Code and the date of any change. Licensee must include in that file the
* documentation of any changes made by any predecessor Licensee. Licensee
* must include a prominent statement that the modification is derived,
* directly or indirectly, from Original Intel Code.
*
* 3.2. Redistribution of Source with no Rights to Further Distribute Source.
* Redistribution of source code of any substantial portion of the Covered
* Code or modification without rights to further distribute source must
* include the following Disclaimer and Export Compliance provision in the
* documentation and/or other materials provided with distribution. In
* addition, Licensee may not authorize further sublicense of source of any
* portion of the Covered Code, and must include terms to the effect that the
* license from Licensee to its licensee is limited to the intellectual
* property embodied in the software Licensee provides to its licensee, and
* not to intellectual property embodied in modifications its licensee may
* make.
*
* 3.3. Redistribution of Executable. Redistribution in executable form of any
* substantial portion of the Covered Code or modification must reproduce the
* above Copyright Notice, and the following Disclaimer and Export Compliance
* provision in the documentation and/or other materials provided with the
* distribution.
*
* 3.4. Intel retains all right, title, and interest in and to the Original
* Intel Code.
*
* 3.5. Neither the name Intel nor any other trademark owned or controlled by
* Intel shall be used in advertising or otherwise to promote the sale, use or
* other dealings in products derived from or relating to the Covered Code
* without prior written authorization from Intel.
*
* 4. Disclaimer and Export Compliance
*
* 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
* HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
* IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
* INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
* UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
* IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
* PARTICULAR PURPOSE.
*
* 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
* OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
* COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
* SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
* CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
* HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
* SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
* LIMITED REMEDY.
*
* 4.3. Licensee shall not export, either directly or indirectly, any of this
* software or system incorporating such software without first obtaining any
* required license or other approval from the U. S. Department of Commerce or
* any other agency or department of the United States Government. In the
* event Licensee exports any such software from the United States or
* re-exports any such software from a foreign destination, Licensee shall
* ensure that the distribution and export/re-export of the software is in
* compliance with all laws, regulations, orders, or other restrictions of the
* U.S. Export Administration Regulations. Licensee agrees that neither it nor
* any of its subsidiaries will export/re-export any technical data, process,
* software, or service, directly or indirectly, to any country for which the
* United States government or any agency thereof requires an export license,
* other governmental approval, or letter of assurance, without first obtaining
* such license, approval or letter.
*
*****************************************************************************/
#include "opt_acpi.h"
#include <sys/param.h>
#include <sys/kernel.h>
#include <sys/bus.h>
#include <machine/bus.h>
#include <machine/resource.h>
#include <sys/rman.h>
#include "acpi.h"
#include <dev/acpica/acpivar.h>
#include <dev/acpica/acpi_ecreg.h>
struct acpi_ec_softc {
device_t ec_dev;
ACPI_HANDLE ec_handle;
ACPI_HANDLE ec_semaphore;
UINT32 ec_gpebit;
int ec_data_rid;
struct resource *ec_data_res;
bus_space_tag_t ec_data_tag;
bus_space_handle_t ec_data_handle;
int ec_csr_rid;
struct resource *ec_csr_res;
bus_space_tag_t ec_csr_tag;
bus_space_handle_t ec_csr_handle;
int ec_locked;
};
#define EC_LOCK_TIMEOUT 1000 /* 1ms */
static __inline ACPI_STATUS
EcLock(struct acpi_ec_softc *sc)
{
ACPI_STATUS status;
status = AcpiOsWaitSemaphore((sc)->ec_semaphore, 1, EC_LOCK_TIMEOUT);
(sc)->ec_locked = 1;
return(status);
}
static __inline void
EcUnlock(struct acpi_ec_softc *sc)
{
(sc)->ec_locked = 0;
AcpiOsSignalSemaphore((sc)->ec_semaphore, 1);
}
static __inline int
EcIsLocked(struct acpi_ec_softc *sc)
{
return((sc)->ec_locked != 0);
}
typedef struct
{
EC_COMMAND Command;
UINT8 Address;
UINT8 Data;
} EC_REQUEST;
static struct acpi_ec_softc acpi_ec_default; /* for the default EC handler */
static void EcGpeHandler(void *Context);
static ACPI_STATUS EcSpaceSetup(ACPI_HANDLE Region, UINT32 Function,
void *Context, void **return_Context);
static ACPI_STATUS EcSpaceHandler(UINT32 Function, UINT32 Address, UINT32 width, UINT32 *Value,
void *Context, void *RegionContext);
static ACPI_STATUS EcDefaultSpaceHandler(UINT32 Function, UINT32 Address, UINT32 width, UINT32 *Value,
void *Context, void *RegionContext);
static ACPI_STATUS EcWaitEvent(struct acpi_ec_softc *sc, EC_EVENT Event);
static ACPI_STATUS EcQuery(struct acpi_ec_softc *sc, UINT8 *Data);
static ACPI_STATUS EcTransaction(struct acpi_ec_softc *sc, EC_REQUEST *EcRequest);
static ACPI_STATUS EcRead(struct acpi_ec_softc *sc, UINT8 Address, UINT8 *Data);
static ACPI_STATUS EcWrite(struct acpi_ec_softc *sc, UINT8 Address, UINT8 *Data);
static void acpi_ec_identify(driver_t driver, device_t bus);
static int acpi_ec_probe(device_t dev);
static int acpi_ec_attach(device_t dev);
static device_method_t acpi_ec_methods[] = {
/* Device interface */
DEVMETHOD(device_identify, acpi_ec_identify),
DEVMETHOD(device_probe, acpi_ec_probe),
DEVMETHOD(device_attach, acpi_ec_attach),
{0, 0}
};
static driver_t acpi_ec_driver = {
"acpi_ec",
acpi_ec_methods,
sizeof(struct acpi_ec_softc),
};
devclass_t acpi_ec_devclass;
DRIVER_MODULE(acpi_ec, acpi, acpi_ec_driver, acpi_ec_devclass, 0, 0);
/*
* Look for an ECDT table and if we find one, set up a default EC
* space handler to catch possible attempts to access EC space before
* we have a real driver instance in place.
* We're not really an identify routine, but because we get called
* before most other things, this works out OK.
*/
static void
acpi_ec_identify(driver_t driver, device_t bus)
{
ACPI_STATUS Status;
/* XXX implement - need an ACPI 2.0 system to test this */
/*
* XXX install a do-nothing handler at the top of the namespace to catch
* bogus accesses being made due to apparent interpreter bugs.
*/
acpi_ec_default.ec_dev = bus;
if ((Status = AcpiInstallAddressSpaceHandler(ACPI_ROOT_OBJECT, ADDRESS_SPACE_EC,
&EcDefaultSpaceHandler, &EcSpaceSetup,
&acpi_ec_default)) != AE_OK) {
device_printf(acpi_ec_default.ec_dev, "can't install default EC address space handler - %s\n",
acpi_strerror(Status));
}
}
/*
* We could setup resources in the probe routine in order to have them printed
* when the device is attached.
*/
static int
acpi_ec_probe(device_t dev)
{
if ((acpi_get_type(dev) == ACPI_TYPE_DEVICE) &&
acpi_MatchHid(dev, "PNP0C09")) {
/*
* Set device description
*/
device_set_desc(dev, "embedded controller");
return(0);
}
return(ENXIO);
}
static int
acpi_ec_attach(device_t dev)
{
struct acpi_ec_softc *sc;
ACPI_BUFFER *bufp;
UINT32 *param;
ACPI_STATUS Status;
struct acpi_object_list *args;
/*
* Fetch/initialise softc
*/
sc = device_get_softc(dev);
sc->ec_dev = dev;
sc->ec_handle = acpi_get_handle(dev);
/*
* Evaluate resources
*/
acpi_parse_resources(sc->ec_dev, sc->ec_handle, &acpi_res_parse_set);
/*
* Attach bus resources
*/
sc->ec_data_rid = 0;
if ((sc->ec_data_res = bus_alloc_resource(sc->ec_dev, SYS_RES_IOPORT, &sc->ec_data_rid,
0, ~0, 1, RF_ACTIVE)) == NULL) {
device_printf(dev, "can't allocate data port\n");
return(ENXIO);
}
sc->ec_data_tag = rman_get_bustag(sc->ec_data_res);
sc->ec_data_handle = rman_get_bushandle(sc->ec_data_res);
sc->ec_csr_rid = 1;
if ((sc->ec_csr_res = bus_alloc_resource(sc->ec_dev, SYS_RES_IOPORT, &sc->ec_csr_rid,
0, ~0, 1, RF_ACTIVE)) == NULL) {
device_printf(dev, "can't allocate command/status port\n");
return(ENXIO);
}
sc->ec_csr_tag = rman_get_bustag(sc->ec_csr_res);
sc->ec_csr_handle = rman_get_bushandle(sc->ec_csr_res);
/*
* Create serialisation semaphore
*/
if ((Status = AcpiOsCreateSemaphore(1, 1, &sc->ec_semaphore)) != AE_OK) {
device_printf(dev, "can't create semaphore - %s\n", acpi_strerror(Status));
return(ENXIO);
}
/*
* Install GPE handler
*
* Evaluate the _GPE method to find the GPE bit used by the EC to signal
* status (SCI).
*/
if ((bufp = acpi_AllocBuffer(16)) == NULL)
return(ENOMEM);
if ((Status = AcpiEvaluateObject(sc->ec_handle, "_GPE", NULL, bufp)) != AE_OK) {
device_printf(dev, "can't evaluate _GPE method - %s\n", acpi_strerror(Status));
return(ENXIO);
}
param = (UINT32 *)bufp->Pointer;
if (param[0] != ACPI_TYPE_NUMBER) {
device_printf(dev, "_GPE method returned bad result\n");
return(ENXIO);
}
sc->ec_gpebit = param[1];
AcpiOsFree(bufp);
/*
* Install a handler for this EC's GPE bit. Note that EC SCIs are
* treated as both edge- and level-triggered interrupts; in other words
* we clear the status bit immediately after getting an EC-SCI, then
* again after we're done processing the event. This guarantees that
* events we cause while performing a transaction (e.g. IBE/OBF) get
* cleared before re-enabling the GPE.
*/
if ((Status = AcpiInstallGpeHandler(sc->ec_gpebit, ACPI_EVENT_LEVEL_TRIGGERED | ACPI_EVENT_EDGE_TRIGGERED,
EcGpeHandler, sc)) != AE_OK) {
device_printf(dev, "can't install GPE handler - %s\n", acpi_strerror(Status));
return(ENXIO);
}
/*
* Install address space handler
*/
if ((Status = AcpiInstallAddressSpaceHandler(sc->ec_handle, ADDRESS_SPACE_EC,
&EcSpaceHandler, &EcSpaceSetup, sc)) != AE_OK) {
device_printf(dev, "can't install address space handler - %s\n", acpi_strerror(Status));
return(ENXIO);
}
/*
* Evaluate _REG to indicate that the region is now available.
*/
if ((args = acpi_AllocObjectList(2)) == NULL)
return(ENOMEM);
args->object[0].Type = ACPI_TYPE_NUMBER;
args->object[0].Number.Value = ADDRESS_SPACE_EC;
args->object[1].Type = ACPI_TYPE_NUMBER;
args->object[1].Number.Value = 1;
Status = AcpiEvaluateObject(sc->ec_handle, "_REG", (ACPI_OBJECT_LIST *)args, NULL);
AcpiOsFree(args);
/*
* If evaluation failed for some reason other than that the method didn't
* exist, that's bad and we should not attach.
*/
if ((Status != AE_OK) && (Status != AE_NOT_FOUND)) {
device_printf(dev, "can't evaluate _REG method - %s\n", acpi_strerror(Status));
return(ENXIO);
}
return(0);
}
static void
EcGpeHandler(void *Context)
{
struct acpi_ec_softc *sc = (struct acpi_ec_softc *)Context;
UINT8 Data;
ACPI_STATUS Status;
char qxx[5];
for (;;) {
/*
* Check EC_SCI.
*
* Bail out if the EC_SCI bit of the status register is not set.
* Note that this function should only be called when
* this bit is set (polling is used to detect IBE/OBF events).
*
* It is safe to do this without locking the controller, as it's
* OK to call EcQuery when there's no data ready; in the worst
* case we should just find nothing waiting for us and bail.
*/
if (!(EC_GET_CSR(sc) & EC_EVENT_SCI))
break;
/*
* Find out why the EC is signalling us
*/
Status = EcQuery(sc, &Data);
/*
* If we failed to get anything from the EC, give up
*/
if (Status != AE_OK) {
device_printf(sc->ec_dev, "GPE query failed - %s\n", acpi_strerror(Status));
break;
}
/*
* Evaluate _Qxx to respond to the controller.
*/
sprintf(qxx, "_Q%02x", Data);
strupr(qxx);
if ((Status - AcpiEvaluateObject(sc->ec_handle, qxx, NULL, NULL)) != AE_OK) {
device_printf(sc->ec_dev, "evaluation of GPE query method %s failed - %s\n",
qxx, acpi_strerror(Status));
}
}
}
static ACPI_STATUS
EcSpaceSetup(ACPI_HANDLE Region, UINT32 Function, void *Context, void **RegionContext)
{
/*
* Just pass the context through, there's nothing to do here.
*/
*RegionContext = Context;
return(AE_OK);
}
static ACPI_STATUS
EcSpaceHandler(UINT32 Function, UINT32 Address, UINT32 width, UINT32 *Value, void *Context, void *RegionContext)
{
struct acpi_ec_softc *sc = (struct acpi_ec_softc *)Context;
ACPI_STATUS Status = AE_OK;
EC_REQUEST EcRequest;
if ((Address > 0xFF) || (width != 8) || (Value == NULL) || (Context == NULL))
return(AE_BAD_PARAMETER);
switch (Function) {
case ADDRESS_SPACE_READ:
EcRequest.Command = EC_COMMAND_READ;
EcRequest.Address = Address;
EcRequest.Data = 0;
break;
case ADDRESS_SPACE_WRITE:
EcRequest.Command = EC_COMMAND_WRITE;
EcRequest.Address = Address;
EcRequest.Data = (UINT8)(*Value);
break;
default:
device_printf(sc->ec_dev, "invalid Address Space function %d\n", Function);
return(AE_BAD_PARAMETER);
}
/*
* Perform the transaction.
*/
if ((Status = EcTransaction(sc, &EcRequest)) == AE_OK)
(*Value) = (UINT32)EcRequest.Data;
return(Status);
}
static ACPI_STATUS
EcDefaultSpaceHandler(UINT32 Function, UINT32 Address, UINT32 width, UINT32 *Value, void *Context, void *RegionContext)
{
if ((Address > 0xFF) || (width != 8) || (Value == NULL) || (Context == NULL))
return(AE_BAD_PARAMETER);
switch (Function) {
case ADDRESS_SPACE_READ:
printf("ACPI: Illegal EC read from 0x%x\n", Address);
*Value = 0;
break;
case ADDRESS_SPACE_WRITE:
printf("ACPI: Illegal EC write 0x%x to 0x%x\n", *Value, Address);
break;
default:
printf("ACPI: Illegal EC unknown operation");
break;
}
/* let things keep going */
return(AE_OK);
}
static ACPI_STATUS
EcWaitEvent(struct acpi_ec_softc *sc, EC_EVENT Event)
{
EC_STATUS EcStatus;
UINT32 i = 0;
if (!EcIsLocked(sc))
device_printf(sc->ec_dev, "EcWaitEvent called without EC lock!\n");
/*
* Stall 1us:
* ----------
* Stall for 1 microsecond before reading the status register
* for the first time. This allows the EC to set the IBF/OBF
* bit to its proper state.
*
* XXX it is not clear why we read the CSR twice.
*/
AcpiOsSleepUsec(1);
EcStatus = EC_GET_CSR(sc);
/*
* Wait For Event:
* ---------------
* Poll the EC status register to detect completion of the last
* command. Wait up to 10ms (in 100us chunks) for this to occur.
*/
for (i = 0; i < 100; i++) {
EcStatus = EC_GET_CSR(sc);
if ((Event == EC_EVENT_OUTPUT_BUFFER_FULL) &&
(EcStatus & EC_FLAG_OUTPUT_BUFFER))
return(AE_OK);
if ((Event == EC_EVENT_INPUT_BUFFER_EMPTY) &&
!(EcStatus & EC_FLAG_INPUT_BUFFER))
return(AE_OK);
AcpiOsSleepUsec(100);
}
return(AE_ERROR);
}
static ACPI_STATUS
EcQuery(struct acpi_ec_softc *sc, UINT8 *Data)
{
ACPI_STATUS Status;
if ((Status = EcLock(sc)) != AE_OK)
return(Status);
EC_SET_CSR(sc, EC_COMMAND_QUERY);
Status = EcWaitEvent(sc, EC_EVENT_OUTPUT_BUFFER_FULL);
if (Status == AE_OK)
*Data = EC_GET_DATA(sc);
EcUnlock(sc);
if (Status != AE_OK)
device_printf(sc->ec_dev, "timeout waiting for EC to respond to EC_COMMAND_QUERY\n");
return(Status);
}
static ACPI_STATUS
EcTransaction(struct acpi_ec_softc *sc, EC_REQUEST *EcRequest)
{
ACPI_STATUS Status;
/*
* Lock the EC
*/
if ((Status = EcLock(sc)) != AE_OK)
return(Status);
/*
* Disable EC GPE:
* ---------------
* Disable EC interrupts (GPEs) from occuring during this transaction.
* This is done here as EcTransaction() is also called by the EC GPE
* handler -- where disabling/re-enabling the EC GPE is automatically
* handled by the ACPI Core Subsystem.
*/
if (AcpiDisableEvent(sc->ec_gpebit, ACPI_EVENT_GPE) != AE_OK)
device_printf(sc->ec_dev, "EcRequest: Unable to disable the EC GPE.\n");
/*
* Perform the transaction.
*/
switch (EcRequest->Command) {
case EC_COMMAND_READ:
Status = EcRead(sc, EcRequest->Address, &(EcRequest->Data));
break;
case EC_COMMAND_WRITE:
Status = EcWrite(sc, EcRequest->Address, &(EcRequest->Data));
break;
default:
Status = AE_SUPPORT;
break;
}
/*
* Clear & Re-Enable the EC GPE:
* -----------------------------
* 'Consume' any EC GPE events that we generated while performing
* the transaction (e.g. IBF/OBF). Clearing the GPE here shouldn't
* have an adverse affect on outstanding EC-SCI's, as the source
* (EC-SCI) will still be high and thus should trigger the GPE
* immediately after we re-enabling it.
*/
if (AcpiClearEvent(sc->ec_gpebit, ACPI_EVENT_GPE) != AE_OK)
device_printf(sc->ec_dev, "EcRequest: Unable to clear the EC GPE.\n");
if (AcpiEnableEvent(sc->ec_gpebit, ACPI_EVENT_GPE) != AE_OK)
device_printf(sc->ec_dev, "EcRequest: Unable to re-enable the EC GPE.\n");
/*
* Unlock the EC
*/
EcUnlock(sc);
return(Status);
}
static ACPI_STATUS
EcRead(struct acpi_ec_softc *sc, UINT8 Address, UINT8 *Data)
{
ACPI_STATUS Status;
if (!EcIsLocked(sc))
device_printf(sc->ec_dev, "EcRead called without EC lock!\n");
/*EcBurstEnable(EmbeddedController);*/
EC_SET_CSR(sc, EC_COMMAND_READ);
if ((Status = EcWaitEvent(sc, EC_EVENT_INPUT_BUFFER_EMPTY)) != AE_OK) {
device_printf(sc->ec_dev, "EcRead: Failed waiting for EC to process read command.\n");
return(Status);
}
EC_SET_DATA(sc, Address);
if ((Status = EcWaitEvent(sc, EC_EVENT_OUTPUT_BUFFER_FULL)) != AE_OK) {
device_printf(sc->ec_dev, "EcRead: Failed waiting for EC to send data.\n");
return(Status);
}
(*Data) = EC_GET_DATA(sc);
/*EcBurstDisable(EmbeddedController);*/
return(AE_OK);
}
static ACPI_STATUS
EcWrite(struct acpi_ec_softc *sc, UINT8 Address, UINT8 *Data)
{
ACPI_STATUS Status;
if (!EcIsLocked(sc))
device_printf(sc->ec_dev, "EcWrite called without EC lock!\n");
/*EcBurstEnable(EmbeddedController);*/
EC_SET_CSR(sc, EC_COMMAND_WRITE);
if ((Status = EcWaitEvent(sc, EC_EVENT_INPUT_BUFFER_EMPTY)) != AE_OK) {
device_printf(sc->ec_dev, "EcWrite: Failed waiting for EC to process write command.\n");
return(Status);
}
EC_SET_DATA(sc, Address);
if ((Status = EcWaitEvent(sc, EC_EVENT_INPUT_BUFFER_EMPTY)) != AE_OK) {
device_printf(sc->ec_dev, "EcRead: Failed waiting for EC to process address.\n");
return(Status);
}
EC_SET_DATA(sc, *Data);
if ((Status = EcWaitEvent(sc, EC_EVENT_INPUT_BUFFER_EMPTY)) != AE_OK) {
device_printf(sc->ec_dev, "EcWrite: Failed waiting for EC to process data.\n");
return(Status);
}
/*EcBurstDisable(EmbeddedController);*/
return(AE_OK);
}

196
sys/dev/acpica/acpi_ecreg.h Normal file
View File

@ -0,0 +1,196 @@
/*-
* Copyright (c) 2000 Michael Smith
* Copyright (c) 2000 BSDi
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $FreeBSD$
*/
/******************************************************************************
*
* 1. Copyright Notice
*
* Some or all of this work - Copyright (c) 1999, Intel Corp. All rights
* reserved.
*
* 2. License
*
* 2.1. This is your license from Intel Corp. under its intellectual property
* rights. You may have additional license terms from the party that provided
* you this software, covering your right to use that party's intellectual
* property rights.
*
* 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
* copy of the source code appearing in this file ("Covered Code") an
* irrevocable, perpetual, worldwide license under Intel's copyrights in the
* base code distributed originally by Intel ("Original Intel Code") to copy,
* make derivatives, distribute, use and display any portion of the Covered
* Code in any form, with the right to sublicense such rights; and
*
* 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
* license (with the right to sublicense), under only those claims of Intel
* patents that are infringed by the Original Intel Code, to make, use, sell,
* offer to sell, and import the Covered Code and derivative works thereof
* solely to the minimum extent necessary to exercise the above copyright
* license, and in no event shall the patent license extend to any additions
* to or modifications of the Original Intel Code. No other license or right
* is granted directly or by implication, estoppel or otherwise;
*
* The above copyright and patent license is granted only if the following
* conditions are met:
*
* 3. Conditions
*
* 3.1. Redistribution of Source with Rights to Further Distribute Source.
* Redistribution of source code of any substantial portion of the Covered
* Code or modification with rights to further distribute source must include
* the above Copyright Notice, the above License, this list of Conditions,
* and the following Disclaimer and Export Compliance provision. In addition,
* Licensee must cause all Covered Code to which Licensee contributes to
* contain a file documenting the changes Licensee made to create that Covered
* Code and the date of any change. Licensee must include in that file the
* documentation of any changes made by any predecessor Licensee. Licensee
* must include a prominent statement that the modification is derived,
* directly or indirectly, from Original Intel Code.
*
* 3.2. Redistribution of Source with no Rights to Further Distribute Source.
* Redistribution of source code of any substantial portion of the Covered
* Code or modification without rights to further distribute source must
* include the following Disclaimer and Export Compliance provision in the
* documentation and/or other materials provided with distribution. In
* addition, Licensee may not authorize further sublicense of source of any
* portion of the Covered Code, and must include terms to the effect that the
* license from Licensee to its licensee is limited to the intellectual
* property embodied in the software Licensee provides to its licensee, and
* not to intellectual property embodied in modifications its licensee may
* make.
*
* 3.3. Redistribution of Executable. Redistribution in executable form of any
* substantial portion of the Covered Code or modification must reproduce the
* above Copyright Notice, and the following Disclaimer and Export Compliance
* provision in the documentation and/or other materials provided with the
* distribution.
*
* 3.4. Intel retains all right, title, and interest in and to the Original
* Intel Code.
*
* 3.5. Neither the name Intel nor any other trademark owned or controlled by
* Intel shall be used in advertising or otherwise to promote the sale, use or
* other dealings in products derived from or relating to the Covered Code
* without prior written authorization from Intel.
*
* 4. Disclaimer and Export Compliance
*
* 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
* HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
* IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
* INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
* UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
* IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
* PARTICULAR PURPOSE.
*
* 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
* OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
* COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
* SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
* CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
* HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
* SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
* LIMITED REMEDY.
*
* 4.3. Licensee shall not export, either directly or indirectly, any of this
* software or system incorporating such software without first obtaining any
* required license or other approval from the U. S. Department of Commerce or
* any other agency or department of the United States Government. In the
* event Licensee exports any such software from the United States or
* re-exports any such software from a foreign destination, Licensee shall
* ensure that the distribution and export/re-export of the software is in
* compliance with all laws, regulations, orders, or other restrictions of the
* U.S. Export Administration Regulations. Licensee agrees that neither it nor
* any of its subsidiaries will export/re-export any technical data, process,
* software, or service, directly or indirectly, to any country for which the
* United States government or any agency thereof requires an export license,
* other governmental approval, or letter of assurance, without first obtaining
* such license, approval or letter.
*
*****************************************************************************/
/*
* EC_COMMAND:
* -----------
*/
typedef UINT8 EC_COMMAND;
#define EC_COMMAND_UNKNOWN ((EC_COMMAND) 0x00)
#define EC_COMMAND_READ ((EC_COMMAND) 0x80)
#define EC_COMMAND_WRITE ((EC_COMMAND) 0x81)
#define EC_COMMAND_BURST_ENABLE ((EC_COMMAND) 0x82)
#define EC_COMMAND_BURST_DISABLE ((EC_COMMAND) 0x83)
#define EC_COMMAND_QUERY ((EC_COMMAND) 0x84)
/*
* EC_STATUS:
* ----------
* The encoding of the EC status register is illustrated below.
* Note that a set bit (1) indicates the property is TRUE
* (e.g. if bit 0 is set then the output buffer is full).
* +-+-+-+-+-+-+-+-+
* |7|6|5|4|3|2|1|0|
* +-+-+-+-+-+-+-+-+
* | | | | | | | |
* | | | | | | | +- Output Buffer Full?
* | | | | | | +--- Input Buffer Full?
* | | | | | +----- <reserved>
* | | | | +------- Data Register is Command Byte?
* | | | +--------- Burst Mode Enabled?
* | | +----------- SCI Event?
* | +------------- SMI Event?
* +--------------- <Reserved>
*
*/
typedef UINT8 EC_STATUS;
#define EC_FLAG_OUTPUT_BUFFER ((EC_STATUS) 0x01)
#define EC_FLAG_INPUT_BUFFER ((EC_STATUS) 0x02)
#define EC_FLAG_BURST_MODE ((EC_STATUS) 0x10)
#define EC_FLAG_SCI ((EC_STATUS) 0x20)
/*
* EC_EVENT:
* ---------
*/
typedef UINT8 EC_EVENT;
#define EC_EVENT_UNKNOWN ((EC_EVENT) 0x00)
#define EC_EVENT_OUTPUT_BUFFER_FULL ((EC_EVENT) 0x01)
#define EC_EVENT_INPUT_BUFFER_EMPTY ((EC_EVENT) 0x02)
#define EC_EVENT_SCI ((EC_EVENT) 0x20)
/*
* Register access primitives
*/
#define EC_GET_DATA(sc) bus_space_read_1 (sc->ec_data_tag, sc->ec_data_handle, 0)
#define EC_SET_DATA(sc, v) bus_space_write_1(sc->ec_data_tag, sc->ec_data_handle, 0, v)
#define EC_GET_CSR(sc) bus_space_read_1 (sc->ec_csr_tag, sc->ec_csr_handle, 0)
#define EC_SET_CSR(sc, v) bus_space_write_1(sc->ec_csr_tag, sc->ec_csr_handle, 0, v)

442
sys/dev/acpica/acpi_isa.c Normal file
View File

@ -0,0 +1,442 @@
/*-
* Copyright (c) 2000 Michael Smith
* Copyright (c) 2000 BSDi
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $FreeBSD$
*/
/*
* ISA bus enumerator using PnP HIDs from ACPI space.
*/
#include "opt_acpi.h"
#include <sys/param.h>
#include <sys/kernel.h>
#include <sys/malloc.h>
#include <sys/bus.h>
#include <isa/isavar.h>
#include "acpi.h"
#include <dev/acpica/acpivar.h>
#define PNP_HEXTONUM(c) ((c) >= 'a' \
? (c) - 'a' + 10 \
: ((c) >= 'A' \
? (c) - 'A' + 10 \
: (c) - '0'))
#define PNP_EISAID(s) \
((((s[0] - '@') & 0x1f) << 2) \
| (((s[1] - '@') & 0x18) >> 3) \
| (((s[1] - '@') & 0x07) << 13) \
| (((s[2] - '@') & 0x1f) << 8) \
| (PNP_HEXTONUM(s[4]) << 16) \
| (PNP_HEXTONUM(s[3]) << 20) \
| (PNP_HEXTONUM(s[6]) << 24) \
| (PNP_HEXTONUM(s[5]) << 28))
static void acpi_isa_set_init(device_t dev, void **context);
static void acpi_isa_set_done(device_t dev, void *context);
static void acpi_isa_set_ioport(device_t dev, void *context, u_int32_t base, u_int32_t length);
static void acpi_isa_set_iorange(device_t dev, void *context, u_int32_t low, u_int32_t high,
u_int32_t length, u_int32_t align);
static void acpi_isa_set_memory(device_t dev, void *context, u_int32_t base, u_int32_t length);
static void acpi_isa_set_memoryrange(device_t dev, void *context, u_int32_t low, u_int32_t high,
u_int32_t length, u_int32_t align);
static void acpi_isa_set_irq(device_t dev, void *context, u_int32_t irq);
static void acpi_isa_set_drq(device_t dev, void *context, u_int32_t drq);
static void acpi_isa_set_start_dependant(device_t dev, void *context, int preference);
static void acpi_isa_set_end_dependant(device_t dev, void *context);
static struct acpi_parse_resource_set acpi_isa_parse_set = {
acpi_isa_set_init,
acpi_isa_set_done,
acpi_isa_set_ioport,
acpi_isa_set_iorange,
acpi_isa_set_memory,
acpi_isa_set_memoryrange,
acpi_isa_set_irq,
acpi_isa_set_drq,
acpi_isa_set_start_dependant,
acpi_isa_set_end_dependant
};
#define MAXDEP 8
struct acpi_isa_context {
int ai_config;
int ai_nconfigs;
struct isa_config ai_configs[MAXDEP + 1];
int ai_priorities[MAXDEP + 1];
};
static void acpi_isa_set_config(void *arg, struct isa_config *config, int enable);
static void acpi_isa_identify(driver_t *driver, device_t bus);
static ACPI_STATUS acpi_isa_identify_child(ACPI_HANDLE handle, UINT32 level,
void *context, void **status);
static device_method_t acpi_isa_methods[] = {
DEVMETHOD(device_identify, acpi_isa_identify),
{0, 0}
};
static driver_t acpi_isa_driver = {
"acpi_isa",
acpi_isa_methods,
1,
};
static devclass_t acpi_isa_devclass;
DRIVER_MODULE(acpi_isa, isa, acpi_isa_driver, acpi_isa_devclass, 0, 0);
/*
* This function is called to make the selected configuration
* active.
*/
static void
acpi_isa_set_config(void *arg, struct isa_config *config, int enable)
{
}
/*
* Interrogate ACPI for devices which might be attatched to an ISA
* bus.
*
* Note that it is difficult to determine whether a device in the ACPI
* namespace is or is not visible to the ISA bus, and thus we are a
* little too generous here and just export everything with _HID
* and _CRS.
*/
static void
acpi_isa_identify(driver_t *driver, device_t bus)
{
ACPI_HANDLE parent;
ACPI_STATUS status;
/*
* Look for the _SB_ scope, which will contain all the devices
* we are likely to support.
*/
if ((status = AcpiGetHandle(ACPI_ROOT_OBJECT, "\\_SB_", &parent)) != AE_OK) {
device_printf(bus, "no ACPI _SB_ scope - %s\n", acpi_strerror(status));
return;
}
if ((status = AcpiWalkNamespace(ACPI_TYPE_DEVICE, parent, 100, acpi_isa_identify_child, bus, NULL)) != AE_OK) {
device_printf(bus, "AcpiWalkNamespace on _SB_ failed - %s\n", acpi_strerror(status));
return;
}
}
/*
* Check a device to see whether it makes sense to try attaching it to an
* ISA bus, and if so, do so.
*
* Note that we *must* always return AE_OK, or the namespace walk will terminate.
*
* XXX Note also that this is picking up a *lot* of things that are not ISA devices.
* Should we consider lazy-binding this so that only the ID is saved and resources
* are not parsed until the device is claimed by a driver?
*/
static ACPI_STATUS
acpi_isa_identify_child(ACPI_HANDLE handle, UINT32 level, void *context, void **status)
{
ACPI_DEVICE_INFO devinfo;
ACPI_BUFFER buf;
device_t child, bus = (device_t)context;
u_int32_t devid;
/*
* Try to get information about the device
*/
if (AcpiGetObjectInfo(handle, &devinfo) != AE_OK)
return(AE_OK);
/*
* Reformat the _HID value into 32 bits.
*/
if (!(devinfo.Valid & ACPI_VALID_HID))
return(AE_OK);
/*
* XXX Try to avoid passing stuff to ISA that it just isn't interested
* in. This is the *wrong* solution, and what needs to be done
* involves just sending ISA the PnP ID and a handle, and then
* lazy-parsing the resources if and only if a driver attaches.
* With the way that ISA currently works (using bus_probe_and_attach)
* this is very difficult. Maybe we need a device_configure method?
*/
if (!(strncmp(devinfo.HardwareId, "PNP0C", 5)))
return(AE_OK);
devid = PNP_EISAID(devinfo.HardwareId);
/* XXX check _STA here? */
if (devinfo.Valid & ACPI_VALID_STA) {
}
/*
* Fetch our current settings.
*
* XXX Note that we may want to support alternate settings at some
* point as well.
*/
if (acpi_GetIntoBuffer(handle, AcpiGetCurrentResources, &buf) != AE_OK)
return(AE_OK);
/*
* Add the device and parse our resources
*/
child = BUS_ADD_CHILD(bus, ISA_ORDER_PNP, NULL, -1);
isa_set_vendorid(child, devid);
isa_set_logicalid(child, devid);
ISA_SET_CONFIG_CALLBACK(bus, child, acpi_isa_set_config, 0);
acpi_parse_resources(child, handle, &acpi_isa_parse_set);
AcpiOsFree(buf.Pointer);
if (!device_get_desc(child))
device_set_desc_copy(child, devinfo.HardwareId);
/*
* XXX Parse configuration data and _CID list to find compatible IDs
*/
return(AE_OK);
}
static void
acpi_isa_set_init(device_t dev, void **context)
{
struct acpi_isa_context *cp;
cp = malloc(sizeof(*cp), M_DEVBUF, M_NOWAIT);
bzero(cp, sizeof(*cp));
cp->ai_nconfigs = 1;
*context = cp;
}
static void
acpi_isa_set_done(device_t dev, void *context)
{
struct acpi_isa_context *cp = (struct acpi_isa_context *)context;
struct isa_config *config, *configs;
device_t parent;
int i, j;
if (cp == NULL)
return;
parent = device_get_parent(dev);
/* simple config without dependants */
if (cp->ai_nconfigs == 1) {
ISA_ADD_CONFIG(parent, dev, cp->ai_priorities[0], &cp->ai_configs[0]);
goto done;
}
/* Cycle through dependant configs merging primary details */
configs = &cp->ai_configs[0];
for(i = 1; i < cp->ai_nconfigs; i++) {
config = &configs[i];
for(j = 0; j < configs[0].ic_nmem; j++) {
if (config->ic_nmem == ISA_NMEM) {
device_printf(parent, "too many memory ranges\n");
free(configs, M_DEVBUF);
return;
}
config->ic_mem[config->ic_nmem] = configs[0].ic_mem[j];
config->ic_nmem++;
}
for(j = 0; j < configs[0].ic_nport; j++) {
if (config->ic_nport == ISA_NPORT) {
device_printf(parent, "too many port ranges\n");
free(configs, M_DEVBUF);
return;
}
config->ic_port[config->ic_nport] = configs[0].ic_port[j];
config->ic_nport++;
}
for(j = 0; j < configs[0].ic_nirq; j++) {
if (config->ic_nirq == ISA_NIRQ) {
device_printf(parent, "too many irq ranges\n");
free(configs, M_DEVBUF);
return;
}
config->ic_irqmask[config->ic_nirq] = configs[0].ic_irqmask[j];
config->ic_nirq++;
}
for(j = 0; j < configs[0].ic_ndrq; j++) {
if (config->ic_ndrq == ISA_NDRQ) {
device_printf(parent, "too many drq ranges\n");
free(configs, M_DEVBUF);
return;
}
config->ic_drqmask[config->ic_ndrq] = configs[0].ic_drqmask[j];
config->ic_ndrq++;
}
(void)ISA_ADD_CONFIG(parent, dev, cp->ai_priorities[i], &configs[i]);
}
done:
free(cp, M_DEVBUF);
}
static void
acpi_isa_set_ioport(device_t dev, void *context, u_int32_t base, u_int32_t length)
{
struct acpi_isa_context *cp = (struct acpi_isa_context *)context;
struct isa_config *ic = &cp->ai_configs[cp->ai_config];
if (cp == NULL)
return;
if (ic->ic_nport == ISA_NPORT) {
printf("too many ports\n");
return;
}
ic->ic_port[ic->ic_nport].ir_start = base;
ic->ic_port[ic->ic_nport].ir_end = base + length - 1;
ic->ic_port[ic->ic_nport].ir_size = length;
ic->ic_port[ic->ic_nport].ir_align = 1;
ic->ic_nport++;
}
static void
acpi_isa_set_iorange(device_t dev, void *context, u_int32_t low, u_int32_t high, u_int32_t length, u_int32_t align)
{
struct acpi_isa_context *cp = (struct acpi_isa_context *)context;
struct isa_config *ic = &cp->ai_configs[cp->ai_config];
if (cp == NULL)
return;
if (ic->ic_nport == ISA_NPORT) {
printf("too many ports\n");
return;
}
ic->ic_port[ic->ic_nport].ir_start = low;
ic->ic_port[ic->ic_nport].ir_end = high + length - 1;
ic->ic_port[ic->ic_nport].ir_size = length;
ic->ic_port[ic->ic_nport].ir_align = imin(1, align);
ic->ic_nport++;
}
static void
acpi_isa_set_memory(device_t dev, void *context, u_int32_t base, u_int32_t length)
{
struct acpi_isa_context *cp = (struct acpi_isa_context *)context;
struct isa_config *ic = &cp->ai_configs[cp->ai_config];
if (cp == NULL)
return;
if (ic->ic_nmem == ISA_NMEM) {
printf("too many memory ranges\n");
return;
}
ic->ic_mem[ic->ic_nmem].ir_start = base;
ic->ic_mem[ic->ic_nmem].ir_end = base + length - 1;
ic->ic_mem[ic->ic_nmem].ir_size = length;
ic->ic_mem[ic->ic_nmem].ir_align = 1;
ic->ic_nmem++;
}
static void
acpi_isa_set_memoryrange(device_t dev, void *context, u_int32_t low, u_int32_t high, u_int32_t length, u_int32_t align)
{
struct acpi_isa_context *cp = (struct acpi_isa_context *)context;
struct isa_config *ic = &cp->ai_configs[cp->ai_config];
if (cp == NULL)
return;
if (ic->ic_nmem == ISA_NMEM) {
printf("too many memory ranges\n");
return;
}
ic->ic_mem[ic->ic_nmem].ir_start = low;
ic->ic_mem[ic->ic_nmem].ir_end = high + length - 1;
ic->ic_mem[ic->ic_nmem].ir_size = length;
ic->ic_mem[ic->ic_nmem].ir_align = imin(1, align);
ic->ic_nmem++;
}
static void
acpi_isa_set_irq(device_t dev, void *context, u_int32_t irq)
{
struct acpi_isa_context *cp = (struct acpi_isa_context *)context;
struct isa_config *ic = &cp->ai_configs[cp->ai_config];
if (cp == NULL)
return;
if (ic->ic_nirq == ISA_NIRQ) {
printf("too many IRQs\n");
return;
}
ic->ic_irqmask[ic->ic_nirq] = 1 << irq;
ic->ic_nirq++;
}
static void
acpi_isa_set_drq(device_t dev, void *context, u_int32_t drq)
{
struct acpi_isa_context *cp = (struct acpi_isa_context *)context;
struct isa_config *ic = &cp->ai_configs[cp->ai_config];
if (cp == NULL)
return;
if (ic->ic_nirq == ISA_NDRQ) {
printf("too many DRQs\n");
return;
}
ic->ic_drqmask[ic->ic_ndrq] = drq;
ic->ic_ndrq++;
}
/*
* XXX the "too many dependant configs" logic here is wrong, and
* will spam the last dependant config.
*/
static void
acpi_isa_set_start_dependant(device_t dev, void *context, int preference)
{
struct acpi_isa_context *cp = (struct acpi_isa_context *)context;
if (cp == NULL)
return;
if (cp->ai_nconfigs > MAXDEP) {
printf("too many dependant configs\n");
return;
}
cp->ai_config = cp->ai_nconfigs;
cp->ai_priorities[cp->ai_config] = preference;
cp->ai_nconfigs++;
}
static void
acpi_isa_set_end_dependant(device_t dev, void *context)
{
struct acpi_isa_context *cp = (struct acpi_isa_context *)context;
if (cp == NULL)
return;
cp->ai_config = 0;
}

152
sys/dev/acpica/acpi_lid.c Normal file
View File

@ -0,0 +1,152 @@
/*-
* Copyright (c) 2000 Takanori Watanabe <takawata@jp.freebsd.org>
* Copyright (c) 2000 Mitsuru IWASAKI <iwasaki@jp.freebsd.org>
* Copyright (c) 2000 Michael Smith <msmith@freebd.org>
* Copyright (c) 2000 BSDi
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $FreeBSD$
*/
#include "opt_acpi.h"
#include <sys/param.h>
#include <sys/kernel.h>
#include <sys/bus.h>
#include "acpi.h"
#include <dev/acpica/acpivar.h>
struct acpi_lid_softc {
device_t lid_dev;
ACPI_HANDLE lid_handle;
int lid_status; /* open or closed */
};
static int acpi_lid_probe(device_t dev);
static int acpi_lid_attach(device_t dev);
static void acpi_lid_notify_status_changed(void *arg);
static void acpi_lid_notify_handler(ACPI_HANDLE h,UINT32 notify, void *context);
static device_method_t acpi_lid_methods[] = {
/* Device interface */
DEVMETHOD(device_probe, acpi_lid_probe),
DEVMETHOD(device_attach, acpi_lid_attach),
{0, 0}
};
static driver_t acpi_lid_driver = {
"acpi_lid",
acpi_lid_methods,
sizeof(struct acpi_lid_softc),
};
devclass_t acpi_lid_devclass;
DRIVER_MODULE(acpi_lid, acpi, acpi_lid_driver, acpi_lid_devclass, 0, 0);
static int
acpi_lid_probe(device_t dev)
{
if ((acpi_get_type(dev) == ACPI_TYPE_DEVICE) &&
acpi_MatchHid(dev, "PNP0C0D")) {
device_set_desc(dev, "Control Method Lid Switch");
return(0);
}
return(ENXIO);
}
static int
acpi_lid_attach(device_t dev)
{
struct acpi_lid_softc *sc;
sc = device_get_softc(dev);
sc->lid_dev = dev;
sc->lid_handle = acpi_get_handle(dev);
/*
* Install notification handler
*/
AcpiInstallNotifyHandler(sc->lid_handle, ACPI_DEVICE_NOTIFY, acpi_lid_notify_handler, sc);
return(0);
}
static void
acpi_lid_notify_status_changed(void *arg)
{
struct acpi_lid_softc *sc;
struct acpi_softc *acpi_sc;
ACPI_BUFFER Buffer;
ACPI_OBJECT Object;
sc = (struct acpi_lid_softc *)arg;
/*
* Evaluate _LID and check the return value
* Zero: The lid is closed
* Non-zero: The lid is open
*/
Buffer.Length = sizeof(Object);
Buffer.Pointer = &Object;
if (AcpiEvaluateObject(sc->lid_handle, "_LID", NULL, &Buffer) != AE_OK)
return;
if (Object.Type != ACPI_TYPE_NUMBER)
return;
/*
* Update lid status
*/
sc->lid_status = Object.Number.Value;
device_printf(sc->lid_dev, "Lid %s\n", sc->lid_status ? "opened" : "closed");
acpi_sc = acpi_device_get_parent_softc(sc->lid_dev);
if (acpi_sc == NULL) {
return;
}
if (sc->lid_status == 0) {
EVENTHANDLER_INVOKE(acpi_sleep_event, acpi_sc->acpi_lid_switch_sx);
} else {
EVENTHANDLER_INVOKE(acpi_wakeup_event, acpi_sc->acpi_lid_switch_sx);
}
}
/* XXX maybe not here */
#define ACPI_NOTIFY_STATUS_CHANGED 0x80
static void
acpi_lid_notify_handler(ACPI_HANDLE h, UINT32 notify, void *context)
{
struct acpi_lid_softc *sc = (struct acpi_lid_softc *)context;
switch (notify) {
case ACPI_NOTIFY_STATUS_CHANGED:
AcpiOsQueueForExecution(OSD_PRIORITY_LO, acpi_lid_notify_status_changed, sc);
break;
default:
return; /* unknown notification value */
}
}

236
sys/dev/acpica/acpi_pcib.c Normal file
View File

@ -0,0 +1,236 @@
/*-
* Copyright (c) 2000 Michael Smith
* Copyright (c) 2000 BSDi
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $FreeBSD$
*/
#include "opt_acpi.h"
#include <sys/param.h>
#include <sys/kernel.h>
#include <sys/bus.h>
#include "acpi.h"
#include <dev/acpica/acpivar.h>
#include <machine/pci_cfgreg.h>
#include <pci/pcivar.h>
#include "pcib_if.h"
struct acpi_pcib_softc {
device_t ap_dev;
ACPI_HANDLE ap_handle;
int ap_segment; /* analagous to Alpha 'hose' */
int ap_bus; /* bios-assigned bus number */
};
static int acpi_pcib_probe(device_t bus);
static int acpi_pcib_attach(device_t bus);
static int acpi_pcib_read_ivar(device_t dev, device_t child, int which, uintptr_t *result);
static int acpi_pcib_write_ivar(device_t dev, device_t child, int which, uintptr_t value);
static int acpi_pcib_maxslots(device_t dev);
static u_int32_t acpi_pcib_read_config(device_t dev, int bus, int slot, int func, int reg, int bytes);
static void acpi_pcib_write_config(device_t dev, int bus, int slot, int func, int reg,
u_int32_t data, int bytes);
static int acpi_pcib_route_interrupt(device_t bus, int device, int pin);
static device_method_t acpi_pcib_methods[] = {
/* Device interface */
DEVMETHOD(device_probe, acpi_pcib_probe),
DEVMETHOD(device_attach, acpi_pcib_attach),
DEVMETHOD(device_shutdown, bus_generic_shutdown),
DEVMETHOD(device_suspend, bus_generic_suspend),
DEVMETHOD(device_resume, bus_generic_resume),
/* Bus interface */
DEVMETHOD(bus_print_child, bus_generic_print_child),
DEVMETHOD(bus_read_ivar, acpi_pcib_read_ivar),
DEVMETHOD(bus_write_ivar, acpi_pcib_write_ivar),
DEVMETHOD(bus_alloc_resource, bus_generic_alloc_resource),
DEVMETHOD(bus_release_resource, bus_generic_release_resource),
DEVMETHOD(bus_activate_resource, bus_generic_activate_resource),
DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource),
DEVMETHOD(bus_setup_intr, bus_generic_setup_intr),
DEVMETHOD(bus_teardown_intr, bus_generic_teardown_intr),
/* pcib interface */
DEVMETHOD(pcib_maxslots, acpi_pcib_maxslots),
DEVMETHOD(pcib_read_config, acpi_pcib_read_config),
DEVMETHOD(pcib_write_config, acpi_pcib_write_config),
DEVMETHOD(pcib_route_interrupt, acpi_pcib_route_interrupt),
{0, 0}
};
static driver_t acpi_pcib_driver = {
"acpi_pcib",
acpi_pcib_methods,
sizeof(struct acpi_pcib_softc),
};
devclass_t acpi_pcib_devclass;
DRIVER_MODULE(acpi_pcib, acpi, acpi_pcib_driver, acpi_pcib_devclass, 0, 0);
static int
acpi_pcib_probe(device_t dev)
{
if ((acpi_get_type(dev) == ACPI_TYPE_DEVICE) &&
acpi_MatchHid(dev, "PNP0A03")) {
/*
* Set device description
*/
device_set_desc(dev, "Host-PCI bridge");
return(0);
}
return(ENXIO);
}
static int
acpi_pcib_attach(device_t dev)
{
struct acpi_pcib_softc *sc;
device_t child;
ACPI_STATUS status;
sc = device_get_softc(dev);
sc->ap_dev = dev;
sc->ap_handle = acpi_get_handle(dev);
/*
* Don't attach if we're not really there.
*
* XXX this isn't entirely correct, since we may be a PCI bus
* on a hot-plug docking station, etc.
*/
if (!acpi_DeviceIsPresent(dev))
return(ENXIO);
/*
* Get our segment number by evaluating _SEG
* It's OK for this to not exist.
*/
if ((status = acpi_EvaluateNumber(sc->ap_handle, "_SEG", &sc->ap_segment)) != AE_OK) {
if (status != AE_NOT_FOUND) {
device_printf(dev, "could not evaluate _SEG - %s\n", acpi_strerror(status));
return(ENXIO);
}
/* if it's not found, assume 0 */
sc->ap_segment = 0;
}
/*
* Get our base bus number by evaluating _BBN
* If this doesn't exist, we assume we're bus number 0.
*
* XXX note that it may also not exist in the case where we are
* meant to use a private configuration space mechanism for this bus,
* so we should dig out our resources and check to see if we have
* anything like that. How do we do this?
*/
if ((status = acpi_EvaluateNumber(sc->ap_handle, "_BBN", &sc->ap_bus)) != AE_OK) {
if (status != AE_NOT_FOUND) {
device_printf(dev, "could not evaluate _BBN - %s\n", acpi_strerror(status));
return(ENXIO);
}
/* if it's not found, assume 0 */
sc->ap_bus = 0;
}
/*
* XXX we should check here to make sure that this bus number hasn't already
* been attached. It shouldn't really be an issue.
*/
if ((child = device_add_child(dev, "pci", sc->ap_bus)) == NULL) {
device_printf(device_get_parent(dev), "couldn't attach pci bus");
return(ENXIO);
}
/*
* XXX If we have the requisite information, and if we don't think the
* default PCI configuration space handlers can deal with this bus,
* we should attach our own handler.
*/
/* XXX invoke _REG on this for the PCI config space address space? */
/*
* Now go scan the bus.
*
* XXX is it possible to defer this and count on the nexus getting to it
* reliably after it's finished with ACPI? Should we really care?
*/
return(bus_generic_attach(dev));
}
static int
acpi_pcib_maxslots(device_t dev)
{
return(31);
}
static int
acpi_pcib_read_ivar(device_t dev, device_t child, int which, uintptr_t *result)
{
struct acpi_pcib_softc *sc = device_get_softc(dev);
switch (which) {
case PCIB_IVAR_BUS:
*result = sc->ap_bus;
return(0);
}
return(ENOENT);
}
static int
acpi_pcib_write_ivar(device_t dev, device_t child, int which, uintptr_t value)
{
struct acpi_pcib_softc *sc = device_get_softc(dev);
switch (which) {
case PCIB_IVAR_BUS:
sc->ap_bus = value;
return(0);
}
return(ENOENT);
}
static u_int32_t
acpi_pcib_read_config(device_t dev, int bus, int slot, int func, int reg, int bytes)
{
return(pci_cfgregread(bus, slot, func, reg, bytes));
}
static void
acpi_pcib_write_config(device_t dev, int bus, int slot, int func, int reg, u_int32_t data, int bytes)
{
pci_cfgregwrite(bus, slot, func, reg, data, bytes);
}
static int
acpi_pcib_route_interrupt(device_t bus, int device, int pin)
{
return(255); /* XXX implement */
}

236
sys/dev/acpica/acpi_pcib_acpi.c Normal file
View File

@ -0,0 +1,236 @@
/*-
* Copyright (c) 2000 Michael Smith
* Copyright (c) 2000 BSDi
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $FreeBSD$
*/
#include "opt_acpi.h"
#include <sys/param.h>
#include <sys/kernel.h>
#include <sys/bus.h>
#include "acpi.h"
#include <dev/acpica/acpivar.h>
#include <machine/pci_cfgreg.h>
#include <pci/pcivar.h>
#include "pcib_if.h"
struct acpi_pcib_softc {
device_t ap_dev;
ACPI_HANDLE ap_handle;
int ap_segment; /* analagous to Alpha 'hose' */
int ap_bus; /* bios-assigned bus number */
};
static int acpi_pcib_probe(device_t bus);
static int acpi_pcib_attach(device_t bus);
static int acpi_pcib_read_ivar(device_t dev, device_t child, int which, uintptr_t *result);
static int acpi_pcib_write_ivar(device_t dev, device_t child, int which, uintptr_t value);
static int acpi_pcib_maxslots(device_t dev);
static u_int32_t acpi_pcib_read_config(device_t dev, int bus, int slot, int func, int reg, int bytes);
static void acpi_pcib_write_config(device_t dev, int bus, int slot, int func, int reg,
u_int32_t data, int bytes);
static int acpi_pcib_route_interrupt(device_t bus, int device, int pin);
static device_method_t acpi_pcib_methods[] = {
/* Device interface */
DEVMETHOD(device_probe, acpi_pcib_probe),
DEVMETHOD(device_attach, acpi_pcib_attach),
DEVMETHOD(device_shutdown, bus_generic_shutdown),
DEVMETHOD(device_suspend, bus_generic_suspend),
DEVMETHOD(device_resume, bus_generic_resume),
/* Bus interface */
DEVMETHOD(bus_print_child, bus_generic_print_child),
DEVMETHOD(bus_read_ivar, acpi_pcib_read_ivar),
DEVMETHOD(bus_write_ivar, acpi_pcib_write_ivar),
DEVMETHOD(bus_alloc_resource, bus_generic_alloc_resource),
DEVMETHOD(bus_release_resource, bus_generic_release_resource),
DEVMETHOD(bus_activate_resource, bus_generic_activate_resource),
DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource),
DEVMETHOD(bus_setup_intr, bus_generic_setup_intr),
DEVMETHOD(bus_teardown_intr, bus_generic_teardown_intr),
/* pcib interface */
DEVMETHOD(pcib_maxslots, acpi_pcib_maxslots),
DEVMETHOD(pcib_read_config, acpi_pcib_read_config),
DEVMETHOD(pcib_write_config, acpi_pcib_write_config),
DEVMETHOD(pcib_route_interrupt, acpi_pcib_route_interrupt),
{0, 0}
};
static driver_t acpi_pcib_driver = {
"acpi_pcib",
acpi_pcib_methods,
sizeof(struct acpi_pcib_softc),
};
devclass_t acpi_pcib_devclass;
DRIVER_MODULE(acpi_pcib, acpi, acpi_pcib_driver, acpi_pcib_devclass, 0, 0);
static int
acpi_pcib_probe(device_t dev)
{
if ((acpi_get_type(dev) == ACPI_TYPE_DEVICE) &&
acpi_MatchHid(dev, "PNP0A03")) {
/*
* Set device description
*/
device_set_desc(dev, "Host-PCI bridge");
return(0);
}
return(ENXIO);
}
static int
acpi_pcib_attach(device_t dev)
{
struct acpi_pcib_softc *sc;
device_t child;
ACPI_STATUS status;
sc = device_get_softc(dev);
sc->ap_dev = dev;
sc->ap_handle = acpi_get_handle(dev);
/*
* Don't attach if we're not really there.
*
* XXX this isn't entirely correct, since we may be a PCI bus
* on a hot-plug docking station, etc.
*/
if (!acpi_DeviceIsPresent(dev))
return(ENXIO);
/*
* Get our segment number by evaluating _SEG
* It's OK for this to not exist.
*/
if ((status = acpi_EvaluateNumber(sc->ap_handle, "_SEG", &sc->ap_segment)) != AE_OK) {
if (status != AE_NOT_FOUND) {
device_printf(dev, "could not evaluate _SEG - %s\n", acpi_strerror(status));
return(ENXIO);
}
/* if it's not found, assume 0 */
sc->ap_segment = 0;
}
/*
* Get our base bus number by evaluating _BBN
* If this doesn't exist, we assume we're bus number 0.
*
* XXX note that it may also not exist in the case where we are
* meant to use a private configuration space mechanism for this bus,
* so we should dig out our resources and check to see if we have
* anything like that. How do we do this?
*/
if ((status = acpi_EvaluateNumber(sc->ap_handle, "_BBN", &sc->ap_bus)) != AE_OK) {
if (status != AE_NOT_FOUND) {
device_printf(dev, "could not evaluate _BBN - %s\n", acpi_strerror(status));
return(ENXIO);
}
/* if it's not found, assume 0 */
sc->ap_bus = 0;
}
/*
* XXX we should check here to make sure that this bus number hasn't already
* been attached. It shouldn't really be an issue.
*/
if ((child = device_add_child(dev, "pci", sc->ap_bus)) == NULL) {
device_printf(device_get_parent(dev), "couldn't attach pci bus");
return(ENXIO);
}
/*
* XXX If we have the requisite information, and if we don't think the
* default PCI configuration space handlers can deal with this bus,
* we should attach our own handler.
*/
/* XXX invoke _REG on this for the PCI config space address space? */
/*
* Now go scan the bus.
*
* XXX is it possible to defer this and count on the nexus getting to it
* reliably after it's finished with ACPI? Should we really care?
*/
return(bus_generic_attach(dev));
}
static int
acpi_pcib_maxslots(device_t dev)
{
return(31);
}
static int
acpi_pcib_read_ivar(device_t dev, device_t child, int which, uintptr_t *result)
{
struct acpi_pcib_softc *sc = device_get_softc(dev);
switch (which) {
case PCIB_IVAR_BUS:
*result = sc->ap_bus;
return(0);
}
return(ENOENT);
}
static int
acpi_pcib_write_ivar(device_t dev, device_t child, int which, uintptr_t value)
{
struct acpi_pcib_softc *sc = device_get_softc(dev);
switch (which) {
case PCIB_IVAR_BUS:
sc->ap_bus = value;
return(0);
}
return(ENOENT);
}
static u_int32_t
acpi_pcib_read_config(device_t dev, int bus, int slot, int func, int reg, int bytes)
{
return(pci_cfgregread(bus, slot, func, reg, bytes));
}
static void
acpi_pcib_write_config(device_t dev, int bus, int slot, int func, int reg, u_int32_t data, int bytes)
{
pci_cfgregwrite(bus, slot, func, reg, data, bytes);
}
static int
acpi_pcib_route_interrupt(device_t bus, int device, int pin)
{
return(255); /* XXX implement */
}

640
sys/dev/acpica/acpi_processor.c Normal file
View File

@ -0,0 +1,640 @@
/*-
* Copyright (c) 2000 Michael Smith
* Copyright (c) 2000 BSDi
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $FreeBSD$
*/
/******************************************************************************
*
* 1. Copyright Notice
*
* Some or all of this work - Copyright (c) 1999, Intel Corp. All rights
* reserved.
*
* 2. License
*
* 2.1. This is your license from Intel Corp. under its intellectual property
* rights. You may have additional license terms from the party that provided
* you this software, covering your right to use that party's intellectual
* property rights.
*
* 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
* copy of the source code appearing in this file ("Covered Code") an
* irrevocable, perpetual, worldwide license under Intel's copyrights in the
* base code distributed originally by Intel ("Original Intel Code") to copy,
* make derivatives, distribute, use and display any portion of the Covered
* Code in any form, with the right to sublicense such rights; and
*
* 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
* license (with the right to sublicense), under only those claims of Intel
* patents that are infringed by the Original Intel Code, to make, use, sell,
* offer to sell, and import the Covered Code and derivative works thereof
* solely to the minimum extent necessary to exercise the above copyright
* license, and in no event shall the patent license extend to any additions
* to or modifications of the Original Intel Code. No other license or right
* is granted directly or by implication, estoppel or otherwise;
*
* The above copyright and patent license is granted only if the following
* conditions are met:
*
* 3. Conditions
*
* 3.1. Redistribution of Source with Rights to Further Distribute Source.
* Redistribution of source code of any substantial portion of the Covered
* Code or modification with rights to further distribute source must include
* the above Copyright Notice, the above License, this list of Conditions,
* and the following Disclaimer and Export Compliance provision. In addition,
* Licensee must cause all Covered Code to which Licensee contributes to
* contain a file documenting the changes Licensee made to create that Covered
* Code and the date of any change. Licensee must include in that file the
* documentation of any changes made by any predecessor Licensee. Licensee
* must include a prominent statement that the modification is derived,
* directly or indirectly, from Original Intel Code.
*
* 3.2. Redistribution of Source with no Rights to Further Distribute Source.
* Redistribution of source code of any substantial portion of the Covered
* Code or modification without rights to further distribute source must
* include the following Disclaimer and Export Compliance provision in the
* documentation and/or other materials provided with distribution. In
* addition, Licensee may not authorize further sublicense of source of any
* portion of the Covered Code, and must include terms to the effect that the
* license from Licensee to its licensee is limited to the intellectual
* property embodied in the software Licensee provides to its licensee, and
* not to intellectual property embodied in modifications its licensee may
* make.
*
* 3.3. Redistribution of Executable. Redistribution in executable form of any
* substantial portion of the Covered Code or modification must reproduce the
* above Copyright Notice, and the following Disclaimer and Export Compliance
* provision in the documentation and/or other materials provided with the
* distribution.
*
* 3.4. Intel retains all right, title, and interest in and to the Original
* Intel Code.
*
* 3.5. Neither the name Intel nor any other trademark owned or controlled by
* Intel shall be used in advertising or otherwise to promote the sale, use or
* other dealings in products derived from or relating to the Covered Code
* without prior written authorization from Intel.
*
* 4. Disclaimer and Export Compliance
*
* 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
* HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
* IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
* INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
* UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
* IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
* PARTICULAR PURPOSE.
*
* 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
* OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
* COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
* SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
* CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
* HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
* SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
* LIMITED REMEDY.
*
* 4.3. Licensee shall not export, either directly or indirectly, any of this
* software or system incorporating such software without first obtaining any
* required license or other approval from the U. S. Department of Commerce or
* any other agency or department of the United States Government. In the
* event Licensee exports any such software from the United States or
* re-exports any such software from a foreign destination, Licensee shall
* ensure that the distribution and export/re-export of the software is in
* compliance with all laws, regulations, orders, or other restrictions of the
* U.S. Export Administration Regulations. Licensee agrees that neither it nor
* any of its subsidiaries will export/re-export any technical data, process,
* software, or service, directly or indirectly, to any country for which the
* United States government or any agency thereof requires an export license,
* other governmental approval, or letter of assurance, without first obtaining
* such license, approval or letter.
*
*****************************************************************************/
/*
* Processor driver.
*
* XXX Note that the power state code here is almost certainly suboptimal.
* We should go raid the Linux code for their ideas and experience.
*
* Code style here is a hairy mix of BSD-like and Intel-like. Should be
* sanitised at some point.
*/
#include "opt_acpi.h"
#include <sys/param.h>
#include <sys/kernel.h>
#include <sys/bus.h>
#include "acpi.h"
#include <dev/acpica/acpivar.h>
#define PR_MAX_POWER_STATES 4
#define PR_MAX_PERFORMANCE_STATES 8
#define PR_MAX_THROTTLING_STATES 8
/*
* Processor Commands:
* -------------------
*/
#define PR_COMMAND_GET_INFO ((BM_COMMAND) 0x80)
#define PR_COMMAND_SET_CX_STATE_INFO ((BM_COMMAND) 0x81)
#define PR_COMMAND_GET_THROTTLING_STATE ((BM_COMMAND) 0x82)
#define PR_COMMAND_SET_THROTTLING_STATE ((BM_COMMAND) 0x83)
#define PR_COMMAND_GET_PERF_STATE ((BM_COMMAND) 0x84)
#define PR_COMMAND_SET_PERF_STATE ((BM_COMMAND) 0x85)
#define PR_COMMAND_GET_CURRENT_FREQ ((BM_COMMAND) 0x86)
/*
* PR_POWER_STATE:
* ---------------
*/
typedef u_int32_t PR_POWER_STATE;
#define PR_POWER_STATE_UNKNOWN ((PR_POWER_STATE) 0xFFFFFFFF)
#define PR_POWER_STATE_C0 ((PR_POWER_STATE) 0x00000000)
#define PR_POWER_STATE_C1 ((PR_POWER_STATE) 0x00000001)
#define PR_POWER_STATE_C2 ((PR_POWER_STATE) 0x00000002)
#define PR_POWER_STATE_C3 ((PR_POWER_STATE) 0x00000003)
/*
* Processor Notifications:
* ------------------------
*/
#define PR_NOTIFY_PERF_STATES_CHANGE ((BM_NOTIFY) 0x80)
#define PR_NOTIFY_POWER_STATES_CHANGE ((BM_NOTIFY) 0x81)
typedef struct
{
u_int32_t TimeThreshold;
u_int32_t CountThreshold;
u_int32_t Count;
PR_POWER_STATE TargetState;
} PR_POLICY_VALUES;
/*
* PR_CX_STATE_INFO:
* -----------------
*/
typedef struct
{
u_int32_t Latency;
u_int64_t Utilization;
PR_POLICY_VALUES PromotionPolicy;
PR_POLICY_VALUES DemotionPolicy;
} PR_CX_STATE_INFO;
/*
* PR_POWER_INFO:
* --------------
*/
typedef struct
{
u_int32_t Count;
PR_POWER_STATE ActiveState;
PR_CX_STATE_INFO Info[PR_MAX_POWER_STATES];
} PR_POWER_INFO;
/*
* PR_PERFORMANCE_INFO:
* --------------------
*/
typedef struct
{
u_int32_t Count;
/* TODO... */
} PR_PERFORMANCE_INFO;
/*
* PR_THROTTLING_INFO:
* -------------------
*/
typedef struct
{
u_int32_t Count;
u_int32_t Percentage[PR_MAX_THROTTLING_STATES];
} PR_THROTTLING_INFO;
struct acpi_pr_softc {
device_t pr_dev;
ACPI_HANDLE pr_handle;
PR_POWER_INFO pr_PowerStates;
PR_PERFORMANCE_INFO pr_PerformanceStates;
PR_THROTTLING_INFO pr_ThrottlingStates;
eventhandler_tag pr_idleevent;
/* local APIC data */
PROCESSOR_APIC pr_lapic;
};
#define PR_MAGIC 0x20555043 /* "CPU " */
static void acpi_pr_identify(driver_t *driver, device_t bus);
static ACPI_STATUS acpi_pr_identify_cpu(ACPI_HANDLE handle, UINT32 level, void *context, void **status);
static int acpi_pr_probe(device_t dev);
static int acpi_pr_attach(device_t dev);
static void acpi_pr_FindLapic(device_t dev, ACPI_HANDLE handle, PROCESSOR_APIC *lapic);
static ACPI_STATUS acpi_pr_CalculatePowerStates(struct acpi_pr_softc *sc);
static ACPI_STATUS acpi_pr_CalculatePerformanceStates(struct acpi_pr_softc *sc);
static ACPI_STATUS acpi_pr_CalculateThrottlingStates(struct acpi_pr_softc *sc);
static void acpi_pr_IdleHandler(void *arg, int count);
static ACPI_STATUS acpi_pr_PolicyInitialize(struct acpi_pr_softc *sc);
static device_method_t acpi_pr_methods[] = {
/* Device interface */
DEVMETHOD(device_identify, acpi_pr_identify),
DEVMETHOD(device_probe, acpi_pr_probe),
DEVMETHOD(device_attach, acpi_pr_attach),
{0, 0}
};
static driver_t acpi_pr_driver = {
"acpi_pr",
acpi_pr_methods,
sizeof(struct acpi_pr_softc),
};
devclass_t acpi_pr_devclass;
DRIVER_MODULE(acpi_pr, acpi, acpi_pr_driver, acpi_pr_devclass, 0, 0);
/*
* Scan the \_PR_ scope for processor objects, and attach them accordingly.
*
* XXX note that we should find the local APIC address and obtain a resource
* that we can hand to child devices for access to it...
*/
static void
acpi_pr_identify(driver_t *driver, device_t bus)
{
ACPI_HANDLE handle;
if (AcpiGetHandle(ACPI_ROOT_OBJECT, "\\_PR_", &handle) == AE_OK)
AcpiWalkNamespace(ACPI_TYPE_PROCESSOR, handle, 2, acpi_pr_identify_cpu, bus, NULL);
}
/*
* Create a child device for CPUs
*/
static ACPI_STATUS
acpi_pr_identify_cpu(ACPI_HANDLE handle, UINT32 level, void *context, void **status)
{
device_t bus = (device_t)context;
device_t child;
PROCESSOR_APIC lapic;
acpi_pr_FindLapic(bus, handle, &lapic);
if (lapic.ProcessorEnabled) {
if ((child = BUS_ADD_CHILD(bus, 0, "acpi_pr", -1)) == NULL) {
device_printf(bus, "could not create CPU device\n");
return(AE_OK);
}
acpi_set_handle(child, handle);
acpi_set_magic(child, PR_MAGIC);
device_set_desc(child, "processor device");
}
return(AE_OK);
}
static int
acpi_pr_probe(device_t dev)
{
if (acpi_get_magic(dev) == PR_MAGIC)
return(0);
return(ENXIO);
}
static int
acpi_pr_attach(device_t dev)
{
struct acpi_pr_softc *sc;
sc = device_get_softc(dev);
sc->pr_dev = dev;
sc->pr_handle = acpi_get_handle(dev);
acpi_pr_FindLapic(dev, sc->pr_handle, &sc->pr_lapic);
/*
* If the APIC information is valid, print it
*/
if (sc->pr_lapic.LocalApicId != (UINT8)0xff)
device_printf(dev, "local APIC ID %d\n", sc->pr_lapic.LocalApicId);
/*
* Fetch operational parameters.
*/
if (acpi_pr_CalculatePowerStates(sc) == AE_OK) {
acpi_pr_PolicyInitialize(sc);
}
acpi_pr_CalculatePerformanceStates(sc);
acpi_pr_CalculateThrottlingStates(sc);
/* XXX call MD cpu-identification here? */
return(0);
}
/*
* Find the Local Apic information for this CPU
*/
static void
acpi_pr_FindLapic(device_t dev, ACPI_HANDLE handle, PROCESSOR_APIC *lapic)
{
ACPI_BUFFER buf;
ACPI_STATUS status;
APIC_HEADER *hdr;
APIC_TABLE *tbl;
PROCESSOR_APIC *pap;
int len, cpuno;
/*
* Assume that we're not going to suceed in finding/parsing the APIC table.
* In this case, CPU 0 is valid, and any other CPU is invalid.
*/
lapic->LocalApicId = 0xff;
lapic->ProcessorEnabled = 0;
if ((status = AcpiGetProcessorId(handle, &cpuno)) != AE_OK) {
device_printf(dev, "error fetching CPU device ID - %s\n", acpi_strerror(status));
return;
}
lapic->ProcessorEnabled = (cpuno == 0);
/*
* Perform the tedious double-get to fetch the actual APIC table, and suck it in.
*/
buf.Length = 0;
buf.Pointer = NULL;
if ((status = AcpiGetTable(ACPI_TABLE_APIC, 1, &buf)) != AE_BUFFER_OVERFLOW) {
if (status != AE_NOT_EXIST)
device_printf(dev, "error sizing APIC table - %s\n", acpi_strerror(status));
return;
}
if ((buf.Pointer = AcpiOsAllocate(buf.Length)) == NULL)
return;
if ((status = AcpiGetTable(ACPI_TABLE_APIC, 1, &buf)) != AE_OK) {
device_printf(dev, "error fetching APIC table - %s\n", acpi_strerror(status));
return;
}
/*
* Scan the tables looking for this CPU index.
*/
tbl = (APIC_TABLE *)buf.Pointer;
len = tbl->header.Length - sizeof(APIC_TABLE);
hdr = (APIC_HEADER *)((char *)buf.Pointer + sizeof(APIC_TABLE));
while(len > 0) {
if (hdr->Length > len) {
device_printf(dev, "APIC header corrupt (claims %d bytes where only %d left in structure)\n",
hdr->Length, len);
break;
}
/*
* If we have found a processor APIC definition with
* matching CPU index, copy it out and return.
*/
if (hdr->Type == APIC_PROC) {
pap = (PROCESSOR_APIC *)hdr;
if (pap->ProcessorApicId == cpuno) {
bcopy(pap, lapic, sizeof(*pap));
break;
}
}
len -= hdr->Length;
hdr = (APIC_HEADER *)((char *)hdr + hdr->Length);
}
AcpiOsFree(buf.Pointer);
}
static ACPI_STATUS
acpi_pr_CalculatePowerStates(struct acpi_pr_softc *sc)
{
ACPI_STATUS Status = AE_OK;
ACPI_BUFFER Buffer;
ACPI_CX_STATE *State = NULL;
u_int32_t StateCount = 0;
u_int32_t i = 0;
/*
* Set Latency Defaults:
* ---------------------
* Default state latency to ACPI_UINT32_MAX -- meaning that this state
* should not be used by policy. This value is overriden by states
* that are present and have usable latencies (e.g. <= 1000us for C3).
*/
for (i = 0; i < PR_MAX_POWER_STATES; i++)
sc->pr_PowerStates.Info[i].Latency = ACPI_UINT32_MAX;
/*
* Get Power State Latencies:
* --------------------------
*
* XXX Note that ACPICA will never give us back C2 if it costs more than 100us,
* or C3 if it costs more than 1000us, so some of this code is redundant.
*/
Status = acpi_GetIntoBuffer(sc->pr_handle, AcpiGetProcessorCxInfo, &Buffer);
if (Status != AE_OK) {
device_printf(sc->pr_dev, "could not fetch ProcessorCxInfo - %s\n", acpi_strerror(Status));
return(Status);
}
State = (ACPI_CX_STATE*)(Buffer.Pointer);
if (State != NULL) {
device_printf(sc->pr_dev, "supported power states:");
StateCount = Buffer.Length / sizeof(ACPI_CX_STATE);
for (i = 0; i < StateCount; i++) {
/* XXX C3 isn't supportable in MP configurations, how to best handle this? */
if ((State[i].StateNumber < PR_MAX_POWER_STATES) && (State[i].Latency <= 1000)) {
printf(" C%d (%dus)", i, State[i].Latency);
sc->pr_PowerStates.Info[State[i].StateNumber].Latency = State[i].Latency;
}
}
printf("\n");
}
sc->pr_PowerStates.Count = PR_MAX_POWER_STATES;
sc->pr_PowerStates.ActiveState = PR_POWER_STATE_C1;
AcpiOsFree(Buffer.Pointer);
return(Status);
}
static ACPI_STATUS
acpi_pr_CalculatePerformanceStates(struct acpi_pr_softc *sc)
{
ACPI_STATUS Status = AE_OK;
/* TODO... */
return(Status);
}
static ACPI_STATUS
acpi_pr_CalculateThrottlingStates(struct acpi_pr_softc *sc)
{
ACPI_STATUS Status = AE_OK;
ACPI_BUFFER Buffer;
ACPI_CPU_THROTTLING_STATE *State = NULL;
u_int32_t StateCount = 0;
u_int32_t i = 0;
/*
* Get Throttling States:
* ----------------------
*/
Status = acpi_GetIntoBuffer(sc->pr_handle, AcpiGetProcessorThrottlingInfo, &Buffer);
if (Status != AE_OK) {
device_printf(sc->pr_dev, "could not fetch ThrottlingInfo - %s\n", acpi_strerror(Status));
return(Status);
}
State = (ACPI_CPU_THROTTLING_STATE*)(Buffer.Pointer);
if (State != NULL) {
StateCount = Buffer.Length / sizeof(ACPI_CPU_THROTTLING_STATE);
device_printf(sc->pr_dev, "supported throttling states:");
for (i = 0; i < StateCount; i++) {
if (State[i].StateNumber < PR_MAX_THROTTLING_STATES) {
/* TODO: Verify that state is *really* supported by this chipset/processor (e.g. errata). */
sc->pr_ThrottlingStates.Percentage[State[i].StateNumber] = State[i].PercentOfClock;
sc->pr_ThrottlingStates.Count++;
printf(" %d%%", State[i].PercentOfClock);
}
}
printf("\n");
}
AcpiOsFree(Buffer.Pointer);
return(Status);
}
static ACPI_STATUS
acpi_pr_PolicyInitialize(struct acpi_pr_softc *sc)
{
ACPI_STATUS status;
if ((status = AcpiSetProcessorSleepState(sc->pr_handle, sc->pr_PowerStates.ActiveState)) != AE_OK) {
device_printf(sc->pr_dev, "could not set Active sleep state - %s\n", acpi_strerror(status));
return(status);
}
/* XXX need to hook ourselves to be called when things go idle */
/* sc->pr_idleevent = EVENTHANDLER_FAST_REGISTER(idle_event, acpi_pr_IdleHandler, sc, IDLE_PRI_FIRST); */
return(AE_OK);
}
static void
acpi_pr_IdleHandler(void *arg, int count)
{
struct acpi_pr_softc *sc = (struct acpi_pr_softc *)arg;
ACPI_STATUS Status = AE_OK;
PR_CX_STATE_INFO *CxState = NULL;
PR_POWER_STATE ActiveState = PR_POWER_STATE_UNKNOWN;
PR_POWER_STATE NextState = PR_POWER_STATE_UNKNOWN;
u_int32_t PmTimerTicks = 0;
ActiveState = NextState = sc->pr_PowerStates.ActiveState;
CxState = &(sc->pr_PowerStates.Info[ActiveState]);
CxState->Utilization++;
/*
* Invoke Cx State:
* ----------------
*/
if ((Status = AcpiProcessorSleep(sc->pr_handle, &PmTimerTicks)) != AE_OK) {
device_printf(sc->pr_dev, "AcpiProcessorSleep() failed - %s\n", acpi_strerror(Status));
/*
* Something went wrong with the sleep attempt, so give up on trying to do this.
*/
/* EVENTHANDLER_FAST_DEREGISTER(idle_event, sc->pr_idleevent);*/
device_printf(sc->pr_dev, "disabling CPU power saving\n");
return;
}
/*
* Check For State Promotion:
* --------------------------
* Only need to check for promotion on C1 and C2, and then only
* when the state has a non-zero count threshold and target state.
*/
if (CxState->PromotionPolicy.CountThreshold && CxState->PromotionPolicy.TargetState &&
((ActiveState == PR_POWER_STATE_C1) || (ActiveState == PR_POWER_STATE_C2))) {
/*
* Check the amount of time we spent in the Cx state against our
* promotion policy. If successful (asleep longer than our threshold)
* increment our count and see if a promotion is in order.
*/
if (PmTimerTicks > (CxState->PromotionPolicy.TimeThreshold)) {
CxState->PromotionPolicy.Count++;
CxState->DemotionPolicy.Count = 0;
if (CxState->PromotionPolicy.Count >= CxState->PromotionPolicy.CountThreshold)
NextState = CxState->PromotionPolicy.TargetState;
}
}
/*
* Check For State Demotion:
* -------------------------
* Only need to check for demotion on C2 and C3, and then only
* when the state has a non-zero count threshold and target state.
*/
if (CxState->DemotionPolicy.CountThreshold && CxState->DemotionPolicy.TargetState &&
((ActiveState == PR_POWER_STATE_C2) || (ActiveState == PR_POWER_STATE_C3))) {
/*
* Check the amount of time we spent in the Cx state against our
* demotion policy. If unsuccessful (asleep shorter than our threshold)
* increment our count and see if a demotion is in order.
*/
if (PmTimerTicks < (CxState->DemotionPolicy.TimeThreshold)) {
CxState->DemotionPolicy.Count++;
CxState->PromotionPolicy.Count = 0;
if (CxState->DemotionPolicy.Count >= CxState->DemotionPolicy.CountThreshold)
NextState = CxState->DemotionPolicy.TargetState;
}
}
/*
* New Cx State?
* -------------
* If so, clean up from the previous Cx state (if necessary).
*/
if (NextState != sc->pr_PowerStates.ActiveState) {
if ((Status = AcpiSetProcessorSleepState(sc->pr_handle, NextState)) != AE_OK) {
device_printf(sc->pr_dev, "AcpiSetProcessorSleepState() returned error [0x%08X]\n", Status);
} else {
CxState->PromotionPolicy.Count = 0;
CxState->DemotionPolicy.Count = 0;
sc->pr_PowerStates.ActiveState = NextState;
}
}
}

343
sys/dev/acpica/acpi_resource.c Normal file
View File

@ -0,0 +1,343 @@
/*-
* Copyright (c) 2000 Michael Smith
* Copyright (c) 2000 BSDi
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $FreeBSD$
*/
#include "opt_acpi.h"
#include <sys/param.h>
#include <sys/kernel.h>
#include <sys/bus.h>
#include <machine/bus.h>
#include <machine/resource.h>
#include "acpi.h"
#include <dev/acpica/acpivar.h>
/*
* Fetch a device's resources and associate them with the device.
*
* Note that it might be nice to also locate ACPI-specific resource items, such
* as GPE bits.
*/
ACPI_STATUS
acpi_parse_resources(device_t dev, ACPI_HANDLE handle, struct acpi_parse_resource_set *set)
{
ACPI_BUFFER buf;
RESOURCE *res;
char *curr, *last;
ACPI_STATUS status;
int i;
void *context;
/*
* Fetch the device resources
*/
if (((status = acpi_GetIntoBuffer(handle, AcpiGetPossibleResources, &buf)) != AE_OK) &&
((status = acpi_GetIntoBuffer(handle, AcpiGetCurrentResources, &buf)) != AE_OK)) {
device_printf(dev, "can't fetch ACPI resources - %s\n", acpi_strerror(status));
return(status);
}
#ifdef ACPI_RES_DEBUG
device_printf(dev, "got %d bytes of resources\n", buf.Length);
#endif
set->set_init(dev, &context);
/*
* Iterate through the resources
*/
curr = buf.Pointer;
last = (char *)buf.Pointer + buf.Length;
while (curr < last) {
res = (RESOURCE *)curr;
curr += res->Length;
/*
* Handle the individual resource types
*/
switch(res->Id) {
case EndTag:
#ifdef ACPI_RES_DEBUG
device_printf(dev, "EndTag\n");
#endif
curr = last;
break;
case FixedIo:
#ifdef ACPI_RES_DEBUG
device_printf(dev, "FixedIo 0x%x/%d\n", res->Data.FixedIo.BaseAddress, res->Data.FixedIo.RangeLength);
#endif
set->set_ioport(dev, context, res->Data.FixedIo.BaseAddress, res->Data.FixedIo.RangeLength);
break;
case Io:
if (res->Data.Io.MinBaseAddress == res->Data.Io.MaxBaseAddress) {
#ifdef ACPI_RES_DEBUG
device_printf(dev, "Io 0x%x/%d\n", res->Data.Io.MinBaseAddress, res->Data.Io.RangeLength);
#endif
set->set_ioport(dev, context, res->Data.Io.MinBaseAddress, res->Data.Io.RangeLength);
} else {
#ifdef ACPI_RES_DEBUG
device_printf(dev, "Io 0x%x-0x%x/%d\n", res->Data.Io.MinBaseAddress, res->Data.Io.MaxBaseAddress,
res->Data.Io.RangeLength);
#endif
set->set_iorange(dev, context, res->Data.Io.MinBaseAddress, res->Data.Io.MaxBaseAddress,
res->Data.Io.RangeLength, res->Data.Io.Alignment);
}
break;
case FixedMemory32:
#ifdef ACPI_RES_DEBUG
device_printf(dev, "FixedMemory32 0x%x/%d\n", res->Data.FixedMemory32.RangeBaseAddress,
res->Data.FixedMemory32.RangeLength);
#endif
set->set_memory(dev, context, res->Data.FixedMemory32.RangeBaseAddress,
res->Data.FixedMemory32.RangeLength);
break;
case Memory32:
if (res->Data.Memory32.MinBaseAddress == res->Data.Memory32.MaxBaseAddress) {
#ifdef ACPI_RES_DEBUG
device_printf(dev, "Memory32 0x%x/%d\n", res->Data.Memory32.MinBaseAddress,
res->Data.Memory32.RangeLength);
#endif
set->set_memory(dev, context, res->Data.Memory32.MinBaseAddress, res->Data.Memory32.RangeLength);
} else {
#ifdef ACPI_RES_DEBUG
device_printf(dev, "Memory32 0x%x-0x%x/%d\n", res->Data.Memory32.MinBaseAddress,
res->Data.Memory32.MaxBaseAddress, res->Data.Memory32.RangeLength);
#endif
set->set_memoryrange(dev, context, res->Data.Memory32.MinBaseAddress, res->Data.Memory32.MaxBaseAddress,
res->Data.Memory32.RangeLength, res->Data.Memory32.Alignment);
}
break;
case Memory24:
if (res->Data.Memory24.MinBaseAddress == res->Data.Memory24.MaxBaseAddress) {
#ifdef ACPI_RES_DEBUG
device_printf(dev, "Memory24 0x%x/%d\n", res->Data.Memory24.MinBaseAddress,
res->Data.Memory24.RangeLength);
#endif
set->set_memory(dev, context, res->Data.Memory24.MinBaseAddress, res->Data.Memory24.RangeLength);
} else {
#ifdef ACPI_RES_DEBUG
device_printf(dev, "Memory24 0x%x-0x%x/%d\n", res->Data.Memory24.MinBaseAddress,
res->Data.Memory24.MaxBaseAddress, res->Data.Memory24.RangeLength);
#endif
set->set_memoryrange(dev, context, res->Data.Memory24.MinBaseAddress, res->Data.Memory24.MaxBaseAddress,
res->Data.Memory24.RangeLength, res->Data.Memory24.Alignment);
}
break;
case Irq:
for (i = 0; i < res->Data.Irq.NumberOfInterrupts; i++) {
#ifdef ACPI_RES_DEBUG
device_printf(dev, "Irq %d\n", res->Data.Irq.Interrupts[i]);
#endif
set->set_irq(dev, context, res->Data.Irq.Interrupts[i]);
}
break;
case Dma:
for (i = 0; i < res->Data.Dma.NumberOfChannels; i++) {
#ifdef ACPI_RES_DEBUG
device_printf(dev, "Drq %d\n", res->Data.Dma.Channels[i]);
#endif
set->set_drq(dev, context, res->Data.Dma.Channels[i]);
}
break;
case StartDependentFunctions:
#ifdef ACPI_RES_DEBUG
device_printf(dev, "start dependant functions");
#endif
set->set_start_dependant(dev, context, res->Data.StartDependentFunctions.CompatibilityPriority);
break;
case EndDependentFunctions:
#ifdef ACPI_RES_DEBUG
device_printf(dev, "end dependant functions");
#endif
set->set_end_dependant(dev, context);
break;
case Address32:
device_printf(dev, "unimplemented Address32 resource\n");
break;
case Address16:
device_printf(dev, "unimplemented Address16 resource\n");
break;
case ExtendedIrq:
device_printf(dev, "unimplemented ExtendedIrq resource\n");
break;
case VendorSpecific:
device_printf(dev, "unimplemented VendorSpecific resource\n");
break;
default:
break;
}
}
AcpiOsFree(buf.Pointer);
set->set_done(dev, context);
return(AE_OK);
}
static void acpi_res_set_init(device_t dev, void **context);
static void acpi_res_set_done(device_t dev, void *context);
static void acpi_res_set_ioport(device_t dev, void *context, u_int32_t base, u_int32_t length);
static void acpi_res_set_iorange(device_t dev, void *context, u_int32_t low, u_int32_t high,
u_int32_t length, u_int32_t align);
static void acpi_res_set_memory(device_t dev, void *context, u_int32_t base, u_int32_t length);
static void acpi_res_set_memoryrange(device_t dev, void *context, u_int32_t low, u_int32_t high,
u_int32_t length, u_int32_t align);
static void acpi_res_set_irq(device_t dev, void *context, u_int32_t irq);
static void acpi_res_set_drq(device_t dev, void *context, u_int32_t drq);
static void acpi_res_set_start_dependant(device_t dev, void *context, int preference);
static void acpi_res_set_end_dependant(device_t dev, void *context);
struct acpi_parse_resource_set acpi_res_parse_set = {
acpi_res_set_init,
acpi_res_set_done,
acpi_res_set_ioport,
acpi_res_set_iorange,
acpi_res_set_memory,
acpi_res_set_memoryrange,
acpi_res_set_irq,
acpi_res_set_drq,
acpi_res_set_start_dependant,
acpi_res_set_end_dependant
};
struct acpi_res_context {
int ar_nio;
int ar_nmem;
int ar_nirq;
};
static void
acpi_res_set_init(device_t dev, void **context)
{
struct acpi_res_context *cp;
if ((cp = AcpiOsAllocate(sizeof(*cp))) != NULL) {
bzero(cp, sizeof(*cp));
*context = cp;
}
}
static void
acpi_res_set_done(device_t dev, void *context)
{
struct acpi_res_context *cp = (struct acpi_res_context *)context;
if (cp == NULL)
return;
AcpiOsFree(cp);
}
static void
acpi_res_set_ioport(device_t dev, void *context, u_int32_t base, u_int32_t length)
{
struct acpi_res_context *cp = (struct acpi_res_context *)context;
if (cp == NULL)
return;
bus_set_resource(dev, SYS_RES_IOPORT, cp->ar_nio++, base, length);
}
static void
acpi_res_set_iorange(device_t dev, void *context, u_int32_t low, u_int32_t high, u_int32_t length, u_int32_t align)
{
struct acpi_res_context *cp = (struct acpi_res_context *)context;
if (cp == NULL)
return;
device_printf(dev, "I/O range not supported\n");
}
static void
acpi_res_set_memory(device_t dev, void *context, u_int32_t base, u_int32_t length)
{
struct acpi_res_context *cp = (struct acpi_res_context *)context;
if (cp == NULL)
return;
bus_set_resource(dev, SYS_RES_MEMORY, cp->ar_nmem++, base, length);
}
static void
acpi_res_set_memoryrange(device_t dev, void *context, u_int32_t low, u_int32_t high, u_int32_t length, u_int32_t align)
{
struct acpi_res_context *cp = (struct acpi_res_context *)context;
if (cp == NULL)
return;
device_printf(dev, "memory range not supported\n");
}
static void
acpi_res_set_irq(device_t dev, void *context, u_int32_t irq)
{
struct acpi_res_context *cp = (struct acpi_res_context *)context;
if (cp == NULL)
return;
bus_set_resource(dev, SYS_RES_IRQ, cp->ar_nirq++, irq, 1);
}
static void
acpi_res_set_drq(device_t dev, void *context, u_int32_t drq)
{
struct acpi_res_context *cp = (struct acpi_res_context *)context;
if (cp == NULL)
return;
device_printf(dev, "DRQ not supported\n");
}
static void
acpi_res_set_start_dependant(device_t dev, void *context, int preference)
{
struct acpi_res_context *cp = (struct acpi_res_context *)context;
if (cp == NULL)
return;
device_printf(dev, "dependant functions not supported");
}
static void
acpi_res_set_end_dependant(device_t dev, void *context)
{
struct acpi_res_context *cp = (struct acpi_res_context *)context;
if (cp == NULL)
return;
}

102
sys/dev/acpica/acpi_thermal.c Normal file
View File

@ -0,0 +1,102 @@
/*-
* Copyright (c) 2000 Michael Smith
* Copyright (c) 2000 BSDi
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $FreeBSD$
*/
#include "opt_acpi.h"
#include <sys/param.h>
#include <sys/kernel.h>
#include <sys/bus.h>
#include "acpi.h"
#include <dev/acpica/acpivar.h>
#define TZ_KELVTOC(x) (((x) - 2732) / 10), (((x) - 2732) % 10)
struct acpi_tz_softc {
device_t tz_dev;
ACPI_HANDLE tz_handle;
};
static int acpi_tz_probe(device_t dev);
static int acpi_tz_attach(device_t dev);
static device_method_t acpi_tz_methods[] = {
/* Device interface */
DEVMETHOD(device_probe, acpi_tz_probe),
DEVMETHOD(device_attach, acpi_tz_attach),
{0, 0}
};
static driver_t acpi_tz_driver = {
"acpi_tz",
acpi_tz_methods,
sizeof(struct acpi_tz_softc),
};
devclass_t acpi_tz_devclass;
DRIVER_MODULE(acpi_tz, acpi, acpi_tz_driver, acpi_tz_devclass, 0, 0);
static int
acpi_tz_probe(device_t dev)
{
if (acpi_get_type(dev) == ACPI_TYPE_THERMAL) {
device_set_desc(dev, "thermal zone");
return(0);
}
return(ENXIO);
}
static int
acpi_tz_attach(device_t dev)
{
struct acpi_tz_softc *sc;
UINT32 param[4];
ACPI_BUFFER buf;
ACPI_STATUS status;
sc = device_get_softc(dev);
sc->tz_dev = dev;
sc->tz_handle = acpi_get_handle(dev);
buf.Pointer = &param[0];
buf.Length = sizeof(param);
if ((status = AcpiEvaluateObject(sc->tz_handle, "_TMP", NULL, &buf)) != AE_OK) {
device_printf(sc->tz_dev, "can't fetch temperature - %s\n", acpi_strerror(status));
return(ENXIO);
}
if (param[0] != ACPI_TYPE_NUMBER) {
device_printf(sc->tz_dev, "%s._TMP does not evaluate to ACPI_TYPE_NUMBER\n",
acpi_name(sc->tz_handle));
return(ENXIO);
}
device_printf(sc->tz_dev, "current temperature %d.%dC\n", TZ_KELVTOC(param[1]));
return(0);
}

117
sys/dev/acpica/acpi_timer.c Normal file
View File

@ -0,0 +1,117 @@
/*-
* Copyright (c) 2000 Michael Smith
* Copyright (c) 2000 BSDi
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $FreeBSD$
*/
#include "opt_acpi.h"
#include <sys/param.h>
#include <sys/kernel.h>
#include <sys/bus.h>
#include "acpi.h"
#include <dev/acpica/acpivar.h>
#define ACPITIMER_MAGIC 0x524d4954 /* "TIMR" */
struct acpi_timer_softc {
device_t tm_dev;
};
static void acpi_timer_identify(driver_t *driver, device_t parent);
static int acpi_timer_probe(device_t dev);
static int acpi_timer_attach(device_t dev);
static device_method_t acpi_timer_methods[] = {
/* Device interface */
DEVMETHOD(device_identify, acpi_timer_identify),
DEVMETHOD(device_probe, acpi_timer_probe),
DEVMETHOD(device_attach, acpi_timer_attach),
{0, 0}
};
static driver_t acpi_timer_driver = {
"acpi_timer",
acpi_timer_methods,
sizeof(struct acpi_timer_softc),
};
devclass_t acpi_timer_devclass;
DRIVER_MODULE(acpi_timer, acpi, acpi_timer_driver, acpi_timer_devclass, 0, 0);
static void
acpi_timer_identify(driver_t *driver, device_t parent)
{
static FIXED_ACPI_DESCRIPTION_TABLE facp;
ACPI_BUFFER buf;
ACPI_STATUS status;
device_t dev;
char desc[40];
buf.Pointer = &facp;
buf.Length = sizeof(facp);
if ((status = AcpiGetTable(ACPI_TABLE_FACP, 1, &buf)) != AE_OK) {
device_printf(parent, "can't locate FACP - %s\n", acpi_strerror(status));
return;
}
if (buf.Length != sizeof(facp)) {
device_printf(parent, "invalid FACP\n");
return;
}
if ((dev = BUS_ADD_CHILD(parent, 0, "acpi_timer", 0)) == NULL) {
device_printf(parent, "could not add acpi_timer0\n");
return;
}
if (acpi_set_magic(dev, ACPITIMER_MAGIC)) {
device_printf(dev, "could not set magic\n");
return;
}
sprintf(desc, "%d-bit timer at 3.579545MHz", facp.TmrValExt ? 32 : 24);
device_set_desc_copy(dev, desc);
}
static int
acpi_timer_probe(device_t dev)
{
if (acpi_get_magic(dev) == ACPITIMER_MAGIC)
return(0);
return(ENXIO);
}
static int
acpi_timer_attach(device_t dev)
{
struct acpi_timer_softc *sc;
sc = device_get_softc(dev);
sc->tm_dev = dev;
return(0);
}

33
sys/dev/acpica/acpiio.h Normal file
View File

@ -0,0 +1,33 @@
/*-
* Copyright (c) 1999 Takanori Watanabe <takawata@shidahara1.planet.sci.kobe-u.ac.jp>
* Copyright (c) 1999 Mitsuru IWASAKI <iwasaki@FreeBSD.org>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $FreeBSD$
*/
#define ACPIIO_ENABLE _IO('P', 1)
#define ACPIIO_DISABLE _IO('P', 2)
#define ACPIIO_SETSLPSTATE _IOW('P', 3, int)

221
sys/dev/acpica/acpivar.h Normal file
View File

@ -0,0 +1,221 @@
/*-
* Copyright (c) 2000 Mitsuru IWASAKI <iwasaki@jp.freebsd.org>
* Copyright (c) 2000 Michael Smith <msmith@freebsd.org>
* Copyright (c) 2000 BSDi
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $FreeBSD$
*/
#include "bus_if.h"
#include <sys/eventhandler.h>
extern devclass_t acpi_devclass;
struct acpi_softc {
device_t acpi_dev;
dev_t acpi_dev_t;
struct resource *acpi_irq;
int acpi_irq_rid;
void *acpi_irq_handle;
int acpi_enabled;
int acpi_sstate;
#define ACPI_POWER_BUTTON_DEFAULT_SX ACPI_STATE_S5;
#define ACPI_SLEEP_BUTTON_DEFAULT_SX ACPI_STATE_S1;
#define ACPI_LID_SWITCH_DEFAULT_SX ACPI_STATE_S1;
int acpi_power_button_sx;
int acpi_sleep_button_sx;
int acpi_lid_switch_sx;
};
struct acpi_device {
/* ACPI ivars */
ACPI_HANDLE ad_handle;
int ad_magic;
void *ad_private;
/* resources */
struct resource_list ad_rl;
};
/*
* This is a cheap and nasty way to get around the horrid counted list
* argument format that AcpiEvalateMethod uses.
*/
#define ACPI_OBJECTLIST_MAX 16
struct acpi_object_list {
UINT32 count;
ACPI_OBJECT *pointer[ACPI_OBJECTLIST_MAX];
ACPI_OBJECT object[ACPI_OBJECTLIST_MAX];
};
static __inline struct acpi_object_list *
acpi_AllocObjectList(int nobj) {
struct acpi_object_list *l;
int i;
if (nobj > ACPI_OBJECTLIST_MAX)
return(NULL);
if ((l = AcpiOsAllocate(sizeof(*l))) == NULL)
return(NULL);
bzero(l, sizeof(*l));
for (i = 0; i < ACPI_OBJECTLIST_MAX; i++)
l->pointer[i] = &l->object[i];
l->count = nobj;
return(l);
}
#define ACPI_IVAR_HANDLE 0x100
#define ACPI_IVAR_MAGIC 0x101
#define ACPI_IVAR_PRIVATE 0x102
static __inline ACPI_HANDLE
acpi_get_handle(device_t dev) {
ACPI_HANDLE h;
if (BUS_READ_IVAR(device_get_parent(dev), dev, ACPI_IVAR_HANDLE, (uintptr_t *)&h))
return(NULL);
return(h);
}
static __inline int
acpi_set_handle(device_t dev, ACPI_HANDLE h) {
return(BUS_WRITE_IVAR(device_get_parent(dev), dev, ACPI_IVAR_HANDLE, (uintptr_t)h));
}
static __inline int
acpi_get_magic(device_t dev) {
int m;
if (BUS_READ_IVAR(device_get_parent(dev), dev, ACPI_IVAR_MAGIC, (uintptr_t *)&m))
return(0);
return(m);
}
static __inline int
acpi_set_magic(device_t dev, int m) {
return(BUS_WRITE_IVAR(device_get_parent(dev), dev, ACPI_IVAR_MAGIC, (uintptr_t)m));
}
static __inline void *
acpi_get_private(device_t dev) {
void *p;
if (BUS_READ_IVAR(device_get_parent(dev), dev, ACPI_IVAR_PRIVATE, (uintptr_t *)&p))
return(NULL);
return(p);
}
static __inline int
acpi_set_private(device_t dev, void *p) {
return(BUS_WRITE_IVAR(device_get_parent(dev), dev, ACPI_IVAR_PRIVATE, (uintptr_t)p));
}
static __inline ACPI_OBJECT_TYPE
acpi_get_type(device_t dev) {
ACPI_HANDLE h;
ACPI_OBJECT_TYPE t;
if ((h = acpi_get_handle(dev)) == NULL)
return(ACPI_TYPE_NOT_FOUND);
if (AcpiGetType(h, &t) != AE_OK)
return(ACPI_TYPE_NOT_FOUND);
return(t);
}
#ifdef ENABLE_DEBUGGER
extern void acpi_EnterDebugger(void);
#endif
extern BOOLEAN acpi_MatchHid(device_t dev, char *hid);
extern ACPI_STATUS acpi_GetIntoBuffer(ACPI_HANDLE handle,
ACPI_STATUS (*func)(ACPI_HANDLE, ACPI_BUFFER *),
ACPI_BUFFER *buf);
extern ACPI_BUFFER *acpi_AllocBuffer(int size);
extern ACPI_STATUS acpi_SetSleepState(struct acpi_softc *sc, int state);
extern ACPI_STATUS acpi_Enable(struct acpi_softc *sc);
extern ACPI_STATUS acpi_Disable(struct acpi_softc *sc);
extern BOOLEAN acpi_DeviceIsPresent(device_t dev);
extern ACPI_STATUS acpi_EvaluateNumber(ACPI_HANDLE handle, char *path, int *number);
struct acpi_parse_resource_set {
void (* set_init)(device_t dev, void **context);
void (* set_done)(device_t dev, void *context);
void (* set_ioport)(device_t dev, void *context, u_int32_t base, u_int32_t length);
void (* set_iorange)(device_t dev, void *context, u_int32_t low, u_int32_t high,
u_int32_t length, u_int32_t align);
void (* set_memory)(device_t dev, void *context, u_int32_t base, u_int32_t length);
void (* set_memoryrange)(device_t dev, void *context, u_int32_t low, u_int32_t high,
u_int32_t length, u_int32_t align);
void (* set_irq)(device_t dev, void *context, u_int32_t irq);
void (* set_drq)(device_t dev, void *context, u_int32_t drq);
void (* set_start_dependant)(device_t dev, void *context, int preference);
void (* set_end_dependant)(device_t dev, void *context);
};
extern struct acpi_parse_resource_set acpi_res_parse_set;
extern ACPI_STATUS acpi_parse_resources(device_t dev, ACPI_HANDLE handle,
struct acpi_parse_resource_set *set);
/* XXX this is ugly */
extern char *acpi_strerror(ACPI_STATUS excep);
/*
* ACPI event handling
*/
extern UINT32 acpi_eventhandler_power_button_for_sleep(void *context);
extern UINT32 acpi_eventhandler_power_button_for_wakeup(void *context);
extern UINT32 acpi_eventhandler_sleep_button_for_sleep(void *context);
extern UINT32 acpi_eventhandler_sleep_button_for_wakeup(void *context);
#define ACPI_EVENT_PRI_FIRST 0
#define ACPI_EVENT_PRI_DEFAULT 10000
#define ACPI_EVENT_PRI_LAST 20000
typedef void (*acpi_event_handler_t) __P((void *, int));
EVENTHANDLER_DECLARE(acpi_sleep_event, acpi_event_handler_t);
EVENTHANDLER_DECLARE(acpi_wakeup_event, acpi_event_handler_t);
/*
* Misc.
*/
static __inline struct acpi_softc *
acpi_device_get_parent_softc(device_t child)
{
device_t parent;
parent = device_get_parent(child);
if (parent == NULL) {
return(NULL);
}
return(device_get_softc(parent));
}
extern char *acpi_name(ACPI_HANDLE handle);
extern int acpi_avoid(ACPI_HANDLE handle);