| /* SPDX-License-Identifier: GPL-2.0-only */ |
| |
| Device (HIDD) // HID Device |
| { |
| Name (_HID, "INTC1051") // Intel Ultrabook HID Platform Event Driver. |
| Name (HBSY, 0) // HID Busy |
| Name (HIDX, 0) // HID Index |
| Name (HMDE, 0) // HID Mode |
| Name (HRDY, 0) // HID Ready |
| Name (BTLD, 0) // Button Driver Loaded |
| Name (BTS1, 0) // Button Status |
| Method (_STA, 0, Serialized) // Status Method |
| { |
| // Usually, ACPI will check if the OS is 0x07DD (2013 - Windows 8.1ish) |
| // before showing the HID event filter. Seeing as we use Linux we show |
| // it regardless. |
| Return (0x0F) |
| } |
| // |
| // HID Driver Descriptor Method - Called by HID Driver during initialization |
| // to obtain HID Descriptor information. |
| // |
| // Input: |
| // None |
| // |
| // Output: |
| // Package containing a complete HID Descriptor information. |
| // |
| Name (DPKG, Package(4) |
| { |
| 0x11111111, |
| 0x22222222, |
| 0x33333333, |
| 0x44444444, |
| }) |
| Method (HDDM, 0, Serialized) |
| { |
| Return (DPKG) |
| } |
| // |
| // HID Driver Event Method - Called by HID Driver to get the specific |
| // platform event. |
| // |
| // Input: |
| // None |
| // |
| // Output: |
| // Mode 0 = Index of HID Input Report, per pre-defined Table. |
| // Mode 1 = Package containing a complete HID Input Report. |
| // |
| Method (HDEM, 0, Serialized) |
| { |
| HBSY = 0x00 // Clear HID Busy. |
| // Simple Mode is hardcoded for now. Return Simple Mode HID Index Value. |
| If (HMDE == 0x00) |
| { |
| Return (HIDX) |
| } |
| Return (HMDE) |
| } |
| // |
| // HID Driver Mode Method - Called by HID Driver during initialization to get |
| // the platform mode of operation. |
| // |
| // Input: |
| // None |
| // |
| // Output: |
| // 0 = Simple Mode. |
| // 1 = Advanced Mode. |
| // |
| Method (HDMM, 0, Serialized) |
| { |
| Return (HMDE) // Return Mode of operation. |
| } |
| // |
| // HID Driver Status Method - called by HID Driver to report platform readiness status. |
| // |
| // Input: Driver Status. |
| // 0 = Driver Unloaded. |
| // 1 = Driver Loaded and Ready. |
| // |
| // Output: None |
| // |
| Method (HDSM, 1, Serialized) |
| { |
| HRDY = Arg0 // Store HID Ready Status. |
| // Eventually code will communicate to platform the Driver status (enabled/disabled). |
| } |
| // |
| // HID Platform Event Method - called by Platform to communicate HID Event to Driver. |
| // |
| // Input: |
| // Mode 0 = Index of HID Event. |
| // Mode 1 = Package containing a complete HID Report. |
| // |
| Method (HPEM, 1, Serialized) // HID Platform Event Method. |
| { |
| HBSY = 0x01 // Set HID Busy. |
| // Simple Mode is hardcoded for now. Simply store HID Index value. |
| If (HMDE == 0x00) |
| { |
| HIDX = Arg0 |
| } Else { |
| HIDX = Arg0 |
| } |
| Notify (\_SB.HIDD, 0xC0) // Notify Driver to get HID Event. |
| Local0 = 0x00 // Initialize Local0 as a timeout counter. |
| While((Local0 < 250) && HBSY) // Wait <= 1 second for Driver to ACK success. |
| { |
| Sleep (4) // Delay 4 ms. |
| Local0++ // Increment Timeout. |
| } |
| If (HBSY == 0x01) // Failure? |
| { |
| HBSY = 0x00 // Yes. Clear HID Busy Flag. |
| HIDX = 0x00 // Set HID Simple Mode Index = 0 = Undefined. |
| Return (0x01) // Return Failure. |
| } Else { |
| Return (0x00) // Return Success. |
| } |
| } |
| // |
| // HID Button Load Method - called by Platform to say HID driver is capable of receiving |
| // 5-button array notifications. |
| // |
| // Input: |
| // None |
| // |
| // Output: |
| // None |
| // |
| Method (BTNL, 0, Serialized) // HID Button Enable/Disable Method |
| { |
| BTS1 = 0x00 |
| } |
| // |
| // HID Button Enable/Disable Method - called by Platform to disable/enable notification based |
| // on button press |
| // |
| // Input: |
| // Arg0 = Bit mask of buttons to Enable or Disable: |
| // 1 == Button should be Enabled |
| // 0 == Button should be Disabled |
| // Bits[0]: Power Button N/A to disable |
| // Bits[1]: Windows Button |
| // Bits[2]: Volume Up Button |
| // Bits[3]: Volume Down Button |
| // Bits[4]: Rotation Lock Button |
| // Bits[5:31]: Reserved |
| // |
| // Output: |
| // None |
| // |
| Method (BTNE, 1, Serialized) // HID Button Enable/Disable Method |
| { |
| Return (BTS1) |
| } |
| // |
| // HID Button Status - called by Platform to get what buttons are enabled and disabled |
| // |
| // Input: |
| // None |
| // |
| // Output: |
| // Bit mask of buttons' current status: |
| // 1 == Button is Enabled |
| // 0 == Button is Disabled |
| // Bits[0]: Power Button N/A to disable |
| // Bits[1]: Windows Button |
| // Bits[2]: Volume Up Button |
| // Bits[3]: Volume Down Button |
| // Bits[4]: Rotation Lock Button |
| // Bits[5:31]: Reserved |
| // |
| Method (BTNS, 0, Serialized) |
| { |
| Return (BTS1) |
| } |
| // |
| // HID Button Capabilities Method - called by Platform to determine what buttons are supported |
| // |
| // Input: |
| // None |
| // |
| // Output: |
| // Bit mask of buttons supported: |
| // 1 == Button is Supported |
| // 0 == Button is not Supported |
| // Bits[0]: Power Button (Must be 1) |
| // Bits[1]: Windows Button |
| // Bits[2]: Volume Up Button |
| // Bits[3]: Volume Down Button |
| // Bits[4]: Rotation Lock Button |
| // Bits[5:31]: Reserved |
| // |
| Method (BTNC, 0, Serialized) // HID Button Capabilities Method |
| { |
| Return (0x1F) |
| } |
| |
| // |
| // HEBC: HID Event Base Capabilities [31:0]- To specify the base button capabilities supported |
| // on platform by returning a ULONG value with the following bit level definition |
| // |
| // Input: |
| // None |
| // |
| // 0 = Button not supported |
| // 1 = Button supported |
| // Output: |
| // Bits [0] - Windows Button (Windows 8.1 supported), Rotation Lock (Windows 8.1 supported): |
| // Num Lock, Home, End, Page Up, Page Down |
| // Bits [1] - Wireless Radio Control |
| // Bits [2] - System Power Down (Windows 8.1 supported) |
| // Bits [3] - System Hibernate |
| // Bits [4] - System Sleep/ System Wake |
| // Bits [5] - Scan Next Track |
| // Bits [6] - Scan Previous Track |
| // Bits [7] - Stop |
| // Bits [8] - Play/Pause |
| // Bits [9] - Mute |
| // Bits [10] - Volume Increment (Windows 8.1 supported) |
| // Bits [11] - Volume Decrement (Windows 8.1 supported) |
| // Bits [12] - Display Brightness Increment |
| // Bits [13] - Display Brightness Decrement |
| // Bits [14] - Lock Tablet |
| // Bits [15] - Release Tablet |
| // Bits [16] - Toggle Bezel |
| // Bits [17] - 5 button array (Windows 10 supported): |
| // (Power, Windows Home, Volume Up, Volume Down, Rotation Lock) |
| // Bits [18] - Button 1 |
| // Bits [19] - Button 2 |
| // Bits [20] - Button 3 |
| // Bits [21] - Button 4 |
| // Bits [22] - Button 5 |
| // Bits [23-31] - reserved |
| // |
| // Modify below table if the target platform has different capabilities. Each bit |
| // corresponding the above table definition. |
| // |
| Name (HEB2, 0) // Extended 32bit capability definition for future enhancements. |
| Method (HEBC, 0, Serialized) { |
| // It's possible to return (\HEB1) |
| Return (0x00) |
| } |
| Method (H2BC, 0, Serialized) { |
| // It's possible to return (\HEB1) |
| Return (0x00) |
| } |
| // |
| // HEEC- Hid Event Extended Capabilities [32:63] |
| // |
| Method (HEEC, 0, Serialized) { |
| // It's possible to return (\HEB2) |
| Return (0x00) |
| } |
| // |
| // HIDD _DSM |
| // _DSM : Device Specific Method for the Windows Compatible Button Array. |
| // |
| // Arg0: UUID Unique function identifier |
| // Arg1: Integer Revision Level |
| // Arg2: Integer Function Index |
| // Arg3: Package Parameters |
| // |
| Method (_DSM, 4, Serialized, 0, UnknownObj, {BuffObj, IntObj, IntObj, PkgObj}) |
| { |
| // Compare passed in UUID to supported UUID. |
| If (Arg0 == ToUUID ("EEEC56B3-4442-408F-A792-4EDD4D758054")) |
| { |
| If (0x01 == ToInteger(Arg1)) // Revision 1. |
| { |
| Switch (ToInteger(Arg2)) // Switch to Function Index. |
| { |
| // |
| // Function 0, Query of supported functions. |
| // |
| Case (0x00) |
| { |
| Return (Buffer() {0xFF, 0x03}) // Total 9 function indices are supported including this. |
| } |
| // |
| // Function 1, BTNL. Button Load Method. No Input/Output. |
| // |
| Case (0x01) |
| { |
| BTNL() |
| } |
| // |
| // Function 2, HDMM. HID Driver Mode Method. |
| // Input:None |
| // Output:HDMM output. See HDMM |
| // |
| Case (0x02) |
| { |
| Return (HDMM()) |
| } |
| // |
| // Function 3, HDSM. HID Driver Status Method. |
| // Input: 0 - The driver is not available. 1 - The driver is available. |
| // Output: None |
| // |
| Case (0x03) |
| { |
| HDSM (DeRefOf(Arg3[0])) |
| } |
| // |
| // Function 4, HDEM. HID Driver Event Method. |
| // Input: None. |
| // Output: Package contains Supported Keys (Mode 0) |
| // |
| Case (0x04) |
| { |
| Return (HDEM()) |
| } |
| // |
| // Function 5 BTNS. Button Status Method. |
| // Input: None. |
| // Output: Int32 which contains a bit map of Buttons' enable/disable states |
| // |
| Case (0x05) |
| { |
| Return (BTNS()) |
| } |
| // |
| // Function 6 BTNE. Button Enable/Disable Method. |
| // Input: Int32 Bit mask of buttons enable/disable control: |
| // 1 = Button should be Enabled |
| // 0 = Button should be Disabled |
| // Output: None. |
| // |
| Case (0x06) |
| { |
| BTNE (DeRefOf(Arg3[0])) |
| } |
| // |
| // Function 7 HEBC. Button implemented state. |
| // Input: None |
| // Output: Int32 Bit map which shows what buttons are implemented on this system. |
| // |
| Case (0x07) |
| { |
| Return (HEBC()) |
| } |
| // |
| // Function 8 VGBS. Virtual GPIO Button Status. |
| // Input: None |
| // Output: Intger Bit map which shows what Virtual GPIO Button status. Currently only |
| // Dock/Slate modes are supported. |
| // |
| Case (0x08) |
| { |
| Return (0x00) |
| } |
| // |
| // Function 9 H2BC. Button implemented state. |
| // Input: None |
| // Output: Int32 Bit map which shows what buttons are implemented on this system. |
| // |
| Case (0x09) |
| { |
| Return (H2BC()) |
| } |
| } |
| } |
| } |
| // If the code falls through to this point, just return a buffer of 0. |
| Return (Buffer() {0x00}) |
| } |
| } |