brain-hackers_pepepper-mirror/u-boot-brain
1
0
Fork 0
mirror of https://github.com/brain-hackers/u-boot-brain synced 2024-06-09 23:36:03 +09:00
Code Issues Projects Releases Wiki Activity

x86: acpi: Add cros_ec tables

Browse Source 
Add ASL files for the Chrome OS EC, taken from coreboot.

Signed-off-by: Simon Glass <sjg@chromium.org>
This commit is contained in:
Simon Glass 2020-09-22 12:44:46 -06:00 committed by Bin Meng
parent d9778ff0d3
commit 4d0c5762ad
10 changed files with 1405 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
arch/x86/include/asm/acpi/cros_ec/ac.asl Normal file
View File

@ -0,0 +1,22 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2012 The Chromium OS Authors. All rights reserved.
*/
// Scope (EC0)
Device (AC)
{
Name (_HID, "ACPI0003")
Name (_PCL, Package () { \_SB })
Method (_PSR)
{
Return (ACEX)
}
Method (_STA)
{
Return (0x0F)
}
}

56
arch/x86/include/asm/acpi/cros_ec/als.asl Normal file
View File

@ -0,0 +1,56 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2014 Google Inc.
*/
Device (ALS)
{
Name (_HID, "ACPI0008")
Name (_UID, 1)
Method (_STA, 0, NotSerialized)
{
Return (0xF)
}
/*
* Returns the current ambient light illuminance reading in lux
*
* 0: Reading is below the range of sensitivity of the sensor
* -1: Reading is above the range or sensitivity of the sensor
*/
Method (_ALI, 0, NotSerialized)
{
Return (^^ALS0)
}
/*
* Returns a recommended polling frequency in tenths of seconds
*
* 0: No need to poll, async notifications will indicate changes
*/
Name (_ALP, 10)
/*
* Returns a package of packages where each tuple consists of a pair
* of integers mapping ambient light illuminance to display brightness.
*
* {<display luminance adjustment>, <ambient light illuminance>}
*
* Ambient light illuminance values are specified in lux.
*
* Display luminance adjustment values are relative percentages where
* 100 is no (0%) display brightness adjustment. Values <100 indicate
* negative adjustment (dimming) and values >100 indicate positive
* adjustment (brightening).
*
* This is currently unused by the Linux kernel ACPI ALS driver but
* is required by the ACPI specification so just define a basic two
* point response curve.
*/
Name (_ALR, Package ()
{
Package () { 70, 30 }, // Min { -30% adjust at 30 lux }
Package () { 150, 1000 } // Max { +50% adjust at 1000 lux }
})
}

411
arch/x86/include/asm/acpi/cros_ec/battery.asl Normal file
View File

@ -0,0 +1,411 @@
/*/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2011 The Chromium OS Authors. All rights reserved.
*/
// Scope (EC0)
/* Mutex for EC battery index interface */
Mutex (BATM, 0)
// Wait for desired battery index to be presented in shared memory
// Arg0 = battery index
// Returns Zero on success, One on error.
Method (BTSW, 1)
{
#ifdef EC_ENABLE_SECOND_BATTERY_DEVICE
If (LEqual (BTIX, Arg0)) {
Return (Zero)
}
If (LGreaterEqual (Arg0, BTCN)) {
Return (One)
}
Store (Arg0, \_SB.PCI0.LPCB.EC0.BTID)
Store (5, Local0) // Timeout 5 msec
While (LNotEqual (BTIX, Arg0))
{
Sleep (1)
Decrement (Local0)
If (LEqual (Local0, Zero))
{
Return (One)
}
}
#else
If (LNotEqual (0, Arg0)) {
Return (One)
}
#endif
Return (Zero)
}
// _STA implementation.
// Arg0 = battery index
Method (BSTA, 1, Serialized)
{
If (Acquire (^BATM, 1000)) {
Return (Zero)
}
If (And(Not(BTSW (Arg0)), BTEX)) {
Store (0x1F, Local0)
} Else {
Store (0x0F, Local0)
}
Release (^BATM)
Return (Local0)
}
// _BIF implementation.
// Arg0 = battery index
// Arg1 = PBIF
Method (BBIF, 2, Serialized)
{
If (Acquire (^BATM, 1000)) {
Return (Arg1)
}
If (BTSW (Arg0)) {
Release (^BATM)
Return (Arg1)
}
// Last Full Charge Capacity
Store (BTDF, Index (Arg1, 2))
// Design Voltage
Store (BTDV, Index (Arg1, 4))
// Design Capacity
Store (BTDA, Local0)
Store (Local0, Index (Arg1, 1))
// Design Capacity of Warning
Divide (Multiply (Local0, DWRN), 100, , Local2)
Store (Local2, Index (Arg1, 5))
// Design Capacity of Low
Divide (Multiply (Local0, DLOW), 100, , Local2)
Store (Local2, Index (Arg1, 6))
// Get battery info from mainboard
Store (ToString(Concatenate(BMOD, 0x00)), Index (Arg1, 9))
Store (ToString(Concatenate(BSER, 0x00)), Index (Arg1, 10))
Store (ToString(Concatenate(BMFG, 0x00)), Index (Arg1, 12))
Release (^BATM)
Return (Arg1)
}
// _BIX implementation.
// Arg0 = battery index
// Arg1 = PBIX
Method (BBIX, 2, Serialized)
{
If (Acquire (^BATM, 1000)) {
Return (Arg1)
}
If (BTSW (Arg0)) {
Release (^BATM)
Return (Arg1)
}
// Last Full Charge Capacity
Store (BTDF, Index (Arg1, 3))
// Design Voltage
Store (BTDV, Index (Arg1, 5))
// Design Capacity
Store (BTDA, Local0)
Store (Local0, Index (Arg1, 2))
// Design Capacity of Warning
Divide (Multiply (Local0, DWRN), 100, , Local2)
Store (Local2, Index (Arg1, 6))
// Design Capacity of Low
Divide (Multiply (Local0, DLOW), 100, , Local2)
Store (Local2, Index (Arg1, 7))
// Cycle Count
Store (BTCC, Index (Arg1, 8))
// Get battery info from mainboard
Store (ToString(Concatenate(BMOD, 0x00)), Index (Arg1, 16))
Store (ToString(Concatenate(BSER, 0x00)), Index (Arg1, 17))
Store (ToString(Concatenate(BMFG, 0x00)), Index (Arg1, 19))
Release (^BATM)
Return (Arg1)
}
// _BST implementation.
// Arg0 = battery index
// Arg1 = PBST
// Arg2 = BSTP
// Arg3 = BFWK
Method (BBST, 4, Serialized)
{
If (Acquire (^BATM, 1000)) {
Return (Arg1)
}
If (BTSW (Arg0)) {
Release (^BATM)
Return (Arg1)
}
//
// 0: BATTERY STATE
//
// bit 0 = discharging
// bit 1 = charging
// bit 2 = critical level
//
Store (Zero, Local1)
// Check if AC is present
If (ACEX) {
If (BFCG) {
Store (0x02, Local1)
} ElseIf (BFDC) {
Store (0x01, Local1)
}
} Else {
// Always discharging when on battery power
Store (0x01, Local1)
}
// Check for critical battery level
If (BFCR) {
Or (Local1, 0x04, Local1)
}
Store (Local1, Index (Arg1, 0))
// Notify if battery state has changed since last time
If (LNotEqual (Local1, DeRefOf (Arg2))) {
Store (Local1, Arg2)
If (LEqual(Arg0, 0)) {
Notify (BAT0, 0x80)
}
#ifdef EC_ENABLE_SECOND_BATTERY_DEVICE
Else {
Notify (BAT1, 0x80)
}
#endif
}
//
// 1: BATTERY PRESENT RATE
//
Store (BTPR, Index (Arg1, 1))
//
// 2: BATTERY REMAINING CAPACITY
//
Store (BTRA, Local1)
If (LAnd (Arg3, LAnd (ACEX, LNot (LAnd (BFDC, BFCG))))) {
// On AC power and battery is neither charging
// nor discharging. Linux expects a full battery
// to report same capacity as last full charge.
// https://bugzilla.kernel.org/show_bug.cgi?id=12632
Store (BTDF, Local2)
// See if within ~6% of full
ShiftRight (Local2, 4, Local3)
If (LAnd (LGreater (Local1, Subtract (Local2, Local3)),
LLess (Local1, Add (Local2, Local3))))
{
Store (Local2, Local1)
}
}
Store (Local1, Index (Arg1, 2))
//
// 3: BATTERY PRESENT VOLTAGE
//
Store (BTVO, Index (Arg1, 3))
Release (^BATM)
Return (Arg1)
}
Device (BAT0)
{
Name (_HID, EISAID ("PNP0C0A"))
Name (_UID, 1)
Name (_PCL, Package () { \_SB })
Name (PBIF, Package () {
0x00000001, // 0x00: Power Unit: mAh
0xFFFFFFFF, // 0x01: Design Capacity
0xFFFFFFFF, // 0x02: Last Full Charge Capacity
0x00000001, // 0x03: Battery Technology: Rechargeable
0xFFFFFFFF, // 0x04: Design Voltage
0x00000003, // 0x05: Design Capacity of Warning
0xFFFFFFFF, // 0x06: Design Capacity of Low
0x00000001, // 0x07: Capacity Granularity 1
0x00000001, // 0x08: Capacity Granularity 2
"", // 0x09: Model Number
"", // 0x0a: Serial Number
"LION", // 0x0b: Battery Type
"" // 0x0c: OEM Information
})
Name (PBIX, Package () {
0x00000000, // 0x00: Revision
0x00000001, // 0x01: Power Unit: mAh
0xFFFFFFFF, // 0x02: Design Capacity
0xFFFFFFFF, // 0x03: Last Full Charge Capacity
0x00000001, // 0x04: Battery Technology: Rechargeable
0xFFFFFFFF, // 0x05: Design Voltage
0x00000003, // 0x06: Design Capacity of Warning
0xFFFFFFFF, // 0x07: Design Capacity of Low
0x00000000, // 0x08: Cycle Count
0x00018000, // 0x09: Measurement Accuracy (98.3%?)
0x000001F4, // 0x0a: Max Sampling Time (500ms)
0x0000000a, // 0x0b: Min Sampling Time (10ms)
0xFFFFFFFF, // 0x0c: Max Averaging Interval
0xFFFFFFFF, // 0x0d: Min Averaging Interval
0x00000001, // 0x0e: Capacity Granularity 1
0x00000001, // 0x0f: Capacity Granularity 2
"", // 0x10 Model Number
"", // 0x11: Serial Number
"LION", // 0x12: Battery Type
"" // 0x13: OEM Information
})
Name (PBST, Package () {
0x00000000, // 0x00: Battery State
0xFFFFFFFF, // 0x01: Battery Present Rate
0xFFFFFFFF, // 0x02: Battery Remaining Capacity
0xFFFFFFFF, // 0x03: Battery Present Voltage
})
Name (BSTP, Zero)
// Workaround for full battery status, disabled by default
Name (BFWK, Zero)
// Method to enable full battery workaround
Method (BFWE)
{
Store (One, BFWK)
}
// Method to disable full battery workaround
Method (BFWD)
{
Store (Zero, BFWK)
}
Method (_STA, 0, Serialized)
{
Return (BSTA (0))
}
Method (_BIF, 0, Serialized)
{
Return (BBIF (0, PBIF))
}
Method (_BIX, 0, Serialized)
{
Return (BBIX (0, PBIX))
}
Method (_BST, 0, Serialized)
{
Return (BBST (0, PBST, RefOf (BSTP), BFWK))
}
}
#ifdef EC_ENABLE_SECOND_BATTERY_DEVICE
Device (BAT1)
{
Name (_HID, EISAID ("PNP0C0A"))
Name (_UID, 1)
Name (_PCL, Package () { \_SB })
Name (PBIF, Package () {
0x00000001, // 0x00: Power Unit: mAh
0xFFFFFFFF, // 0x01: Design Capacity
0xFFFFFFFF, // 0x02: Last Full Charge Capacity
0x00000001, // 0x03: Battery Technology: Rechargeable
0xFFFFFFFF, // 0x04: Design Voltage
0x00000003, // 0x05: Design Capacity of Warning
0xFFFFFFFF, // 0x06: Design Capacity of Low
0x00000001, // 0x07: Capacity Granularity 1
0x00000001, // 0x08: Capacity Granularity 2
"", // 0x09: Model Number
"", // 0x0a: Serial Number
"LION", // 0x0b: Battery Type
"" // 0x0c: OEM Information
})
Name (PBIX, Package () {
0x00000000, // 0x00: Revision
0x00000001, // 0x01: Power Unit: mAh
0xFFFFFFFF, // 0x02: Design Capacity
0xFFFFFFFF, // 0x03: Last Full Charge Capacity
0x00000001, // 0x04: Battery Technology: Rechargeable
0xFFFFFFFF, // 0x05: Design Voltage
0x00000003, // 0x06: Design Capacity of Warning
0xFFFFFFFF, // 0x07: Design Capacity of Low
0x00000000, // 0x08: Cycle Count
0x00018000, // 0x09: Measurement Accuracy (98.3%?)
0x000001F4, // 0x0a: Max Sampling Time (500ms)
0x0000000a, // 0x0b: Min Sampling Time (10ms)
0xFFFFFFFF, // 0x0c: Max Averaging Interval
0xFFFFFFFF, // 0x0d: Min Averaging Interval
0x00000001, // 0x0e: Capacity Granularity 1
0x00000001, // 0x0f: Capacity Granularity 2
"", // 0x10 Model Number
"", // 0x11: Serial Number
"LION", // 0x12: Battery Type
"" // 0x13: OEM Information
})
Name (PBST, Package () {
0x00000000, // 0x00: Battery State
0xFFFFFFFF, // 0x01: Battery Present Rate
0xFFFFFFFF, // 0x02: Battery Remaining Capacity
0xFFFFFFFF, // 0x03: Battery Present Voltage
})
Name (BSTP, Zero)
// Workaround for full battery status, disabled by default
Name (BFWK, Zero)
// Method to enable full battery workaround
Method (BFWE)
{
Store (One, BFWK)
}
// Method to disable full battery workaround
Method (BFWD)
{
Store (Zero, BFWK)
}
Method (_STA, 0, Serialized)
{
Return (BSTA (1))
}
Method (_BIF, 0, Serialized)
{
Return (BBIF (1, PBIF))
}
Method (_BIX, 0, Serialized)
{
Return (BBIX (1, PBIX))
}
Method (_BST, 0, Serialized)
{
Return (BBST (1, PBST, RefOf (BSTP), BFWK))
}
}
#endif

57
arch/x86/include/asm/acpi/cros_ec/cros_ec.asl Normal file
View File

@ -0,0 +1,57 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright 2016 Google Inc.
*/
Device (CREC)
{
Name (_HID, "GOOG0004")
Name (_UID, 1)
Name (_DDN, "EC Command Device")
#ifdef EC_ENABLE_WAKE_PIN
Name (_PRW, Package () { EC_ENABLE_WAKE_PIN, 0x5 })
#endif
#ifdef EC_ENABLE_SYNC_IRQ
Name (_CRS, ResourceTemplate ()
{
Interrupt (ResourceConsumer, Level, ActiveLow, Exclusive)
{
EC_SYNC_IRQ
}
})
#endif
#ifdef EC_ENABLE_SYNC_IRQ_GPIO
Name (_CRS, ResourceTemplate ()
{
GpioInt (Level, ActiveLow, Exclusive, PullDefault, 0x0000,
"\\_SB.GPIO", 0x00, ResourceConsumer, ,)
{
EC_SYNC_IRQ
}
})
#endif
#ifdef EC_ENABLE_MKBP_DEVICE
Device (CKSC)
{
Name (_HID, "GOOG0007")
Name (_UID, 1)
Name (_DDN, "EC MKBP Device")
}
#endif
#ifdef EC_ENABLE_CBAS_DEVICE
Device (CBAS)
{
Name (_HID, "GOOG000B")
Name (_UID, 1)
Name (_DDN, "EC Base Switch Device")
}
#endif
Method(_STA, 0)
{
Return (0xB)
}
}

557
arch/x86/include/asm/acpi/cros_ec/ec.asl Normal file
View File

@ -0,0 +1,557 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2012 The Chromium OS Authors. All rights reserved.
*/
/*
* The mainboard must define a PNOT method to handle power
* state notifications and Notify CPU device objects to
* re-evaluate their _PPC and _CST tables.
*/
// Mainboard specific throttle handler
#ifdef DPTF_ENABLE_CHARGER
External (\_SB.DPTF.TCHG, DeviceObj)
#endif
Device (EC0)
{
Name (_HID, EISAID ("PNP0C09"))
Name (_UID, 1)
Name (_GPE, EC_SCI_GPI)
Name (TOFS, EC_TEMP_SENSOR_OFFSET)
Name (TNCA, EC_TEMP_SENSOR_NOT_CALIBRATED)
Name (TNOP, EC_TEMP_SENSOR_NOT_POWERED)
Name (TBAD, EC_TEMP_SENSOR_ERROR)
Name (TNPR, EC_TEMP_SENSOR_NOT_PRESENT)
Name (DWRN, 15) // Battery capacity warning at 15%
Name (DLOW, 10) // Battery capacity low at 10%
OperationRegion (ERAM, EmbeddedControl, 0x00, EC_ACPI_MEM_MAPPED_BEGIN)
Field (ERAM, ByteAcc, Lock, Preserve)
{
Offset (0x00),
RAMV, 8, // EC RAM Version
TSTB, 8, // Test Byte
TSTC, 8, // Complement of Test Byte
KBLV, 8, // Keyboard Backlight value
FAND, 8, // Set Fan Duty Cycle
PATI, 8, // Programmable Auxiliary Trip Sensor ID
PATT, 8, // Programmable Auxiliary Trip Threshold
PATC, 8, // Programmable Auxiliary Trip Commit
CHGL, 8, // Charger Current Limit
TBMD, 1, // Tablet mode
DDPN, 3, // Device DPTF Profile Number
// DFUD must be 0 for the other 31 values to be valid
Offset (0x0a),
DFUD, 1, // Device Features Undefined
FLSH, 1, // Flash commands present
PFAN, 1, // PWM Fan control present
KBLE, 1, // Keyboard Backlight present
LTBR, 1, // Lightbar present
LEDC, 1, // LED control
MTNS, 1, // Motion sensors present
KEYB, 1, // EC is keyboard controller
PSTR, 1, // Persistent storage
P80P, 1, // EC serves I/O Port 80h
THRM, 1, // EC supports thermal management
SBKL, 1, // Screen backlight switch present
WIFI, 1, // WIFI switch present
HOST, 1, // EC monitors host events (eg SCI, SMI)
GPIO, 1, // EC provides GPIO commands
I2CB, 1, // EC provides I2C controller access
CHRG, 1, // EC provides commands for charger control
BATT, 1, // Simply Battery support
SBAT, 1, // Smart Battery support
HANG, 1, // EC can detect host hang
PMUI, 1, // Power Information
DSEC, 1, // another EC exists downstream
UPDC, 1, // supports USB Power Delivery
UMUX, 1, // supports USB Mux
MSFF, 1, // Motion Sense has FIFO
TVST, 1, // supports temporary secure vstore
TCMV, 1, // USB Type C Muxing is virtual (host assisted)
RTCD, 1, // EC provides an RTC device
FPRD, 1, // EC provides a fingerprint reader device
TPAD, 1, // EC provides a touchpad device
RWSG, 1, // EC has RWSIG task enabled
DEVE, 1, // EC supports device events
// make sure we're within our space envelope
Offset (0x0e),
Offset (0x12),
BTID, 8, // Battery index that host wants to read
USPP, 8, // USB Port Power
}
#if IS_ENABLED(CONFIG_EC_GOOGLE_CHROMEEC_ACPI_MEMMAP)
OperationRegion (EMEM, EmbeddedControl,
EC_ACPI_MEM_MAPPED_BEGIN, EC_ACPI_MEM_MAPPED_SIZE)
Field (EMEM, ByteAcc, Lock, Preserve)
#else
OperationRegion (EMEM, SystemIO, EC_LPC_ADDR_MEMMAP, EC_MEMMAP_SIZE)
Field (EMEM, ByteAcc, NoLock, Preserve)
#endif
{
#include "emem.asl"
}
#ifdef EC_ENABLE_LID_SWITCH
/* LID Switch */
Device (LID0)
{
Name (_HID, EisaId ("PNP0C0D"))
Method (_LID, 0)
{
Return (^^LIDS)
}
#ifdef EC_ENABLE_WAKE_PIN
Name (_PRW, Package () { EC_ENABLE_WAKE_PIN, 0x5 })
#endif
}
#endif
Method (TINS, 1, Serialized)
{
Switch (ToInteger (Arg0))
{
Case (0) { Return (TIN0) }
Case (1) { Return (TIN1) }
Case (2) { Return (TIN2) }
Case (3) { Return (TIN3) }
Case (4) { Return (TIN4) }
Case (5) { Return (TIN5) }
Case (6) { Return (TIN6) }
Case (7) { Return (TIN7) }
Case (8) { Return (TIN8) }
Case (9) { Return (TIN9) }
Default { Return (TIN0) }
}
}
Method (_CRS, 0, Serialized)
{
Name (ECMD, ResourceTemplate()
{
IO (Decode16,
EC_LPC_ADDR_ACPI_DATA,
EC_LPC_ADDR_ACPI_DATA,
0, 1)
IO (Decode16,
EC_LPC_ADDR_ACPI_CMD,
EC_LPC_ADDR_ACPI_CMD,
0, 1)
})
Return (ECMD)
}
Method (_REG, 2, NotSerialized)
{
// Initialize AC power state
Store (ACEX, \PWRS)
// Initialize LID switch state
Store (LIDS, \LIDS)
}
/* Read requested temperature and check against EC error values */
Method (TSRD, 1, Serialized)
{
Store (\_SB.PCI0.LPCB.EC0.TINS (Arg0), Local0)
/* Check for sensor not calibrated */
If (LEqual (Local0, \_SB.PCI0.LPCB.EC0.TNCA)) {
Return (Zero)
}
/* Check for sensor not present */
If (LEqual (Local0, \_SB.PCI0.LPCB.EC0.TNPR)) {
Return (Zero)
}
/* Check for sensor not powered */
If (LEqual (Local0, \_SB.PCI0.LPCB.EC0.TNOP)) {
Return (Zero)
}
/* Check for sensor bad reading */
If (LEqual (Local0, \_SB.PCI0.LPCB.EC0.TBAD)) {
Return (Zero)
}
/* Adjust by offset to get Kelvin */
Add (\_SB.PCI0.LPCB.EC0.TOFS, Local0, Local0)
/* Convert to 1/10 Kelvin */
Multiply (Local0, 10, Local0)
Return (Local0)
}
// Lid Closed Event
Method (_Q01, 0, NotSerialized)
{
Store ("EC: LID CLOSE", Debug)
Store (LIDS, \LIDS)
#ifdef EC_ENABLE_LID_SWITCH
Notify (LID0, 0x80)
#endif
}
// Lid Open Event
Method (_Q02, 0, NotSerialized)
{
Store ("EC: LID OPEN", Debug)
Store (LIDS, \LIDS)
Notify (CREC, 0x2)
#ifdef EC_ENABLE_LID_SWITCH
Notify (LID0, 0x80)
#endif
}
// Power Button
Method (_Q03, 0, NotSerialized)
{
Store ("EC: POWER BUTTON", Debug)
}
// AC Connected
Method (_Q04, 0, NotSerialized)
{
Store ("EC: AC CONNECTED", Debug)
Store (ACEX, \PWRS)
Notify (AC, 0x80)
#ifdef DPTF_ENABLE_CHARGER
If (CondRefOf (\_SB.DPTF.TCHG)) {
Notify (\_SB.DPTF.TCHG, 0x80)
}
#endif
\PNOT ()
}
// AC Disconnected
Method (_Q05, 0, NotSerialized)
{
Store ("EC: AC DISCONNECTED", Debug)
Store (ACEX, \PWRS)
Notify (AC, 0x80)
#ifdef DPTF_ENABLE_CHARGER
If (CondRefOf (\_SB.DPTF.TCHG)) {
Notify (\_SB.DPTF.TCHG, 0x80)
}
#endif
\PNOT ()
}
// Battery Low Event
Method (_Q06, 0, NotSerialized)
{
Store ("EC: BATTERY LOW", Debug)
Notify (BAT0, 0x80)
}
// Battery Critical Event
Method (_Q07, 0, NotSerialized)
{
Store ("EC: BATTERY CRITICAL", Debug)
Notify (BAT0, 0x80)
}
// Battery Info Event
Method (_Q08, 0, NotSerialized)
{
Store ("EC: BATTERY INFO", Debug)
Notify (BAT0, 0x81)
#ifdef EC_ENABLE_SECOND_BATTERY_DEVICE
If (CondRefOf (BAT1)) {
Notify (BAT1, 0x81)
}
#endif
}
// Thermal Overload Event
Method (_Q0A, 0, NotSerialized)
{
Store ("EC: THERMAL OVERLOAD", Debug)
Notify (\_TZ, 0x80)
}
// Thermal Event
Method (_Q0B, 0, NotSerialized)
{
Store ("EC: THERMAL", Debug)
Notify (\_TZ, 0x80)
}
// USB Charger
Method (_Q0C, 0, NotSerialized)
{
Store ("EC: USB CHARGER", Debug)
}
// Key Pressed
Method (_Q0D, 0, NotSerialized)
{
Store ("EC: KEY PRESSED", Debug)
Notify (CREC, 0x2)
}
// Thermal Shutdown Imminent
Method (_Q10, 0, NotSerialized)
{
Store ("EC: THERMAL SHUTDOWN", Debug)
Notify (\_TZ, 0x80)
}
// Battery Shutdown Imminent
Method (_Q11, 0, NotSerialized)
{
Store ("EC: BATTERY SHUTDOWN", Debug)
Notify (BAT0, 0x80)
}
// Throttle Start
Method (_Q12, 0, NotSerialized)
{
#ifdef EC_ENABLE_THROTTLING_HANDLER
Store ("EC: THROTTLE START", Debug)
\_TZ.THRT (1)
#endif
}
// Throttle Stop
Method (_Q13, 0, NotSerialized)
{
#ifdef EC_ENABLE_THROTTLING_HANDLER
Store ("EC: THROTTLE STOP", Debug)
\_TZ.THRT (0)
#endif
}
#ifdef EC_ENABLE_PD_MCU_DEVICE
// PD event
Method (_Q16, 0, NotSerialized)
{
Store ("EC: GOT PD EVENT", Debug)
Notify (ECPD, 0x80)
}
#endif
// Battery Status
Method (_Q17, 0, NotSerialized)
{
Store ("EC: BATTERY STATUS", Debug)
Notify (BAT0, 0x80)
#ifdef EC_ENABLE_SECOND_BATTERY_DEVICE
If (CondRefOf (BAT1)) {
Notify (BAT1, 0x80)
}
#endif
}
// MKBP interrupt.
Method (_Q1B, 0, NotSerialized)
{
Store ("EC: MKBP", Debug)
Notify (CREC, 0x80)
}
// TABLET mode switch Event
Method (_Q1D, 0, NotSerialized)
{
Store ("EC: TABLET mode switch Event", Debug)
Notify (CREC, 0x2)
#ifdef EC_ENABLE_MULTIPLE_DPTF_PROFILES
\_SB.DPTF.TPET()
#endif
#ifdef EC_ENABLE_TBMC_DEVICE
Notify (TBMC, 0x80)
#endif
}
/*
* Dynamic Platform Thermal Framework support
*/
/* Mutex for EC PAT interface */
Mutex (PATM, 1)
/*
* Set Aux Trip Point 0
* Arg0 = Temp Sensor ID
* Arg1 = Value to set
*/
Method (PAT0, 2, Serialized)
{
If (Acquire (^PATM, 1000)) {
Return (0)
}
/* Set sensor ID */
Store (ToInteger (Arg0), ^PATI)
/* Temperature is passed in 1/10 Kelvin */
Divide (ToInteger (Arg1), 10, , Local1)
/* Adjust by EC temperature offset */
Subtract (Local1, ^TOFS, ^PATT)
/* Set commit value with SELECT=0 and ENABLE=1 */
Store (0x02, ^PATC)
Release (^PATM)
Return (1)
}
/*
* Set Aux Trip Point 1
* Arg0 = Temp Sensor ID
* Arg1 = Value to set
*/
Method (PAT1, 2, Serialized)
{
If (Acquire (^PATM, 1000)) {
Return (0)
}
/* Set sensor ID */
Store (ToInteger (Arg0), ^PATI)
/* Temperature is passed in 1/10 Kelvin */
Divide (ToInteger (Arg1), 10, , Local1)
/* Adjust by EC temperature offset */
Subtract (Local1, ^TOFS, ^PATT)
/* Set commit value with SELECT=1 and ENABLE=1 */
Store (0x03, ^PATC)
Release (^PATM)
Return (1)
}
/* Disable Aux Trip Points
* Arg0 = Temp Sensor ID
*/
Method (PATD, 1, Serialized)
{
If (Acquire (^PATM, 1000)) {
Return (0)
}
Store (ToInteger (Arg0), ^PATI)
Store (0x00, ^PATT)
/* Disable PAT0 */
Store (0x00, ^PATC)
/* Disable PAT1 */
Store (0x01, ^PATC)
Release (^PATM)
Return (1)
}
/*
* Thermal Threshold Event
*/
Method (_Q09, 0, NotSerialized)
{
If (LNot(Acquire (^PATM, 1000))) {
/* Read sensor ID for event */
Store (^PATI, Local0)
/* When sensor ID returns 0xFF then no more events */
While (LNotEqual (Local0, EC_TEMP_SENSOR_NOT_PRESENT))
{
#ifdef HAVE_THERM_EVENT_HANDLER
\_SB.DPTF.TEVT (Local0)
#endif
/* Keep reaading sensor ID for event */
Store (^PATI, Local0)
}
Release (^PATM)
}
}
/*
* Set Charger Current Limit
* Arg0 = Current Limit in 64mA steps
*/
Method (CHGS, 1, Serialized)
{
Store (ToInteger (Arg0), ^CHGL)
}
/*
* Disable Charger Current Limit
*/
Method (CHGD, 0, Serialized)
{
Store (0xFF, ^CHGL)
}
/* Read current Tablet mode */
Method (RCTM, 0, NotSerialized)
{
Return (^TBMD)
}
/* Read current Device DPTF Profile Number */
Method (RCDP, 0, NotSerialized)
{
/*
* DDPN = 0 is reserved for backwards compatibility.
* If DDPN == 0 use TBMD to load appropriate DPTF table.
*/
If (LEqual (^DDPN, 0)) {
Return (^TBMD)
} Else {
Subtract (^DDPN, 1, Local0)
Return (Local0)
}
}
#if IS_ENABLED(CONFIG_EC_GOOGLE_CHROMEEC_ACPI_USB_PORT_POWER)
/*
* Enable USB Port Power
* Arg0 = USB port ID
*/
Method (UPPS, 1, Serialized)
{
Or (USPP, ShiftLeft (1, Arg0), USPP)
}
/*
* Disable USB Port Power
* Arg0 = USB port ID
*/
Method (UPPC, 1, Serialized)
{
And (USPP, Not (ShiftLeft (1, Arg0)), USPP)
}
#endif
#include "ac.asl"
#include "battery.asl"
#include "cros_ec.asl"
#ifdef EC_ENABLE_ALS_DEVICE
#include "als.asl"
#endif
#ifdef EC_ENABLE_KEYBOARD_BACKLIGHT
#include "keyboard_backlight.asl"
#endif
#ifdef EC_ENABLE_PD_MCU_DEVICE
#include "pd.asl"
#endif
#ifdef EC_ENABLE_TBMC_DEVICE
#include "tbmc.asl"
#endif
}

53
arch/x86/include/asm/acpi/cros_ec/emem.asl Normal file
View File

@ -0,0 +1,53 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright 2015 The Chromium OS Authors. All rights reserved.
*/
/*
* EMEM data may be accessed through port 62/66 or through LPC at 900h.
*/
Offset (0x00),
TIN0, 8, // Temperature 0
TIN1, 8, // Temperature 1
TIN2, 8, // Temperature 2
TIN3, 8, // Temperature 3
TIN4, 8, // Temperature 4
TIN5, 8, // Temperature 5
TIN6, 8, // Temperature 6
TIN7, 8, // Temperature 7
TIN8, 8, // Temperature 8
TIN9, 8, // Temperature 9
Offset (0x10),
FAN0, 16, // Fan Speed 0
Offset (0x24),
BTVR, 8, // Battery structure version
Offset (0x30),
LIDS, 1, // Lid Switch State
PBTN, 1, // Power Button Pressed
WPDI, 1, // Write Protect Disabled
RECK, 1, // Keyboard Initiated Recovery
RECD, 1, // Dedicated Recovery Mode
Offset (0x40),
BTVO, 32, // Battery Present Voltage
BTPR, 32, // Battery Present Rate
BTRA, 32, // Battery Remaining Capacity
ACEX, 1, // AC Present
BTEX, 1, // Battery Present
BFDC, 1, // Battery Discharging
BFCG, 1, // Battery Charging
BFCR, 1, // Battery Level Critical
Offset (0x4d),
BTCN, 8, // Battery Count
BTIX, 8, // Battery index
Offset (0x50),
BTDA, 32, // Battery Design Capacity
BTDV, 32, // Battery Design Voltage
BTDF, 32, // Battery Last Full Charge Capacity
BTCC, 32, // Battery Cycle Count
BMFG, 64, // Battery Manufacturer String
BMOD, 64, // Battery Model String
BSER, 64, // Battery Serial String
BTYP, 64, // Battery Type String
Offset (0x80),
ALS0, 16, // ALS reading 0 in lux

52
arch/x86/include/asm/acpi/cros_ec/keyboard_backlight.asl Normal file
View File

@ -0,0 +1,52 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2015 Google Inc.
*/
Scope (\_SB)
{
/*
* Chrome EC Keyboard Backlight interface
*/
Device (KBLT)
{
Name (_HID, "GOOG0002")
Name (_UID, 1)
/* Ask EC if we even have a backlight
* Return 0xf (present, enabled, show in UI, functioning) or 0
*
* With older EC codebases that don't support the Device
* Features bitfield, this reports the keyboard backlight as
* enabled since reads to undefined addresses in EC address
* space return 0xff and so KBLE will be 1.
*/
Method (_STA, 0, NotSerialized)
{
/* If query is unsupported, but this code is compiled
* in, assume the backlight exists physically.
*/
If (LEqual (1, \_SB.PCI0.LPCB.EC0.DFUD)) {
Return (0xf)
}
/* If EC reports that backlight exists, trust it */
If (LEqual (1, \_SB.PCI0.LPCB.EC0.KBLE)) {
Return (0xf)
}
/* Otherwise: no device -> disable */
Return (0)
}
/* Read current backlight value */
Method (KBQC, 0, NotSerialized)
{
Return (\_SB.PCI0.LPCB.EC0.KBLV)
}
/* Write new backlight value */
Method (KBCM, 1, NotSerialized)
{
Store (Arg0, \_SB.PCI0.LPCB.EC0.KBLV)
}
}
}

15
arch/x86/include/asm/acpi/cros_ec/pd.asl Normal file
View File

@ -0,0 +1,15 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2014 Google Inc.
*/
Device (ECPD)
{
Name (_HID, "GOOG0003")
Name (_UID, 1)
Name (_DDN, "EC PD Device")
Method(_STA, 0)
{
Return (0xB)
}
}

159
arch/x86/include/asm/acpi/cros_ec/superio.asl Normal file
View File

@ -0,0 +1,159 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2012 The ChromiumOS Authors. All rights reserved.
*/
/*
* Chrome OS Embedded Controller interface
*
* Constants that should be defined:
*
* SIO_EC_MEMMAP_ENABLE : Enable EC LPC memory map resources
* EC_LPC_ADDR_MEMMAP : Base address of memory map range
* EC_MEMMAP_SIZE : Size of memory map range
*
* SIO_EC_HOST_ENABLE : Enable EC host command interface resources
* EC_LPC_ADDR_HOST_DATA : EC host command interface data port
* EC_LPC_ADDR_HOST_CMD : EC host command interface command port
* EC_HOST_CMD_REGION0 : EC host command buffer
* EC_HOST_CMD_REGION1 : EC host command buffer
* EC_HOST_CMD_REGION_SIZE : EC host command buffer size
*/
// Scope is \_SB.PCI0.LPCB
Device (SIO) {
Name (_UID, 0)
Name (_ADR, 0)
#ifdef SIO_EC_MEMMAP_ENABLE
Device (ECMM) {
Name (_HID, EISAID ("PNP0C02"))
Name (_UID, 4)
Method (_STA, 0, NotSerialized) {
Return (0x0F)
}
Name (_CRS, ResourceTemplate ()
{
IO (Decode16, EC_LPC_ADDR_MEMMAP, EC_LPC_ADDR_MEMMAP,
0x08, EC_MEMMAP_SIZE)
})
Name (_PRS, ResourceTemplate ()
{
IO (Decode16, EC_LPC_ADDR_MEMMAP, EC_LPC_ADDR_MEMMAP,
0x08, EC_MEMMAP_SIZE)
})
}
#endif
#ifdef SIO_EC_HOST_ENABLE
Device (ECUI) {
Name (_HID, EISAID ("PNP0C02"))
Name (_UID, 3)
Method (_STA, 0, NotSerialized) {
Return (0x0F)
}
Name (_CRS, ResourceTemplate ()
{
IO (Decode16,
EC_LPC_ADDR_HOST_DATA, EC_LPC_ADDR_HOST_DATA,
0x01, 0x01)
IO (Decode16,
EC_LPC_ADDR_HOST_CMD, EC_LPC_ADDR_HOST_CMD,
0x01, 0x01)
IO (Decode16,
EC_HOST_CMD_REGION0, EC_HOST_CMD_REGION0, 0x08,
EC_HOST_CMD_REGION_SIZE)
IO (Decode16,
EC_HOST_CMD_REGION1, EC_HOST_CMD_REGION1, 0x08,
EC_HOST_CMD_REGION_SIZE)
})
Name (_PRS, ResourceTemplate ()
{
StartDependentFn (0, 0) {
IO (Decode16, EC_LPC_ADDR_HOST_DATA,
EC_LPC_ADDR_HOST_DATA, 0x01, 0x01)
IO (Decode16, EC_LPC_ADDR_HOST_CMD,
EC_LPC_ADDR_HOST_CMD, 0x01, 0x01)
IO (Decode16,
EC_HOST_CMD_REGION0, EC_HOST_CMD_REGION0,
0x08, EC_HOST_CMD_REGION_SIZE)
IO (Decode16,
EC_HOST_CMD_REGION1, EC_HOST_CMD_REGION1,
0x08, EC_HOST_CMD_REGION_SIZE)
}
EndDependentFn ()
})
}
#endif
#ifdef SIO_EC_ENABLE_COM1
Device (COM1) {
Name (_HID, EISAID ("PNP0501"))
Name (_UID, 1)
Method (_STA, 0, NotSerialized) {
Return (0x0F)
}
Name (_CRS, ResourceTemplate ()
{
IO (Decode16, 0x03F8, 0x3F8, 0x08, 0x08)
IRQNoFlags () {4}
})
Name (_PRS, ResourceTemplate ()
{
StartDependentFn (0, 0) {
IO (Decode16, 0x03F8, 0x3F8, 0x08, 0x08)
IRQNoFlags () {4}
}
EndDependentFn ()
})
}
#endif
}
#ifdef SIO_EC_ENABLE_PS2K
Device (PS2K) // Keyboard
{
Name (_UID, 0)
Name (_HID, "GOOG000A")
Name (_CID, Package() { EISAID("PNP0303"), EISAID("PNP030B") } )
Method (_STA, 0, NotSerialized) {
Return (0x0F)
}
Name (_CRS, ResourceTemplate()
{
IO (Decode16, 0x60, 0x60, 0x01, 0x01)
IO (Decode16, 0x64, 0x64, 0x01, 0x01)
#ifdef SIO_EC_PS2K_IRQ
SIO_EC_PS2K_IRQ
#else
IRQ (Edge, ActiveHigh, Exclusive) {1}
#endif
})
Name (_PRS, ResourceTemplate()
{
StartDependentFn (0, 0) {
IO (Decode16, 0x60, 0x60, 0x01, 0x01)
IO (Decode16, 0x64, 0x64, 0x01, 0x01)
#ifdef SIO_EC_PS2K_IRQ
SIO_EC_PS2K_IRQ
#else
IRQ (Edge, ActiveHigh, Exclusive) {1}
#endif
}
EndDependentFn ()
})
}
#endif

23
arch/x86/include/asm/acpi/cros_ec/tbmc.asl Normal file
View File

@ -0,0 +1,23 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright 2017 Google Inc.
*/
Device (TBMC)
{
Name (_HID, "GOOG0006")
Name (_UID, 1)
Name (_DDN, "Tablet Motion Control")
Method (TBMC)
{
If (LEqual (^^RCTM, One)) {
Return (0x1)
} Else {
Return (0x0)
}
}
Method(_STA, 0)
{
Return (0xB)
}
}