Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit ed206fac87d65917280b6c3edd3f01125d4095c9

Authored by Zhang Rui
Committed by Len Brown
1 parent 49fdf6785f
Exists in master and in 7 other branches imx_3.0.35_4.1.0, imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga, smarc-l5.0.0_1.0.0-ga

ACPI: bugfix reporting of event handler status 

Introduce a new flag showing whether the event has an event handler/method.

For all the GPEs and Fixed Events,
 1. ACPI_EVENT_FLAG_HANDLE is cleared, it's an "invalid" ACPI event.
 2. Both ACPI_EVENT_FLAG_HANDLE and ACPI_EVENT_FLAG_DISABLE are set,
    it's "disabled".
 3. Both ACPI_EVENT_FLAG_HANDLE and ACPI_EVENT_FLAG_ENABLE are set,
    it's "enabled".
 4. Both ACPI_EVENT_FLAG_HANDLE and ACPI_EVENT_FLAG_WAKE_ENABLE are set,
    it's "wake_enabled".

Among other things, this prevents incorrect reporting of ACPI events
as being "invalid" when it's really just (temporarily) "disabled".

Signed-off-by: Zhang Rui <rui.zhang@intel.com>
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Len Brown <len.brown@intel.com>

Showing 4 changed files with 22 additions and 20 deletions Inline Diff

Documentation/ABI/testing/sysfs-firmware-acpi
Diff comments   View file @ ed206fa
1 What: /sys/firmware/acpi/interrupts/ 1 What: /sys/firmware/acpi/interrupts/
2 Date: February 2008 2 Date: February 2008
3 Contact: Len Brown <lenb@kernel.org> 3 Contact: Len Brown <lenb@kernel.org>
4 Description: 4 Description:
5 All ACPI interrupts are handled via a single IRQ, 5 All ACPI interrupts are handled via a single IRQ,
6 the System Control Interrupt (SCI), which appears 6 the System Control Interrupt (SCI), which appears
7 as "acpi" in /proc/interrupts. 7 as "acpi" in /proc/interrupts.
8 8
9 However, one of the main functions of ACPI is to make 9 However, one of the main functions of ACPI is to make
10 the platform understand random hardware without 10 the platform understand random hardware without
11 special driver support. So while the SCI handles a few 11 special driver support. So while the SCI handles a few
12 well known (fixed feature) interrupts sources, such 12 well known (fixed feature) interrupts sources, such
13 as the power button, it can also handle a variable 13 as the power button, it can also handle a variable
14 number of a "General Purpose Events" (GPE). 14 number of a "General Purpose Events" (GPE).
15 15
16 A GPE vectors to a specified handler in AML, which 16 A GPE vectors to a specified handler in AML, which
17 can do a anything the BIOS writer wants from 17 can do a anything the BIOS writer wants from
18 OS context. GPE 0x12, for example, would vector 18 OS context. GPE 0x12, for example, would vector
19 to a level or edge handler called _L12 or _E12. 19 to a level or edge handler called _L12 or _E12.
20 The handler may do its business and return. 20 The handler may do its business and return.
21 Or the handler may send send a Notify event 21 Or the handler may send send a Notify event
22 to a Linux device driver registered on an ACPI device, 22 to a Linux device driver registered on an ACPI device,
23 such as a battery, or a processor. 23 such as a battery, or a processor.
24 24
25 To figure out where all the SCI's are coming from, 25 To figure out where all the SCI's are coming from,
26 /sys/firmware/acpi/interrupts contains a file listing 26 /sys/firmware/acpi/interrupts contains a file listing
27 every possible source, and the count of how many 27 every possible source, and the count of how many
28 times it has triggered. 28 times it has triggered.
29 29
30 $ cd /sys/firmware/acpi/interrupts 30 $ cd /sys/firmware/acpi/interrupts
31 $ grep . * 31 $ grep . *
32 error: 0 32 error: 0
33 ff_gbl_lock: 0 enable 33 ff_gbl_lock: 0 enable
34 ff_pmtimer: 0 invalid 34 ff_pmtimer: 0 invalid
35 ff_pwr_btn: 0 enable 35 ff_pwr_btn: 0 enable
36 ff_rt_clk: 2 disable 36 ff_rt_clk: 2 disable
37 ff_slp_btn: 0 invalid 37 ff_slp_btn: 0 invalid
38 gpe00: 0 invalid 38 gpe00: 0 invalid
39 gpe01: 0 enable 39 gpe01: 0 enable
40 gpe02: 108 enable 40 gpe02: 108 enable
41 gpe03: 0 invalid 41 gpe03: 0 invalid
42 gpe04: 0 invalid 42 gpe04: 0 invalid
43 gpe05: 0 invalid 43 gpe05: 0 invalid
44 gpe06: 0 enable 44 gpe06: 0 enable
45 gpe07: 0 enable 45 gpe07: 0 enable
46 gpe08: 0 invalid 46 gpe08: 0 invalid
47 gpe09: 0 invalid 47 gpe09: 0 invalid
48 gpe0A: 0 invalid 48 gpe0A: 0 invalid
49 gpe0B: 0 invalid 49 gpe0B: 0 invalid
50 gpe0C: 0 invalid 50 gpe0C: 0 invalid
51 gpe0D: 0 invalid 51 gpe0D: 0 invalid
52 gpe0E: 0 invalid 52 gpe0E: 0 invalid
53 gpe0F: 0 invalid 53 gpe0F: 0 invalid
54 gpe10: 0 invalid 54 gpe10: 0 invalid
55 gpe11: 0 invalid 55 gpe11: 0 invalid
56 gpe12: 0 invalid 56 gpe12: 0 invalid
57 gpe13: 0 invalid 57 gpe13: 0 invalid
58 gpe14: 0 invalid 58 gpe14: 0 invalid
59 gpe15: 0 invalid 59 gpe15: 0 invalid
60 gpe16: 0 invalid 60 gpe16: 0 invalid
61 gpe17: 1084 enable 61 gpe17: 1084 enable
62 gpe18: 0 enable 62 gpe18: 0 enable
63 gpe19: 0 invalid 63 gpe19: 0 invalid
64 gpe1A: 0 invalid 64 gpe1A: 0 invalid
65 gpe1B: 0 invalid 65 gpe1B: 0 invalid
66 gpe1C: 0 invalid 66 gpe1C: 0 invalid
67 gpe1D: 0 invalid 67 gpe1D: 0 invalid
68 gpe1E: 0 invalid 68 gpe1E: 0 invalid
69 gpe1F: 0 invalid 69 gpe1F: 0 invalid
70 gpe_all: 1192 70 gpe_all: 1192
71 sci: 1194 71 sci: 1194
72 72
73 sci - The total number of times the ACPI SCI 73 sci - The total number of times the ACPI SCI
74 has claimed an interrupt. 74 has claimed an interrupt.
75 75
76 gpe_all - count of SCI caused by GPEs. 76 gpe_all - count of SCI caused by GPEs.
77 77
78 gpeXX - count for individual GPE source 78 gpeXX - count for individual GPE source
79 79
80 ff_gbl_lock - Global Lock 80 ff_gbl_lock - Global Lock
81 81
82 ff_pmtimer - PM Timer 82 ff_pmtimer - PM Timer
83 83
84 ff_pwr_btn - Power Button 84 ff_pwr_btn - Power Button
85 85
86 ff_rt_clk - Real Time Clock 86 ff_rt_clk - Real Time Clock
87 87
88 ff_slp_btn - Sleep Button 88 ff_slp_btn - Sleep Button
89 89
90 error - an interrupt that can't be accounted for above. 90 error - an interrupt that can't be accounted for above.
91 91
92 invalid: it's either a wakeup GPE or a GPE/Fixed Event that 92 invalid: it's either a GPE or a Fixed Event that
93 doesn't have an event handler. 93 doesn't have an event handler.
94 94
95 disable: the GPE/Fixed Event is valid but disabled. 95 disable: the GPE/Fixed Event is valid but disabled.
96 96
97 enable: the GPE/Fixed Event is valid and enabled. 97 enable: the GPE/Fixed Event is valid and enabled.
98 98
99 Root has permission to clear any of these counters. Eg. 99 Root has permission to clear any of these counters. Eg.
100 # echo 0 > gpe11 100 # echo 0 > gpe11
101 101
102 All counters can be cleared by clearing the total "sci": 102 All counters can be cleared by clearing the total "sci":
103 # echo 0 > sci 103 # echo 0 > sci
104 104
105 None of these counters has an effect on the function 105 None of these counters has an effect on the function
106 of the system, they are simply statistics. 106 of the system, they are simply statistics.
107 107
108 Besides this, user can also write specific strings to these files 108 Besides this, user can also write specific strings to these files
109 to enable/disable/clear ACPI interrupts in user space, which can be 109 to enable/disable/clear ACPI interrupts in user space, which can be
110 used to debug some ACPI interrupt storm issues. 110 used to debug some ACPI interrupt storm issues.
111 111
112 Note that only writting to VALID GPE/Fixed Event is allowed, 112 Note that only writting to VALID GPE/Fixed Event is allowed,
113 i.e. user can only change the status of runtime GPE and 113 i.e. user can only change the status of runtime GPE and
114 Fixed Event with event handler installed. 114 Fixed Event with event handler installed.
115 115
116 Let's take power button fixed event for example, please kill acpid 116 Let's take power button fixed event for example, please kill acpid
117 and other user space applications so that the machine won't shutdown 117 and other user space applications so that the machine won't shutdown
118 when pressing the power button. 118 when pressing the power button.
119 # cat ff_pwr_btn 119 # cat ff_pwr_btn
120 0 120 0 enabled
121 # press the power button for 3 times; 121 # press the power button for 3 times;
122 # cat ff_pwr_btn 122 # cat ff_pwr_btn
123 3 123 3 enabled
124 # echo disable > ff_pwr_btn 124 # echo disable > ff_pwr_btn
125 # cat ff_pwr_btn 125 # cat ff_pwr_btn
126 disable 126 3 disabled
127 # press the power button for 3 times; 127 # press the power button for 3 times;
128 # cat ff_pwr_btn 128 # cat ff_pwr_btn
129 disable 129 3 disabled
130 # echo enable > ff_pwr_btn 130 # echo enable > ff_pwr_btn
131 # cat ff_pwr_btn 131 # cat ff_pwr_btn
132 4 132 4 enabled
133 /* 133 /*
134 * this is because the status bit is set even if the enable bit is cleared, 134 * this is because the status bit is set even if the enable bit is cleared,
135 * and it triggers an ACPI fixed event when the enable bit is set again 135 * and it triggers an ACPI fixed event when the enable bit is set again
136 */ 136 */
137 # press the power button for 3 times; 137 # press the power button for 3 times;
138 # cat ff_pwr_btn 138 # cat ff_pwr_btn
139 7 139 7 enabled
140 # echo disable > ff_pwr_btn 140 # echo disable > ff_pwr_btn
141 # press the power button for 3 times; 141 # press the power button for 3 times;
142 # echo clear > ff_pwr_btn /* clear the status bit */ 142 # echo clear > ff_pwr_btn /* clear the status bit */
143 # echo disable > ff_pwr_btn 143 # echo disable > ff_pwr_btn
144 # cat ff_pwr_btn 144 # cat ff_pwr_btn
145 7 145 7 enabled
146 146
147 147
drivers/acpi/events/evxfevnt.c
Diff comments   View file @ ed206fa
1 /****************************************************************************** 1 /******************************************************************************
2 * 2 *
3 * Module Name: evxfevnt - External Interfaces, ACPI event disable/enable 3 * Module Name: evxfevnt - External Interfaces, ACPI event disable/enable
4 * 4 *
5 *****************************************************************************/ 5 *****************************************************************************/
6 6
7 /* 7 /*
8 * Copyright (C) 2000 - 2008, Intel Corp. 8 * Copyright (C) 2000 - 2008, Intel Corp.
9 * All rights reserved. 9 * All rights reserved.
10 * 10 *
11 * Redistribution and use in source and binary forms, with or without 11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions 12 * modification, are permitted provided that the following conditions
13 * are met: 13 * are met:
14 * 1. Redistributions of source code must retain the above copyright 14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions, and the following disclaimer, 15 * notice, this list of conditions, and the following disclaimer,
16 * without modification. 16 * without modification.
17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18 * substantially similar to the "NO WARRANTY" disclaimer below 18 * substantially similar to the "NO WARRANTY" disclaimer below
19 * ("Disclaimer") and any redistribution must be conditioned upon 19 * ("Disclaimer") and any redistribution must be conditioned upon
20 * including a substantially similar Disclaimer requirement for further 20 * including a substantially similar Disclaimer requirement for further
21 * binary redistribution. 21 * binary redistribution.
22 * 3. Neither the names of the above-listed copyright holders nor the names 22 * 3. Neither the names of the above-listed copyright holders nor the names
23 * of any contributors may be used to endorse or promote products derived 23 * of any contributors may be used to endorse or promote products derived
24 * from this software without specific prior written permission. 24 * from this software without specific prior written permission.
25 * 25 *
26 * Alternatively, this software may be distributed under the terms of the 26 * Alternatively, this software may be distributed under the terms of the
27 * GNU General Public License ("GPL") version 2 as published by the Free 27 * GNU General Public License ("GPL") version 2 as published by the Free
28 * Software Foundation. 28 * Software Foundation.
29 * 29 *
30 * NO WARRANTY 30 * NO WARRANTY
31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR 33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41 * POSSIBILITY OF SUCH DAMAGES. 41 * POSSIBILITY OF SUCH DAMAGES.
42 */ 42 */
43 43
44 #include <acpi/acpi.h> 44 #include <acpi/acpi.h>
45 #include <acpi/acevents.h> 45 #include <acpi/acevents.h>
46 #include <acpi/acnamesp.h> 46 #include <acpi/acnamesp.h>
47 #include <acpi/actables.h> 47 #include <acpi/actables.h>
48 48
49 #define _COMPONENT ACPI_EVENTS 49 #define _COMPONENT ACPI_EVENTS
50 ACPI_MODULE_NAME("evxfevnt") 50 ACPI_MODULE_NAME("evxfevnt")
51 51
52 /******************************************************************************* 52 /*******************************************************************************
53 * 53 *
54 * FUNCTION: acpi_enable 54 * FUNCTION: acpi_enable
55 * 55 *
56 * PARAMETERS: None 56 * PARAMETERS: None
57 * 57 *
58 * RETURN: Status 58 * RETURN: Status
59 * 59 *
60 * DESCRIPTION: Transfers the system into ACPI mode. 60 * DESCRIPTION: Transfers the system into ACPI mode.
61 * 61 *
62 ******************************************************************************/ 62 ******************************************************************************/
63 acpi_status acpi_enable(void) 63 acpi_status acpi_enable(void)
64 { 64 {
65 acpi_status status = AE_OK; 65 acpi_status status = AE_OK;
66 66
67 ACPI_FUNCTION_TRACE(acpi_enable); 67 ACPI_FUNCTION_TRACE(acpi_enable);
68 68
69 /* ACPI tables must be present */ 69 /* ACPI tables must be present */
70 70
71 if (!acpi_tb_tables_loaded()) { 71 if (!acpi_tb_tables_loaded()) {
72 return_ACPI_STATUS(AE_NO_ACPI_TABLES); 72 return_ACPI_STATUS(AE_NO_ACPI_TABLES);
73 } 73 }
74 74
75 /* Check current mode */ 75 /* Check current mode */
76 76
77 if (acpi_hw_get_mode() == ACPI_SYS_MODE_ACPI) { 77 if (acpi_hw_get_mode() == ACPI_SYS_MODE_ACPI) {
78 ACPI_DEBUG_PRINT((ACPI_DB_INIT, 78 ACPI_DEBUG_PRINT((ACPI_DB_INIT,
79 "System is already in ACPI mode\n")); 79 "System is already in ACPI mode\n"));
80 } else { 80 } else {
81 /* Transition to ACPI mode */ 81 /* Transition to ACPI mode */
82 82
83 status = acpi_hw_set_mode(ACPI_SYS_MODE_ACPI); 83 status = acpi_hw_set_mode(ACPI_SYS_MODE_ACPI);
84 if (ACPI_FAILURE(status)) { 84 if (ACPI_FAILURE(status)) {
85 ACPI_ERROR((AE_INFO, 85 ACPI_ERROR((AE_INFO,
86 "Could not transition to ACPI mode")); 86 "Could not transition to ACPI mode"));
87 return_ACPI_STATUS(status); 87 return_ACPI_STATUS(status);
88 } 88 }
89 89
90 ACPI_DEBUG_PRINT((ACPI_DB_INIT, 90 ACPI_DEBUG_PRINT((ACPI_DB_INIT,
91 "Transition to ACPI mode successful\n")); 91 "Transition to ACPI mode successful\n"));
92 } 92 }
93 93
94 return_ACPI_STATUS(status); 94 return_ACPI_STATUS(status);
95 } 95 }
96 96
97 ACPI_EXPORT_SYMBOL(acpi_enable) 97 ACPI_EXPORT_SYMBOL(acpi_enable)
98 98
99 /******************************************************************************* 99 /*******************************************************************************
100 * 100 *
101 * FUNCTION: acpi_disable 101 * FUNCTION: acpi_disable
102 * 102 *
103 * PARAMETERS: None 103 * PARAMETERS: None
104 * 104 *
105 * RETURN: Status 105 * RETURN: Status
106 * 106 *
107 * DESCRIPTION: Transfers the system into LEGACY (non-ACPI) mode. 107 * DESCRIPTION: Transfers the system into LEGACY (non-ACPI) mode.
108 * 108 *
109 ******************************************************************************/ 109 ******************************************************************************/
110 acpi_status acpi_disable(void) 110 acpi_status acpi_disable(void)
111 { 111 {
112 acpi_status status = AE_OK; 112 acpi_status status = AE_OK;
113 113
114 ACPI_FUNCTION_TRACE(acpi_disable); 114 ACPI_FUNCTION_TRACE(acpi_disable);
115 115
116 if (acpi_hw_get_mode() == ACPI_SYS_MODE_LEGACY) { 116 if (acpi_hw_get_mode() == ACPI_SYS_MODE_LEGACY) {
117 ACPI_DEBUG_PRINT((ACPI_DB_INIT, 117 ACPI_DEBUG_PRINT((ACPI_DB_INIT,
118 "System is already in legacy (non-ACPI) mode\n")); 118 "System is already in legacy (non-ACPI) mode\n"));
119 } else { 119 } else {
120 /* Transition to LEGACY mode */ 120 /* Transition to LEGACY mode */
121 121
122 status = acpi_hw_set_mode(ACPI_SYS_MODE_LEGACY); 122 status = acpi_hw_set_mode(ACPI_SYS_MODE_LEGACY);
123 123
124 if (ACPI_FAILURE(status)) { 124 if (ACPI_FAILURE(status)) {
125 ACPI_ERROR((AE_INFO, 125 ACPI_ERROR((AE_INFO,
126 "Could not exit ACPI mode to legacy mode")); 126 "Could not exit ACPI mode to legacy mode"));
127 return_ACPI_STATUS(status); 127 return_ACPI_STATUS(status);
128 } 128 }
129 129
130 ACPI_DEBUG_PRINT((ACPI_DB_INIT, "ACPI mode disabled\n")); 130 ACPI_DEBUG_PRINT((ACPI_DB_INIT, "ACPI mode disabled\n"));
131 } 131 }
132 132
133 return_ACPI_STATUS(status); 133 return_ACPI_STATUS(status);
134 } 134 }
135 135
136 ACPI_EXPORT_SYMBOL(acpi_disable) 136 ACPI_EXPORT_SYMBOL(acpi_disable)
137 137
138 /******************************************************************************* 138 /*******************************************************************************
139 * 139 *
140 * FUNCTION: acpi_enable_event 140 * FUNCTION: acpi_enable_event
141 * 141 *
142 * PARAMETERS: Event - The fixed eventto be enabled 142 * PARAMETERS: Event - The fixed eventto be enabled
143 * Flags - Reserved 143 * Flags - Reserved
144 * 144 *
145 * RETURN: Status 145 * RETURN: Status
146 * 146 *
147 * DESCRIPTION: Enable an ACPI event (fixed) 147 * DESCRIPTION: Enable an ACPI event (fixed)
148 * 148 *
149 ******************************************************************************/ 149 ******************************************************************************/
150 acpi_status acpi_enable_event(u32 event, u32 flags) 150 acpi_status acpi_enable_event(u32 event, u32 flags)
151 { 151 {
152 acpi_status status = AE_OK; 152 acpi_status status = AE_OK;
153 u32 value; 153 u32 value;
154 154
155 ACPI_FUNCTION_TRACE(acpi_enable_event); 155 ACPI_FUNCTION_TRACE(acpi_enable_event);
156 156
157 /* Decode the Fixed Event */ 157 /* Decode the Fixed Event */
158 158
159 if (event > ACPI_EVENT_MAX) { 159 if (event > ACPI_EVENT_MAX) {
160 return_ACPI_STATUS(AE_BAD_PARAMETER); 160 return_ACPI_STATUS(AE_BAD_PARAMETER);
161 } 161 }
162 162
163 /* 163 /*
164 * Enable the requested fixed event (by writing a one to the 164 * Enable the requested fixed event (by writing a one to the
165 * enable register bit) 165 * enable register bit)
166 */ 166 */
167 status = 167 status =
168 acpi_set_register(acpi_gbl_fixed_event_info[event]. 168 acpi_set_register(acpi_gbl_fixed_event_info[event].
169 enable_register_id, 1); 169 enable_register_id, 1);
170 if (ACPI_FAILURE(status)) { 170 if (ACPI_FAILURE(status)) {
171 return_ACPI_STATUS(status); 171 return_ACPI_STATUS(status);
172 } 172 }
173 173
174 /* Make sure that the hardware responded */ 174 /* Make sure that the hardware responded */
175 175
176 status = 176 status =
177 acpi_get_register(acpi_gbl_fixed_event_info[event]. 177 acpi_get_register(acpi_gbl_fixed_event_info[event].
178 enable_register_id, &value); 178 enable_register_id, &value);
179 if (ACPI_FAILURE(status)) { 179 if (ACPI_FAILURE(status)) {
180 return_ACPI_STATUS(status); 180 return_ACPI_STATUS(status);
181 } 181 }
182 182
183 if (value != 1) { 183 if (value != 1) {
184 ACPI_ERROR((AE_INFO, 184 ACPI_ERROR((AE_INFO,
185 "Could not enable %s event", 185 "Could not enable %s event",
186 acpi_ut_get_event_name(event))); 186 acpi_ut_get_event_name(event)));
187 return_ACPI_STATUS(AE_NO_HARDWARE_RESPONSE); 187 return_ACPI_STATUS(AE_NO_HARDWARE_RESPONSE);
188 } 188 }
189 189
190 return_ACPI_STATUS(status); 190 return_ACPI_STATUS(status);
191 } 191 }
192 192
193 ACPI_EXPORT_SYMBOL(acpi_enable_event) 193 ACPI_EXPORT_SYMBOL(acpi_enable_event)
194 194
195 /******************************************************************************* 195 /*******************************************************************************
196 * 196 *
197 * FUNCTION: acpi_set_gpe_type 197 * FUNCTION: acpi_set_gpe_type
198 * 198 *
199 * PARAMETERS: gpe_device - Parent GPE Device 199 * PARAMETERS: gpe_device - Parent GPE Device
200 * gpe_number - GPE level within the GPE block 200 * gpe_number - GPE level within the GPE block
201 * Type - New GPE type 201 * Type - New GPE type
202 * 202 *
203 * RETURN: Status 203 * RETURN: Status
204 * 204 *
205 * DESCRIPTION: Set the type of an individual GPE 205 * DESCRIPTION: Set the type of an individual GPE
206 * 206 *
207 ******************************************************************************/ 207 ******************************************************************************/
208 acpi_status acpi_set_gpe_type(acpi_handle gpe_device, u32 gpe_number, u8 type) 208 acpi_status acpi_set_gpe_type(acpi_handle gpe_device, u32 gpe_number, u8 type)
209 { 209 {
210 acpi_status status = AE_OK; 210 acpi_status status = AE_OK;
211 struct acpi_gpe_event_info *gpe_event_info; 211 struct acpi_gpe_event_info *gpe_event_info;
212 212
213 ACPI_FUNCTION_TRACE(acpi_set_gpe_type); 213 ACPI_FUNCTION_TRACE(acpi_set_gpe_type);
214 214
215 /* Ensure that we have a valid GPE number */ 215 /* Ensure that we have a valid GPE number */
216 216
217 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number); 217 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
218 if (!gpe_event_info) { 218 if (!gpe_event_info) {
219 status = AE_BAD_PARAMETER; 219 status = AE_BAD_PARAMETER;
220 goto unlock_and_exit; 220 goto unlock_and_exit;
221 } 221 }
222 222
223 if ((gpe_event_info->flags & ACPI_GPE_TYPE_MASK) == type) { 223 if ((gpe_event_info->flags & ACPI_GPE_TYPE_MASK) == type) {
224 return_ACPI_STATUS(AE_OK); 224 return_ACPI_STATUS(AE_OK);
225 } 225 }
226 226
227 /* Set the new type (will disable GPE if currently enabled) */ 227 /* Set the new type (will disable GPE if currently enabled) */
228 228
229 status = acpi_ev_set_gpe_type(gpe_event_info, type); 229 status = acpi_ev_set_gpe_type(gpe_event_info, type);
230 230
231 unlock_and_exit: 231 unlock_and_exit:
232 return_ACPI_STATUS(status); 232 return_ACPI_STATUS(status);
233 } 233 }
234 234
235 ACPI_EXPORT_SYMBOL(acpi_set_gpe_type) 235 ACPI_EXPORT_SYMBOL(acpi_set_gpe_type)
236 236
237 /******************************************************************************* 237 /*******************************************************************************
238 * 238 *
239 * FUNCTION: acpi_enable_gpe 239 * FUNCTION: acpi_enable_gpe
240 * 240 *
241 * PARAMETERS: gpe_device - Parent GPE Device 241 * PARAMETERS: gpe_device - Parent GPE Device
242 * gpe_number - GPE level within the GPE block 242 * gpe_number - GPE level within the GPE block
243 * Flags - Just enable, or also wake enable? 243 * Flags - Just enable, or also wake enable?
244 * Called from ISR or not 244 * Called from ISR or not
245 * 245 *
246 * RETURN: Status 246 * RETURN: Status
247 * 247 *
248 * DESCRIPTION: Enable an ACPI event (general purpose) 248 * DESCRIPTION: Enable an ACPI event (general purpose)
249 * 249 *
250 ******************************************************************************/ 250 ******************************************************************************/
251 acpi_status acpi_enable_gpe(acpi_handle gpe_device, u32 gpe_number, u32 flags) 251 acpi_status acpi_enable_gpe(acpi_handle gpe_device, u32 gpe_number, u32 flags)
252 { 252 {
253 acpi_status status = AE_OK; 253 acpi_status status = AE_OK;
254 struct acpi_gpe_event_info *gpe_event_info; 254 struct acpi_gpe_event_info *gpe_event_info;
255 255
256 ACPI_FUNCTION_TRACE(acpi_enable_gpe); 256 ACPI_FUNCTION_TRACE(acpi_enable_gpe);
257 257
258 /* Use semaphore lock if not executing at interrupt level */ 258 /* Use semaphore lock if not executing at interrupt level */
259 259
260 if (flags & ACPI_NOT_ISR) { 260 if (flags & ACPI_NOT_ISR) {
261 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS); 261 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
262 if (ACPI_FAILURE(status)) { 262 if (ACPI_FAILURE(status)) {
263 return_ACPI_STATUS(status); 263 return_ACPI_STATUS(status);
264 } 264 }
265 } 265 }
266 266
267 /* Ensure that we have a valid GPE number */ 267 /* Ensure that we have a valid GPE number */
268 268
269 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number); 269 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
270 if (!gpe_event_info) { 270 if (!gpe_event_info) {
271 status = AE_BAD_PARAMETER; 271 status = AE_BAD_PARAMETER;
272 goto unlock_and_exit; 272 goto unlock_and_exit;
273 } 273 }
274 274
275 /* Perform the enable */ 275 /* Perform the enable */
276 276
277 status = acpi_ev_enable_gpe(gpe_event_info, TRUE); 277 status = acpi_ev_enable_gpe(gpe_event_info, TRUE);
278 278
279 unlock_and_exit: 279 unlock_and_exit:
280 if (flags & ACPI_NOT_ISR) { 280 if (flags & ACPI_NOT_ISR) {
281 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS); 281 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
282 } 282 }
283 return_ACPI_STATUS(status); 283 return_ACPI_STATUS(status);
284 } 284 }
285 285
286 ACPI_EXPORT_SYMBOL(acpi_enable_gpe) 286 ACPI_EXPORT_SYMBOL(acpi_enable_gpe)
287 287
288 /******************************************************************************* 288 /*******************************************************************************
289 * 289 *
290 * FUNCTION: acpi_disable_gpe 290 * FUNCTION: acpi_disable_gpe
291 * 291 *
292 * PARAMETERS: gpe_device - Parent GPE Device 292 * PARAMETERS: gpe_device - Parent GPE Device
293 * gpe_number - GPE level within the GPE block 293 * gpe_number - GPE level within the GPE block
294 * Flags - Just disable, or also wake disable? 294 * Flags - Just disable, or also wake disable?
295 * Called from ISR or not 295 * Called from ISR or not
296 * 296 *
297 * RETURN: Status 297 * RETURN: Status
298 * 298 *
299 * DESCRIPTION: Disable an ACPI event (general purpose) 299 * DESCRIPTION: Disable an ACPI event (general purpose)
300 * 300 *
301 ******************************************************************************/ 301 ******************************************************************************/
302 acpi_status acpi_disable_gpe(acpi_handle gpe_device, u32 gpe_number, u32 flags) 302 acpi_status acpi_disable_gpe(acpi_handle gpe_device, u32 gpe_number, u32 flags)
303 { 303 {
304 acpi_status status = AE_OK; 304 acpi_status status = AE_OK;
305 struct acpi_gpe_event_info *gpe_event_info; 305 struct acpi_gpe_event_info *gpe_event_info;
306 306
307 ACPI_FUNCTION_TRACE(acpi_disable_gpe); 307 ACPI_FUNCTION_TRACE(acpi_disable_gpe);
308 308
309 /* Use semaphore lock if not executing at interrupt level */ 309 /* Use semaphore lock if not executing at interrupt level */
310 310
311 if (flags & ACPI_NOT_ISR) { 311 if (flags & ACPI_NOT_ISR) {
312 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS); 312 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
313 if (ACPI_FAILURE(status)) { 313 if (ACPI_FAILURE(status)) {
314 return_ACPI_STATUS(status); 314 return_ACPI_STATUS(status);
315 } 315 }
316 } 316 }
317 317
318 /* Ensure that we have a valid GPE number */ 318 /* Ensure that we have a valid GPE number */
319 319
320 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number); 320 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
321 if (!gpe_event_info) { 321 if (!gpe_event_info) {
322 status = AE_BAD_PARAMETER; 322 status = AE_BAD_PARAMETER;
323 goto unlock_and_exit; 323 goto unlock_and_exit;
324 } 324 }
325 325
326 status = acpi_ev_disable_gpe(gpe_event_info); 326 status = acpi_ev_disable_gpe(gpe_event_info);
327 327
328 unlock_and_exit: 328 unlock_and_exit:
329 if (flags & ACPI_NOT_ISR) { 329 if (flags & ACPI_NOT_ISR) {
330 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS); 330 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
331 } 331 }
332 return_ACPI_STATUS(status); 332 return_ACPI_STATUS(status);
333 } 333 }
334 334
335 ACPI_EXPORT_SYMBOL(acpi_disable_gpe) 335 ACPI_EXPORT_SYMBOL(acpi_disable_gpe)
336 336
337 /******************************************************************************* 337 /*******************************************************************************
338 * 338 *
339 * FUNCTION: acpi_disable_event 339 * FUNCTION: acpi_disable_event
340 * 340 *
341 * PARAMETERS: Event - The fixed eventto be enabled 341 * PARAMETERS: Event - The fixed eventto be enabled
342 * Flags - Reserved 342 * Flags - Reserved
343 * 343 *
344 * RETURN: Status 344 * RETURN: Status
345 * 345 *
346 * DESCRIPTION: Disable an ACPI event (fixed) 346 * DESCRIPTION: Disable an ACPI event (fixed)
347 * 347 *
348 ******************************************************************************/ 348 ******************************************************************************/
349 acpi_status acpi_disable_event(u32 event, u32 flags) 349 acpi_status acpi_disable_event(u32 event, u32 flags)
350 { 350 {
351 acpi_status status = AE_OK; 351 acpi_status status = AE_OK;
352 u32 value; 352 u32 value;
353 353
354 ACPI_FUNCTION_TRACE(acpi_disable_event); 354 ACPI_FUNCTION_TRACE(acpi_disable_event);
355 355
356 /* Decode the Fixed Event */ 356 /* Decode the Fixed Event */
357 357
358 if (event > ACPI_EVENT_MAX) { 358 if (event > ACPI_EVENT_MAX) {
359 return_ACPI_STATUS(AE_BAD_PARAMETER); 359 return_ACPI_STATUS(AE_BAD_PARAMETER);
360 } 360 }
361 361
362 /* 362 /*
363 * Disable the requested fixed event (by writing a zero to the 363 * Disable the requested fixed event (by writing a zero to the
364 * enable register bit) 364 * enable register bit)
365 */ 365 */
366 status = 366 status =
367 acpi_set_register(acpi_gbl_fixed_event_info[event]. 367 acpi_set_register(acpi_gbl_fixed_event_info[event].
368 enable_register_id, 0); 368 enable_register_id, 0);
369 if (ACPI_FAILURE(status)) { 369 if (ACPI_FAILURE(status)) {
370 return_ACPI_STATUS(status); 370 return_ACPI_STATUS(status);
371 } 371 }
372 372
373 status = 373 status =
374 acpi_get_register(acpi_gbl_fixed_event_info[event]. 374 acpi_get_register(acpi_gbl_fixed_event_info[event].
375 enable_register_id, &value); 375 enable_register_id, &value);
376 if (ACPI_FAILURE(status)) { 376 if (ACPI_FAILURE(status)) {
377 return_ACPI_STATUS(status); 377 return_ACPI_STATUS(status);
378 } 378 }
379 379
380 if (value != 0) { 380 if (value != 0) {
381 ACPI_ERROR((AE_INFO, 381 ACPI_ERROR((AE_INFO,
382 "Could not disable %s events", 382 "Could not disable %s events",
383 acpi_ut_get_event_name(event))); 383 acpi_ut_get_event_name(event)));
384 return_ACPI_STATUS(AE_NO_HARDWARE_RESPONSE); 384 return_ACPI_STATUS(AE_NO_HARDWARE_RESPONSE);
385 } 385 }
386 386
387 return_ACPI_STATUS(status); 387 return_ACPI_STATUS(status);
388 } 388 }
389 389
390 ACPI_EXPORT_SYMBOL(acpi_disable_event) 390 ACPI_EXPORT_SYMBOL(acpi_disable_event)
391 391
392 /******************************************************************************* 392 /*******************************************************************************
393 * 393 *
394 * FUNCTION: acpi_clear_event 394 * FUNCTION: acpi_clear_event
395 * 395 *
396 * PARAMETERS: Event - The fixed event to be cleared 396 * PARAMETERS: Event - The fixed event to be cleared
397 * 397 *
398 * RETURN: Status 398 * RETURN: Status
399 * 399 *
400 * DESCRIPTION: Clear an ACPI event (fixed) 400 * DESCRIPTION: Clear an ACPI event (fixed)
401 * 401 *
402 ******************************************************************************/ 402 ******************************************************************************/
403 acpi_status acpi_clear_event(u32 event) 403 acpi_status acpi_clear_event(u32 event)
404 { 404 {
405 acpi_status status = AE_OK; 405 acpi_status status = AE_OK;
406 406
407 ACPI_FUNCTION_TRACE(acpi_clear_event); 407 ACPI_FUNCTION_TRACE(acpi_clear_event);
408 408
409 /* Decode the Fixed Event */ 409 /* Decode the Fixed Event */
410 410
411 if (event > ACPI_EVENT_MAX) { 411 if (event > ACPI_EVENT_MAX) {
412 return_ACPI_STATUS(AE_BAD_PARAMETER); 412 return_ACPI_STATUS(AE_BAD_PARAMETER);
413 } 413 }
414 414
415 /* 415 /*
416 * Clear the requested fixed event (By writing a one to the 416 * Clear the requested fixed event (By writing a one to the
417 * status register bit) 417 * status register bit)
418 */ 418 */
419 status = 419 status =
420 acpi_set_register(acpi_gbl_fixed_event_info[event]. 420 acpi_set_register(acpi_gbl_fixed_event_info[event].
421 status_register_id, 1); 421 status_register_id, 1);
422 422
423 return_ACPI_STATUS(status); 423 return_ACPI_STATUS(status);
424 } 424 }
425 425
426 ACPI_EXPORT_SYMBOL(acpi_clear_event) 426 ACPI_EXPORT_SYMBOL(acpi_clear_event)
427 427
428 /******************************************************************************* 428 /*******************************************************************************
429 * 429 *
430 * FUNCTION: acpi_clear_gpe 430 * FUNCTION: acpi_clear_gpe
431 * 431 *
432 * PARAMETERS: gpe_device - Parent GPE Device 432 * PARAMETERS: gpe_device - Parent GPE Device
433 * gpe_number - GPE level within the GPE block 433 * gpe_number - GPE level within the GPE block
434 * Flags - Called from an ISR or not 434 * Flags - Called from an ISR or not
435 * 435 *
436 * RETURN: Status 436 * RETURN: Status
437 * 437 *
438 * DESCRIPTION: Clear an ACPI event (general purpose) 438 * DESCRIPTION: Clear an ACPI event (general purpose)
439 * 439 *
440 ******************************************************************************/ 440 ******************************************************************************/
441 acpi_status acpi_clear_gpe(acpi_handle gpe_device, u32 gpe_number, u32 flags) 441 acpi_status acpi_clear_gpe(acpi_handle gpe_device, u32 gpe_number, u32 flags)
442 { 442 {
443 acpi_status status = AE_OK; 443 acpi_status status = AE_OK;
444 struct acpi_gpe_event_info *gpe_event_info; 444 struct acpi_gpe_event_info *gpe_event_info;
445 445
446 ACPI_FUNCTION_TRACE(acpi_clear_gpe); 446 ACPI_FUNCTION_TRACE(acpi_clear_gpe);
447 447
448 /* Use semaphore lock if not executing at interrupt level */ 448 /* Use semaphore lock if not executing at interrupt level */
449 449
450 if (flags & ACPI_NOT_ISR) { 450 if (flags & ACPI_NOT_ISR) {
451 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS); 451 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
452 if (ACPI_FAILURE(status)) { 452 if (ACPI_FAILURE(status)) {
453 return_ACPI_STATUS(status); 453 return_ACPI_STATUS(status);
454 } 454 }
455 } 455 }
456 456
457 /* Ensure that we have a valid GPE number */ 457 /* Ensure that we have a valid GPE number */
458 458
459 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number); 459 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
460 if (!gpe_event_info) { 460 if (!gpe_event_info) {
461 status = AE_BAD_PARAMETER; 461 status = AE_BAD_PARAMETER;
462 goto unlock_and_exit; 462 goto unlock_and_exit;
463 } 463 }
464 464
465 status = acpi_hw_clear_gpe(gpe_event_info); 465 status = acpi_hw_clear_gpe(gpe_event_info);
466 466
467 unlock_and_exit: 467 unlock_and_exit:
468 if (flags & ACPI_NOT_ISR) { 468 if (flags & ACPI_NOT_ISR) {
469 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS); 469 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
470 } 470 }
471 return_ACPI_STATUS(status); 471 return_ACPI_STATUS(status);
472 } 472 }
473 473
474 ACPI_EXPORT_SYMBOL(acpi_clear_gpe) 474 ACPI_EXPORT_SYMBOL(acpi_clear_gpe)
475 /******************************************************************************* 475 /*******************************************************************************
476 * 476 *
477 * FUNCTION: acpi_get_event_status 477 * FUNCTION: acpi_get_event_status
478 * 478 *
479 * PARAMETERS: Event - The fixed event 479 * PARAMETERS: Event - The fixed event
480 * event_status - Where the current status of the event will 480 * event_status - Where the current status of the event will
481 * be returned 481 * be returned
482 * 482 *
483 * RETURN: Status 483 * RETURN: Status
484 * 484 *
485 * DESCRIPTION: Obtains and returns the current status of the event 485 * DESCRIPTION: Obtains and returns the current status of the event
486 * 486 *
487 ******************************************************************************/ 487 ******************************************************************************/
488 acpi_status acpi_get_event_status(u32 event, acpi_event_status * event_status) 488 acpi_status acpi_get_event_status(u32 event, acpi_event_status * event_status)
489 { 489 {
490 acpi_status status = AE_OK; 490 acpi_status status = AE_OK;
491 u32 value; 491 u32 value;
492 492
493 ACPI_FUNCTION_TRACE(acpi_get_event_status); 493 ACPI_FUNCTION_TRACE(acpi_get_event_status);
494 494
495 if (!event_status) { 495 if (!event_status) {
496 return_ACPI_STATUS(AE_BAD_PARAMETER); 496 return_ACPI_STATUS(AE_BAD_PARAMETER);
497 } 497 }
498 498
499 /* Decode the Fixed Event */ 499 /* Decode the Fixed Event */
500 500
501 if (event > ACPI_EVENT_MAX) { 501 if (event > ACPI_EVENT_MAX) {
502 return_ACPI_STATUS(AE_BAD_PARAMETER); 502 return_ACPI_STATUS(AE_BAD_PARAMETER);
503 } 503 }
504 504
505 /* Get the status of the requested fixed event */ 505 /* Get the status of the requested fixed event */
506 506
507 status = 507 status =
508 acpi_get_register(acpi_gbl_fixed_event_info[event]. 508 acpi_get_register(acpi_gbl_fixed_event_info[event].
509 enable_register_id, &value); 509 enable_register_id, &value);
510 if (ACPI_FAILURE(status)) 510 if (ACPI_FAILURE(status))
511 return_ACPI_STATUS(status); 511 return_ACPI_STATUS(status);
512 512
513 *event_status = value; 513 *event_status = value;
514 514
515 status = 515 status =
516 acpi_get_register(acpi_gbl_fixed_event_info[event]. 516 acpi_get_register(acpi_gbl_fixed_event_info[event].
517 status_register_id, &value); 517 status_register_id, &value);
518 if (ACPI_FAILURE(status)) 518 if (ACPI_FAILURE(status))
519 return_ACPI_STATUS(status); 519 return_ACPI_STATUS(status);
520 520
521 if (value) 521 if (value)
522 *event_status |= ACPI_EVENT_FLAG_SET; 522 *event_status |= ACPI_EVENT_FLAG_SET;
523 523
524 if (acpi_gbl_fixed_event_handlers[event].handler)
525 *event_status |= ACPI_EVENT_FLAG_HANDLE;
526
524 return_ACPI_STATUS(status); 527 return_ACPI_STATUS(status);
525 } 528 }
526 529
527 ACPI_EXPORT_SYMBOL(acpi_get_event_status) 530 ACPI_EXPORT_SYMBOL(acpi_get_event_status)
528 531
529 /******************************************************************************* 532 /*******************************************************************************
530 * 533 *
531 * FUNCTION: acpi_get_gpe_status 534 * FUNCTION: acpi_get_gpe_status
532 * 535 *
533 * PARAMETERS: gpe_device - Parent GPE Device 536 * PARAMETERS: gpe_device - Parent GPE Device
534 * gpe_number - GPE level within the GPE block 537 * gpe_number - GPE level within the GPE block
535 * Flags - Called from an ISR or not 538 * Flags - Called from an ISR or not
536 * event_status - Where the current status of the event will 539 * event_status - Where the current status of the event will
537 * be returned 540 * be returned
538 * 541 *
539 * RETURN: Status 542 * RETURN: Status
540 * 543 *
541 * DESCRIPTION: Get status of an event (general purpose) 544 * DESCRIPTION: Get status of an event (general purpose)
542 * 545 *
543 ******************************************************************************/ 546 ******************************************************************************/
544 acpi_status 547 acpi_status
545 acpi_get_gpe_status(acpi_handle gpe_device, 548 acpi_get_gpe_status(acpi_handle gpe_device,
546 u32 gpe_number, u32 flags, acpi_event_status * event_status) 549 u32 gpe_number, u32 flags, acpi_event_status * event_status)
547 { 550 {
548 acpi_status status = AE_OK; 551 acpi_status status = AE_OK;
549 struct acpi_gpe_event_info *gpe_event_info; 552 struct acpi_gpe_event_info *gpe_event_info;
550 553
551 ACPI_FUNCTION_TRACE(acpi_get_gpe_status); 554 ACPI_FUNCTION_TRACE(acpi_get_gpe_status);
552 555
553 /* Use semaphore lock if not executing at interrupt level */ 556 /* Use semaphore lock if not executing at interrupt level */
554 557
555 if (flags & ACPI_NOT_ISR) { 558 if (flags & ACPI_NOT_ISR) {
556 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS); 559 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
557 if (ACPI_FAILURE(status)) { 560 if (ACPI_FAILURE(status)) {
558 return_ACPI_STATUS(status); 561 return_ACPI_STATUS(status);
559 } 562 }
560 } 563 }
561 564
562 /* Ensure that we have a valid GPE number */ 565 /* Ensure that we have a valid GPE number */
563 566
564 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number); 567 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
565 if (!gpe_event_info) { 568 if (!gpe_event_info) {
566 status = AE_BAD_PARAMETER; 569 status = AE_BAD_PARAMETER;
567 goto unlock_and_exit; 570 goto unlock_and_exit;
568 } 571 }
569 572
570 /* Obtain status on the requested GPE number */ 573 /* Obtain status on the requested GPE number */
571 574
572 status = acpi_hw_get_gpe_status(gpe_event_info, event_status); 575 status = acpi_hw_get_gpe_status(gpe_event_info, event_status);
576
577 if (gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK)
578 *event_status |= ACPI_EVENT_FLAG_HANDLE;
573 579
574 unlock_and_exit: 580 unlock_and_exit:
575 if (flags & ACPI_NOT_ISR) { 581 if (flags & ACPI_NOT_ISR) {
576 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS); 582 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
577 } 583 }
578 return_ACPI_STATUS(status); 584 return_ACPI_STATUS(status);
579 } 585 }
580 586
581 ACPI_EXPORT_SYMBOL(acpi_get_gpe_status) 587 ACPI_EXPORT_SYMBOL(acpi_get_gpe_status)
582 /******************************************************************************* 588 /*******************************************************************************
583 * 589 *
584 * FUNCTION: acpi_install_gpe_block 590 * FUNCTION: acpi_install_gpe_block
585 * 591 *
586 * PARAMETERS: gpe_device - Handle to the parent GPE Block Device 592 * PARAMETERS: gpe_device - Handle to the parent GPE Block Device
587 * gpe_block_address - Address and space_iD 593 * gpe_block_address - Address and space_iD
588 * register_count - Number of GPE register pairs in the block 594 * register_count - Number of GPE register pairs in the block
589 * interrupt_number - H/W interrupt for the block 595 * interrupt_number - H/W interrupt for the block
590 * 596 *
591 * RETURN: Status 597 * RETURN: Status
592 * 598 *
593 * DESCRIPTION: Create and Install a block of GPE registers 599 * DESCRIPTION: Create and Install a block of GPE registers
594 * 600 *
595 ******************************************************************************/ 601 ******************************************************************************/
596 acpi_status 602 acpi_status
597 acpi_install_gpe_block(acpi_handle gpe_device, 603 acpi_install_gpe_block(acpi_handle gpe_device,
598 struct acpi_generic_address *gpe_block_address, 604 struct acpi_generic_address *gpe_block_address,
599 u32 register_count, u32 interrupt_number) 605 u32 register_count, u32 interrupt_number)
600 { 606 {
601 acpi_status status; 607 acpi_status status;
602 union acpi_operand_object *obj_desc; 608 union acpi_operand_object *obj_desc;
603 struct acpi_namespace_node *node; 609 struct acpi_namespace_node *node;
604 struct acpi_gpe_block_info *gpe_block; 610 struct acpi_gpe_block_info *gpe_block;
605 611
606 ACPI_FUNCTION_TRACE(acpi_install_gpe_block); 612 ACPI_FUNCTION_TRACE(acpi_install_gpe_block);
607 613
608 if ((!gpe_device) || (!gpe_block_address) || (!register_count)) { 614 if ((!gpe_device) || (!gpe_block_address) || (!register_count)) {
609 return_ACPI_STATUS(AE_BAD_PARAMETER); 615 return_ACPI_STATUS(AE_BAD_PARAMETER);
610 } 616 }
611 617
612 status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE); 618 status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
613 if (ACPI_FAILURE(status)) { 619 if (ACPI_FAILURE(status)) {
614 return (status); 620 return (status);
615 } 621 }
616 622
617 node = acpi_ns_map_handle_to_node(gpe_device); 623 node = acpi_ns_map_handle_to_node(gpe_device);
618 if (!node) { 624 if (!node) {
619 status = AE_BAD_PARAMETER; 625 status = AE_BAD_PARAMETER;
620 goto unlock_and_exit; 626 goto unlock_and_exit;
621 } 627 }
622 628
623 /* 629 /*
624 * For user-installed GPE Block Devices, the gpe_block_base_number 630 * For user-installed GPE Block Devices, the gpe_block_base_number
625 * is always zero 631 * is always zero
626 */ 632 */
627 status = 633 status =
628 acpi_ev_create_gpe_block(node, gpe_block_address, register_count, 0, 634 acpi_ev_create_gpe_block(node, gpe_block_address, register_count, 0,
629 interrupt_number, &gpe_block); 635 interrupt_number, &gpe_block);
630 if (ACPI_FAILURE(status)) { 636 if (ACPI_FAILURE(status)) {
631 goto unlock_and_exit; 637 goto unlock_and_exit;
632 } 638 }
633 639
634 /* Run the _PRW methods and enable the GPEs */ 640 /* Run the _PRW methods and enable the GPEs */
635 641
636 status = acpi_ev_initialize_gpe_block(node, gpe_block); 642 status = acpi_ev_initialize_gpe_block(node, gpe_block);
637 if (ACPI_FAILURE(status)) { 643 if (ACPI_FAILURE(status)) {
638 goto unlock_and_exit; 644 goto unlock_and_exit;
639 } 645 }
640 646
641 /* Get the device_object attached to the node */ 647 /* Get the device_object attached to the node */
642 648
643 obj_desc = acpi_ns_get_attached_object(node); 649 obj_desc = acpi_ns_get_attached_object(node);
644 if (!obj_desc) { 650 if (!obj_desc) {
645 651
646 /* No object, create a new one */ 652 /* No object, create a new one */
647 653
648 obj_desc = acpi_ut_create_internal_object(ACPI_TYPE_DEVICE); 654 obj_desc = acpi_ut_create_internal_object(ACPI_TYPE_DEVICE);
649 if (!obj_desc) { 655 if (!obj_desc) {
650 status = AE_NO_MEMORY; 656 status = AE_NO_MEMORY;
651 goto unlock_and_exit; 657 goto unlock_and_exit;
652 } 658 }
653 659
654 status = 660 status =
655 acpi_ns_attach_object(node, obj_desc, ACPI_TYPE_DEVICE); 661 acpi_ns_attach_object(node, obj_desc, ACPI_TYPE_DEVICE);
656 662
657 /* Remove local reference to the object */ 663 /* Remove local reference to the object */
658 664
659 acpi_ut_remove_reference(obj_desc); 665 acpi_ut_remove_reference(obj_desc);
660 666
661 if (ACPI_FAILURE(status)) { 667 if (ACPI_FAILURE(status)) {
662 goto unlock_and_exit; 668 goto unlock_and_exit;
663 } 669 }
664 } 670 }
665 671
666 /* Install the GPE block in the device_object */ 672 /* Install the GPE block in the device_object */
667 673
668 obj_desc->device.gpe_block = gpe_block; 674 obj_desc->device.gpe_block = gpe_block;
669 675
670 unlock_and_exit: 676 unlock_and_exit:
671 (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE); 677 (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
672 return_ACPI_STATUS(status); 678 return_ACPI_STATUS(status);
673 } 679 }
674 680
675 ACPI_EXPORT_SYMBOL(acpi_install_gpe_block) 681 ACPI_EXPORT_SYMBOL(acpi_install_gpe_block)
676 682
677 /******************************************************************************* 683 /*******************************************************************************
678 * 684 *
679 * FUNCTION: acpi_remove_gpe_block 685 * FUNCTION: acpi_remove_gpe_block
680 * 686 *
681 * PARAMETERS: gpe_device - Handle to the parent GPE Block Device 687 * PARAMETERS: gpe_device - Handle to the parent GPE Block Device
682 * 688 *
683 * RETURN: Status 689 * RETURN: Status
684 * 690 *
685 * DESCRIPTION: Remove a previously installed block of GPE registers 691 * DESCRIPTION: Remove a previously installed block of GPE registers
686 * 692 *
687 ******************************************************************************/ 693 ******************************************************************************/
688 acpi_status acpi_remove_gpe_block(acpi_handle gpe_device) 694 acpi_status acpi_remove_gpe_block(acpi_handle gpe_device)
689 { 695 {
690 union acpi_operand_object *obj_desc; 696 union acpi_operand_object *obj_desc;
691 acpi_status status; 697 acpi_status status;
692 struct acpi_namespace_node *node; 698 struct acpi_namespace_node *node;
693 699
694 ACPI_FUNCTION_TRACE(acpi_remove_gpe_block); 700 ACPI_FUNCTION_TRACE(acpi_remove_gpe_block);
695 701
696 if (!gpe_device) { 702 if (!gpe_device) {
697 return_ACPI_STATUS(AE_BAD_PARAMETER); 703 return_ACPI_STATUS(AE_BAD_PARAMETER);
698 } 704 }
699 705
700 status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE); 706 status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
701 if (ACPI_FAILURE(status)) { 707 if (ACPI_FAILURE(status)) {
702 return (status); 708 return (status);
703 } 709 }
704 710
705 node = acpi_ns_map_handle_to_node(gpe_device); 711 node = acpi_ns_map_handle_to_node(gpe_device);
706 if (!node) { 712 if (!node) {
707 status = AE_BAD_PARAMETER; 713 status = AE_BAD_PARAMETER;
708 goto unlock_and_exit; 714 goto unlock_and_exit;
709 } 715 }
710 716
711 /* Get the device_object attached to the node */ 717 /* Get the device_object attached to the node */
712 718
713 obj_desc = acpi_ns_get_attached_object(node); 719 obj_desc = acpi_ns_get_attached_object(node);
714 if (!obj_desc || !obj_desc->device.gpe_block) { 720 if (!obj_desc || !obj_desc->device.gpe_block) {
715 return_ACPI_STATUS(AE_NULL_OBJECT); 721 return_ACPI_STATUS(AE_NULL_OBJECT);
716 } 722 }
717 723
718 /* Delete the GPE block (but not the device_object) */ 724 /* Delete the GPE block (but not the device_object) */
719 725
720 status = acpi_ev_delete_gpe_block(obj_desc->device.gpe_block); 726 status = acpi_ev_delete_gpe_block(obj_desc->device.gpe_block);
721 if (ACPI_SUCCESS(status)) { 727 if (ACPI_SUCCESS(status)) {
722 obj_desc->device.gpe_block = NULL; 728 obj_desc->device.gpe_block = NULL;
723 } 729 }
724 730
725 unlock_and_exit: 731 unlock_and_exit:
726 (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE); 732 (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
727 return_ACPI_STATUS(status); 733 return_ACPI_STATUS(status);
728 } 734 }
729 735
730 ACPI_EXPORT_SYMBOL(acpi_remove_gpe_block) 736 ACPI_EXPORT_SYMBOL(acpi_remove_gpe_block)
731 737
drivers/acpi/system.c
Diff comments   View file @ ed206fa
1 /* 1 /*
2 * acpi_system.c - ACPI System Driver ($Revision: 63 $) 2 * acpi_system.c - ACPI System Driver ($Revision: 63 $)
3 * 3 *
4 * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com> 4 * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
5 * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com> 5 * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
6 * 6 *
7 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
8 * 8 *
9 * This program is free software; you can redistribute it and/or modify 9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by 10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or (at 11 * the Free Software Foundation; either version 2 of the License, or (at
12 * your option) any later version. 12 * your option) any later version.
13 * 13 *
14 * This program is distributed in the hope that it will be useful, but 14 * This program is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of 15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * General Public License for more details. 17 * General Public License for more details.
18 * 18 *
19 * You should have received a copy of the GNU General Public License along 19 * You should have received a copy of the GNU General Public License along
20 * with this program; if not, write to the Free Software Foundation, Inc., 20 * with this program; if not, write to the Free Software Foundation, Inc.,
21 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. 21 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
22 * 22 *
23 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 23 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
24 */ 24 */
25 25
26 #include <linux/proc_fs.h> 26 #include <linux/proc_fs.h>
27 #include <linux/seq_file.h> 27 #include <linux/seq_file.h>
28 #include <linux/init.h> 28 #include <linux/init.h>
29 #include <linux/string.h> 29 #include <linux/string.h>
30 #include <asm/uaccess.h> 30 #include <asm/uaccess.h>
31 31
32 #include <acpi/acpi_drivers.h> 32 #include <acpi/acpi_drivers.h>
33 33
34 #define _COMPONENT ACPI_SYSTEM_COMPONENT 34 #define _COMPONENT ACPI_SYSTEM_COMPONENT
35 ACPI_MODULE_NAME("system"); 35 ACPI_MODULE_NAME("system");
36 #ifdef MODULE_PARAM_PREFIX 36 #ifdef MODULE_PARAM_PREFIX
37 #undef MODULE_PARAM_PREFIX 37 #undef MODULE_PARAM_PREFIX
38 #endif 38 #endif
39 #define MODULE_PARAM_PREFIX "acpi." 39 #define MODULE_PARAM_PREFIX "acpi."
40 40
41 #define ACPI_SYSTEM_CLASS "system" 41 #define ACPI_SYSTEM_CLASS "system"
42 #define ACPI_SYSTEM_DEVICE_NAME "System" 42 #define ACPI_SYSTEM_DEVICE_NAME "System"
43 43
44 u32 acpi_irq_handled; 44 u32 acpi_irq_handled;
45 45
46 /* 46 /*
47 * Make ACPICA version work as module param 47 * Make ACPICA version work as module param
48 */ 48 */
49 static int param_get_acpica_version(char *buffer, struct kernel_param *kp) 49 static int param_get_acpica_version(char *buffer, struct kernel_param *kp)
50 { 50 {
51 int result; 51 int result;
52 52
53 result = sprintf(buffer, "%x", ACPI_CA_VERSION); 53 result = sprintf(buffer, "%x", ACPI_CA_VERSION);
54 54
55 return result; 55 return result;
56 } 56 }
57 57
58 module_param_call(acpica_version, NULL, param_get_acpica_version, NULL, 0444); 58 module_param_call(acpica_version, NULL, param_get_acpica_version, NULL, 0444);
59 59
60 /* -------------------------------------------------------------------------- 60 /* --------------------------------------------------------------------------
61 FS Interface (/sys) 61 FS Interface (/sys)
62 -------------------------------------------------------------------------- */ 62 -------------------------------------------------------------------------- */
63 static LIST_HEAD(acpi_table_attr_list); 63 static LIST_HEAD(acpi_table_attr_list);
64 static struct kobject *tables_kobj; 64 static struct kobject *tables_kobj;
65 65
66 struct acpi_table_attr { 66 struct acpi_table_attr {
67 struct bin_attribute attr; 67 struct bin_attribute attr;
68 char name[8]; 68 char name[8];
69 int instance; 69 int instance;
70 struct list_head node; 70 struct list_head node;
71 }; 71 };
72 72
73 static ssize_t acpi_table_show(struct kobject *kobj, 73 static ssize_t acpi_table_show(struct kobject *kobj,
74 struct bin_attribute *bin_attr, char *buf, 74 struct bin_attribute *bin_attr, char *buf,
75 loff_t offset, size_t count) 75 loff_t offset, size_t count)
76 { 76 {
77 struct acpi_table_attr *table_attr = 77 struct acpi_table_attr *table_attr =
78 container_of(bin_attr, struct acpi_table_attr, attr); 78 container_of(bin_attr, struct acpi_table_attr, attr);
79 struct acpi_table_header *table_header = NULL; 79 struct acpi_table_header *table_header = NULL;
80 acpi_status status; 80 acpi_status status;
81 81
82 status = 82 status =
83 acpi_get_table(table_attr->name, table_attr->instance, 83 acpi_get_table(table_attr->name, table_attr->instance,
84 &table_header); 84 &table_header);
85 if (ACPI_FAILURE(status)) 85 if (ACPI_FAILURE(status))
86 return -ENODEV; 86 return -ENODEV;
87 87
88 return memory_read_from_buffer(buf, count, &offset, 88 return memory_read_from_buffer(buf, count, &offset,
89 table_header, table_header->length); 89 table_header, table_header->length);
90 } 90 }
91 91
92 static void acpi_table_attr_init(struct acpi_table_attr *table_attr, 92 static void acpi_table_attr_init(struct acpi_table_attr *table_attr,
93 struct acpi_table_header *table_header) 93 struct acpi_table_header *table_header)
94 { 94 {
95 struct acpi_table_header *header = NULL; 95 struct acpi_table_header *header = NULL;
96 struct acpi_table_attr *attr = NULL; 96 struct acpi_table_attr *attr = NULL;
97 97
98 memcpy(table_attr->name, table_header->signature, ACPI_NAME_SIZE); 98 memcpy(table_attr->name, table_header->signature, ACPI_NAME_SIZE);
99 99
100 list_for_each_entry(attr, &acpi_table_attr_list, node) { 100 list_for_each_entry(attr, &acpi_table_attr_list, node) {
101 if (!memcmp(table_header->signature, attr->name, 101 if (!memcmp(table_header->signature, attr->name,
102 ACPI_NAME_SIZE)) 102 ACPI_NAME_SIZE))
103 if (table_attr->instance < attr->instance) 103 if (table_attr->instance < attr->instance)
104 table_attr->instance = attr->instance; 104 table_attr->instance = attr->instance;
105 } 105 }
106 table_attr->instance++; 106 table_attr->instance++;
107 107
108 if (table_attr->instance > 1 || (table_attr->instance == 1 && 108 if (table_attr->instance > 1 || (table_attr->instance == 1 &&
109 !acpi_get_table(table_header-> 109 !acpi_get_table(table_header->
110 signature, 2, 110 signature, 2,
111 &header))) 111 &header)))
112 sprintf(table_attr->name + 4, "%d", table_attr->instance); 112 sprintf(table_attr->name + 4, "%d", table_attr->instance);
113 113
114 table_attr->attr.size = 0; 114 table_attr->attr.size = 0;
115 table_attr->attr.read = acpi_table_show; 115 table_attr->attr.read = acpi_table_show;
116 table_attr->attr.attr.name = table_attr->name; 116 table_attr->attr.attr.name = table_attr->name;
117 table_attr->attr.attr.mode = 0444; 117 table_attr->attr.attr.mode = 0444;
118 118
119 return; 119 return;
120 } 120 }
121 121
122 static int acpi_system_sysfs_init(void) 122 static int acpi_system_sysfs_init(void)
123 { 123 {
124 struct acpi_table_attr *table_attr; 124 struct acpi_table_attr *table_attr;
125 struct acpi_table_header *table_header = NULL; 125 struct acpi_table_header *table_header = NULL;
126 int table_index = 0; 126 int table_index = 0;
127 int result; 127 int result;
128 128
129 tables_kobj = kobject_create_and_add("tables", acpi_kobj); 129 tables_kobj = kobject_create_and_add("tables", acpi_kobj);
130 if (!tables_kobj) 130 if (!tables_kobj)
131 return -ENOMEM; 131 return -ENOMEM;
132 132
133 do { 133 do {
134 result = acpi_get_table_by_index(table_index, &table_header); 134 result = acpi_get_table_by_index(table_index, &table_header);
135 if (!result) { 135 if (!result) {
136 table_index++; 136 table_index++;
137 table_attr = NULL; 137 table_attr = NULL;
138 table_attr = 138 table_attr =
139 kzalloc(sizeof(struct acpi_table_attr), GFP_KERNEL); 139 kzalloc(sizeof(struct acpi_table_attr), GFP_KERNEL);
140 if (!table_attr) 140 if (!table_attr)
141 return -ENOMEM; 141 return -ENOMEM;
142 142
143 acpi_table_attr_init(table_attr, table_header); 143 acpi_table_attr_init(table_attr, table_header);
144 result = 144 result =
145 sysfs_create_bin_file(tables_kobj, 145 sysfs_create_bin_file(tables_kobj,
146 &table_attr->attr); 146 &table_attr->attr);
147 if (result) { 147 if (result) {
148 kfree(table_attr); 148 kfree(table_attr);
149 return result; 149 return result;
150 } else 150 } else
151 list_add_tail(&table_attr->node, 151 list_add_tail(&table_attr->node,
152 &acpi_table_attr_list); 152 &acpi_table_attr_list);
153 } 153 }
154 } while (!result); 154 } while (!result);
155 kobject_uevent(tables_kobj, KOBJ_ADD); 155 kobject_uevent(tables_kobj, KOBJ_ADD);
156 156
157 return 0; 157 return 0;
158 } 158 }
159 159
160 /* 160 /*
161 * Detailed ACPI IRQ counters in /sys/firmware/acpi/interrupts/ 161 * Detailed ACPI IRQ counters in /sys/firmware/acpi/interrupts/
162 * See Documentation/ABI/testing/sysfs-firmware-acpi 162 * See Documentation/ABI/testing/sysfs-firmware-acpi
163 */ 163 */
164 164
165 #define COUNT_GPE 0 165 #define COUNT_GPE 0
166 #define COUNT_SCI 1 /* acpi_irq_handled */ 166 #define COUNT_SCI 1 /* acpi_irq_handled */
167 #define COUNT_ERROR 2 /* other */ 167 #define COUNT_ERROR 2 /* other */
168 #define NUM_COUNTERS_EXTRA 3 168 #define NUM_COUNTERS_EXTRA 3
169 169
170 #define ACPI_EVENT_VALID 0x01
171 struct event_counter { 170 struct event_counter {
172 u32 count; 171 u32 count;
173 u32 flags; 172 u32 flags;
174 }; 173 };
175 174
176 static struct event_counter *all_counters; 175 static struct event_counter *all_counters;
177 static u32 num_gpes; 176 static u32 num_gpes;
178 static u32 num_counters; 177 static u32 num_counters;
179 static struct attribute **all_attrs; 178 static struct attribute **all_attrs;
180 static u32 acpi_gpe_count; 179 static u32 acpi_gpe_count;
181 180
182 static struct attribute_group interrupt_stats_attr_group = { 181 static struct attribute_group interrupt_stats_attr_group = {
183 .name = "interrupts", 182 .name = "interrupts",
184 }; 183 };
185 static struct kobj_attribute *counter_attrs; 184 static struct kobj_attribute *counter_attrs;
186 185
187 static int count_num_gpes(void) 186 static int count_num_gpes(void)
188 { 187 {
189 int count = 0; 188 int count = 0;
190 struct acpi_gpe_xrupt_info *gpe_xrupt_info; 189 struct acpi_gpe_xrupt_info *gpe_xrupt_info;
191 struct acpi_gpe_block_info *gpe_block; 190 struct acpi_gpe_block_info *gpe_block;
192 acpi_cpu_flags flags; 191 acpi_cpu_flags flags;
193 192
194 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock); 193 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
195 194
196 gpe_xrupt_info = acpi_gbl_gpe_xrupt_list_head; 195 gpe_xrupt_info = acpi_gbl_gpe_xrupt_list_head;
197 while (gpe_xrupt_info) { 196 while (gpe_xrupt_info) {
198 gpe_block = gpe_xrupt_info->gpe_block_list_head; 197 gpe_block = gpe_xrupt_info->gpe_block_list_head;
199 while (gpe_block) { 198 while (gpe_block) {
200 count += gpe_block->register_count * 199 count += gpe_block->register_count *
201 ACPI_GPE_REGISTER_WIDTH; 200 ACPI_GPE_REGISTER_WIDTH;
202 gpe_block = gpe_block->next; 201 gpe_block = gpe_block->next;
203 } 202 }
204 gpe_xrupt_info = gpe_xrupt_info->next; 203 gpe_xrupt_info = gpe_xrupt_info->next;
205 } 204 }
206 acpi_os_release_lock(acpi_gbl_gpe_lock, flags); 205 acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
207 206
208 return count; 207 return count;
209 } 208 }
210 209
211 static int get_gpe_device(int index, acpi_handle *handle) 210 static int get_gpe_device(int index, acpi_handle *handle)
212 { 211 {
213 struct acpi_gpe_xrupt_info *gpe_xrupt_info; 212 struct acpi_gpe_xrupt_info *gpe_xrupt_info;
214 struct acpi_gpe_block_info *gpe_block; 213 struct acpi_gpe_block_info *gpe_block;
215 acpi_cpu_flags flags; 214 acpi_cpu_flags flags;
216 struct acpi_namespace_node *node; 215 struct acpi_namespace_node *node;
217 216
218 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock); 217 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
219 218
220 gpe_xrupt_info = acpi_gbl_gpe_xrupt_list_head; 219 gpe_xrupt_info = acpi_gbl_gpe_xrupt_list_head;
221 while (gpe_xrupt_info) { 220 while (gpe_xrupt_info) {
222 gpe_block = gpe_xrupt_info->gpe_block_list_head; 221 gpe_block = gpe_xrupt_info->gpe_block_list_head;
223 node = gpe_block->node; 222 node = gpe_block->node;
224 while (gpe_block) { 223 while (gpe_block) {
225 index -= gpe_block->register_count * 224 index -= gpe_block->register_count *
226 ACPI_GPE_REGISTER_WIDTH; 225 ACPI_GPE_REGISTER_WIDTH;
227 if (index < 0) { 226 if (index < 0) {
228 acpi_os_release_lock(acpi_gbl_gpe_lock, flags); 227 acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
229 /* return NULL if it's FADT GPE */ 228 /* return NULL if it's FADT GPE */
230 if (node->type != ACPI_TYPE_DEVICE) 229 if (node->type != ACPI_TYPE_DEVICE)
231 *handle = NULL; 230 *handle = NULL;
232 else 231 else
233 *handle = node; 232 *handle = node;
234 return 0; 233 return 0;
235 } 234 }
236 node = gpe_block->node; 235 node = gpe_block->node;
237 gpe_block = gpe_block->next; 236 gpe_block = gpe_block->next;
238 } 237 }
239 gpe_xrupt_info = gpe_xrupt_info->next; 238 gpe_xrupt_info = gpe_xrupt_info->next;
240 } 239 }
241 acpi_os_release_lock(acpi_gbl_gpe_lock, flags); 240 acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
242 241
243 return -ENODEV; 242 return -ENODEV;
244 } 243 }
245 244
246 static void delete_gpe_attr_array(void) 245 static void delete_gpe_attr_array(void)
247 { 246 {
248 struct event_counter *tmp = all_counters; 247 struct event_counter *tmp = all_counters;
249 248
250 all_counters = NULL; 249 all_counters = NULL;
251 kfree(tmp); 250 kfree(tmp);
252 251
253 if (counter_attrs) { 252 if (counter_attrs) {
254 int i; 253 int i;
255 254
256 for (i = 0; i < num_gpes; i++) 255 for (i = 0; i < num_gpes; i++)
257 kfree(counter_attrs[i].attr.name); 256 kfree(counter_attrs[i].attr.name);
258 257
259 kfree(counter_attrs); 258 kfree(counter_attrs);
260 } 259 }
261 kfree(all_attrs); 260 kfree(all_attrs);
262 261
263 return; 262 return;
264 } 263 }
265 264
266 void acpi_os_gpe_count(u32 gpe_number) 265 void acpi_os_gpe_count(u32 gpe_number)
267 { 266 {
268 acpi_gpe_count++; 267 acpi_gpe_count++;
269 268
270 if (!all_counters) 269 if (!all_counters)
271 return; 270 return;
272 271
273 if (gpe_number < num_gpes) 272 if (gpe_number < num_gpes)
274 all_counters[gpe_number].count++; 273 all_counters[gpe_number].count++;
275 else 274 else
276 all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_ERROR]. 275 all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_ERROR].
277 count++; 276 count++;
278 277
279 return; 278 return;
280 } 279 }
281 280
282 void acpi_os_fixed_event_count(u32 event_number) 281 void acpi_os_fixed_event_count(u32 event_number)
283 { 282 {
284 if (!all_counters) 283 if (!all_counters)
285 return; 284 return;
286 285
287 if (event_number < ACPI_NUM_FIXED_EVENTS) 286 if (event_number < ACPI_NUM_FIXED_EVENTS)
288 all_counters[num_gpes + event_number].count++; 287 all_counters[num_gpes + event_number].count++;
289 else 288 else
290 all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_ERROR]. 289 all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_ERROR].
291 count++; 290 count++;
292 291
293 return; 292 return;
294 } 293 }
295 294
296 static int get_status(u32 index, acpi_event_status *status, acpi_handle *handle) 295 static int get_status(u32 index, acpi_event_status *status, acpi_handle *handle)
297 { 296 {
298 int result = 0; 297 int result = 0;
299 298
300 if (index >= num_gpes + ACPI_NUM_FIXED_EVENTS) 299 if (index >= num_gpes + ACPI_NUM_FIXED_EVENTS)
301 goto end; 300 goto end;
302 301
303 if (index < num_gpes) { 302 if (index < num_gpes) {
304 result = get_gpe_device(index, handle); 303 result = get_gpe_device(index, handle);
305 if (result) { 304 if (result) {
306 ACPI_EXCEPTION((AE_INFO, AE_NOT_FOUND, 305 ACPI_EXCEPTION((AE_INFO, AE_NOT_FOUND,
307 "Invalid GPE 0x%x\n", index)); 306 "Invalid GPE 0x%x\n", index));
308 goto end; 307 goto end;
309 } 308 }
310 result = acpi_get_gpe_status(*handle, index, 309 result = acpi_get_gpe_status(*handle, index,
311 ACPI_NOT_ISR, status); 310 ACPI_NOT_ISR, status);
312 } else if (index < (num_gpes + ACPI_NUM_FIXED_EVENTS)) 311 } else if (index < (num_gpes + ACPI_NUM_FIXED_EVENTS))
313 result = acpi_get_event_status(index - num_gpes, status); 312 result = acpi_get_event_status(index - num_gpes, status);
314 313
315 /*
316 * sleep/power button GPE/Fixed Event is enabled after acpi_system_init,
317 * check the status at runtime and mark it as valid once it's enabled
318 */
319 if (!result && (*status & ACPI_EVENT_FLAG_ENABLED))
320 all_counters[index].flags |= ACPI_EVENT_VALID;
321 end: 314 end:
322 return result; 315 return result;
323 } 316 }
324 317
325 static ssize_t counter_show(struct kobject *kobj, 318 static ssize_t counter_show(struct kobject *kobj,
326 struct kobj_attribute *attr, char *buf) 319 struct kobj_attribute *attr, char *buf)
327 { 320 {
328 int index = attr - counter_attrs; 321 int index = attr - counter_attrs;
329 int size; 322 int size;
330 acpi_handle handle; 323 acpi_handle handle;
331 acpi_event_status status; 324 acpi_event_status status;
332 int result = 0; 325 int result = 0;
333 326
334 all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_SCI].count = 327 all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_SCI].count =
335 acpi_irq_handled; 328 acpi_irq_handled;
336 all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_GPE].count = 329 all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_GPE].count =
337 acpi_gpe_count; 330 acpi_gpe_count;
338 331
339 size = sprintf(buf, "%8d", all_counters[index].count); 332 size = sprintf(buf, "%8d", all_counters[index].count);
340 333
341 /* "gpe_all" or "sci" */ 334 /* "gpe_all" or "sci" */
342 if (index >= num_gpes + ACPI_NUM_FIXED_EVENTS) 335 if (index >= num_gpes + ACPI_NUM_FIXED_EVENTS)
343 goto end; 336 goto end;
344 337
345 result = get_status(index, &status, &handle); 338 result = get_status(index, &status, &handle);
346 if (result) 339 if (result)
347 goto end; 340 goto end;
348 341
349 if (!(all_counters[index].flags & ACPI_EVENT_VALID)) 342 if (!(status & ACPI_EVENT_FLAG_HANDLE))
350 size += sprintf(buf + size, " invalid"); 343 size += sprintf(buf + size, " invalid");
351 else if (status & ACPI_EVENT_FLAG_ENABLED) 344 else if (status & ACPI_EVENT_FLAG_ENABLED)
352 size += sprintf(buf + size, " enable"); 345 size += sprintf(buf + size, " enabled");
346 else if (status & ACPI_EVENT_FLAG_WAKE_ENABLED)
347 size += sprintf(buf + size, " wake_enabled");
353 else 348 else
354 size += sprintf(buf + size, " disable"); 349 size += sprintf(buf + size, " disabled");
355 350
356 end: 351 end:
357 size += sprintf(buf + size, "\n"); 352 size += sprintf(buf + size, "\n");
358 return result ? result : size; 353 return result ? result : size;
359 } 354 }
360 355
361 /* 356 /*
362 * counter_set() sets the specified counter. 357 * counter_set() sets the specified counter.
363 * setting the total "sci" file to any value clears all counters. 358 * setting the total "sci" file to any value clears all counters.
364 * enable/disable/clear a gpe/fixed event in user space. 359 * enable/disable/clear a gpe/fixed event in user space.
365 */ 360 */
366 static ssize_t counter_set(struct kobject *kobj, 361 static ssize_t counter_set(struct kobject *kobj,
367 struct kobj_attribute *attr, const char *buf, size_t size) 362 struct kobj_attribute *attr, const char *buf, size_t size)
368 { 363 {
369 int index = attr - counter_attrs; 364 int index = attr - counter_attrs;
370 acpi_event_status status; 365 acpi_event_status status;
371 acpi_handle handle; 366 acpi_handle handle;
372 int result = 0; 367 int result = 0;
373 368
374 if (index == num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_SCI) { 369 if (index == num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_SCI) {
375 int i; 370 int i;
376 for (i = 0; i < num_counters; ++i) 371 for (i = 0; i < num_counters; ++i)
377 all_counters[i].count = 0; 372 all_counters[i].count = 0;
378 acpi_gpe_count = 0; 373 acpi_gpe_count = 0;
379 acpi_irq_handled = 0; 374 acpi_irq_handled = 0;
380 goto end; 375 goto end;
381 } 376 }
382 377
383 /* show the event status for both GPEs and Fixed Events */ 378 /* show the event status for both GPEs and Fixed Events */
384 result = get_status(index, &status, &handle); 379 result = get_status(index, &status, &handle);
385 if (result) 380 if (result)
386 goto end; 381 goto end;
387 382
388 if (!(all_counters[index].flags & ACPI_EVENT_VALID)) { 383 if (!(status & ACPI_EVENT_FLAG_HANDLE)) {
389 printk(KERN_WARNING PREFIX 384 printk(KERN_WARNING PREFIX
390 "Can not change Invalid GPE/Fixed Event status\n"); 385 "Can not change Invalid GPE/Fixed Event status\n");
391 return -EINVAL; 386 return -EINVAL;
392 } 387 }
393 388
394 if (index < num_gpes) { 389 if (index < num_gpes) {
395 if (!strcmp(buf, "disable\n") && 390 if (!strcmp(buf, "disable\n") &&
396 (status & ACPI_EVENT_FLAG_ENABLED)) 391 (status & ACPI_EVENT_FLAG_ENABLED))
397 result = acpi_disable_gpe(handle, index, ACPI_NOT_ISR); 392 result = acpi_disable_gpe(handle, index, ACPI_NOT_ISR);
398 else if (!strcmp(buf, "enable\n") && 393 else if (!strcmp(buf, "enable\n") &&
399 !(status & ACPI_EVENT_FLAG_ENABLED)) 394 !(status & ACPI_EVENT_FLAG_ENABLED))
400 result = acpi_enable_gpe(handle, index, ACPI_NOT_ISR); 395 result = acpi_enable_gpe(handle, index, ACPI_NOT_ISR);
401 else if (!strcmp(buf, "clear\n") && 396 else if (!strcmp(buf, "clear\n") &&
402 (status & ACPI_EVENT_FLAG_SET)) 397 (status & ACPI_EVENT_FLAG_SET))
403 result = acpi_clear_gpe(handle, index, ACPI_NOT_ISR); 398 result = acpi_clear_gpe(handle, index, ACPI_NOT_ISR);
404 else 399 else
405 all_counters[index].count = strtoul(buf, NULL, 0); 400 all_counters[index].count = strtoul(buf, NULL, 0);
406 } else if (index < num_gpes + ACPI_NUM_FIXED_EVENTS) { 401 } else if (index < num_gpes + ACPI_NUM_FIXED_EVENTS) {
407 int event = index - num_gpes; 402 int event = index - num_gpes;
408 if (!strcmp(buf, "disable\n") && 403 if (!strcmp(buf, "disable\n") &&
409 (status & ACPI_EVENT_FLAG_ENABLED)) 404 (status & ACPI_EVENT_FLAG_ENABLED))
410 result = acpi_disable_event(event, ACPI_NOT_ISR); 405 result = acpi_disable_event(event, ACPI_NOT_ISR);
411 else if (!strcmp(buf, "enable\n") && 406 else if (!strcmp(buf, "enable\n") &&
412 !(status & ACPI_EVENT_FLAG_ENABLED)) 407 !(status & ACPI_EVENT_FLAG_ENABLED))
413 result = acpi_enable_event(event, ACPI_NOT_ISR); 408 result = acpi_enable_event(event, ACPI_NOT_ISR);
414 else if (!strcmp(buf, "clear\n") && 409 else if (!strcmp(buf, "clear\n") &&
415 (status & ACPI_EVENT_FLAG_SET)) 410 (status & ACPI_EVENT_FLAG_SET))
416 result = acpi_clear_event(event); 411 result = acpi_clear_event(event);
417 else 412 else
418 all_counters[index].count = strtoul(buf, NULL, 0); 413 all_counters[index].count = strtoul(buf, NULL, 0);
419 } else 414 } else
420 all_counters[index].count = strtoul(buf, NULL, 0); 415 all_counters[index].count = strtoul(buf, NULL, 0);
421 416
422 if (ACPI_FAILURE(result)) 417 if (ACPI_FAILURE(result))
423 result = -EINVAL; 418 result = -EINVAL;
424 end: 419 end:
425 return result ? result : size; 420 return result ? result : size;
426 } 421 }
427 422
428 void acpi_irq_stats_init(void) 423 void acpi_irq_stats_init(void)
429 { 424 {
430 int i; 425 int i;
431 426
432 if (all_counters) 427 if (all_counters)
433 return; 428 return;
434 429
435 num_gpes = count_num_gpes(); 430 num_gpes = count_num_gpes();
436 num_counters = num_gpes + ACPI_NUM_FIXED_EVENTS + NUM_COUNTERS_EXTRA; 431 num_counters = num_gpes + ACPI_NUM_FIXED_EVENTS + NUM_COUNTERS_EXTRA;
437 432
438 all_attrs = kzalloc(sizeof(struct attribute *) * (num_counters + 1), 433 all_attrs = kzalloc(sizeof(struct attribute *) * (num_counters + 1),
439 GFP_KERNEL); 434 GFP_KERNEL);
440 if (all_attrs == NULL) 435 if (all_attrs == NULL)
441 return; 436 return;
442 437
443 all_counters = kzalloc(sizeof(struct event_counter) * (num_counters), 438 all_counters = kzalloc(sizeof(struct event_counter) * (num_counters),
444 GFP_KERNEL); 439 GFP_KERNEL);
445 if (all_counters == NULL) 440 if (all_counters == NULL)
446 goto fail; 441 goto fail;
447 442
448 counter_attrs = kzalloc(sizeof(struct kobj_attribute) * (num_counters), 443 counter_attrs = kzalloc(sizeof(struct kobj_attribute) * (num_counters),
449 GFP_KERNEL); 444 GFP_KERNEL);
450 if (counter_attrs == NULL) 445 if (counter_attrs == NULL)
451 goto fail; 446 goto fail;
452 447
453 for (i = 0; i < num_counters; ++i) { 448 for (i = 0; i < num_counters; ++i) {
454 char buffer[12]; 449 char buffer[12];
455 char *name; 450 char *name;
456 451
457 if (i < num_gpes) 452 if (i < num_gpes)
458 sprintf(buffer, "gpe%02X", i); 453 sprintf(buffer, "gpe%02X", i);
459 else if (i == num_gpes + ACPI_EVENT_PMTIMER) 454 else if (i == num_gpes + ACPI_EVENT_PMTIMER)
460 sprintf(buffer, "ff_pmtimer"); 455 sprintf(buffer, "ff_pmtimer");
461 else if (i == num_gpes + ACPI_EVENT_GLOBAL) 456 else if (i == num_gpes + ACPI_EVENT_GLOBAL)
462 sprintf(buffer, "ff_gbl_lock"); 457 sprintf(buffer, "ff_gbl_lock");
463 else if (i == num_gpes + ACPI_EVENT_POWER_BUTTON) 458 else if (i == num_gpes + ACPI_EVENT_POWER_BUTTON)
464 sprintf(buffer, "ff_pwr_btn"); 459 sprintf(buffer, "ff_pwr_btn");
465 else if (i == num_gpes + ACPI_EVENT_SLEEP_BUTTON) 460 else if (i == num_gpes + ACPI_EVENT_SLEEP_BUTTON)
466 sprintf(buffer, "ff_slp_btn"); 461 sprintf(buffer, "ff_slp_btn");
467 else if (i == num_gpes + ACPI_EVENT_RTC) 462 else if (i == num_gpes + ACPI_EVENT_RTC)
468 sprintf(buffer, "ff_rt_clk"); 463 sprintf(buffer, "ff_rt_clk");
469 else if (i == num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_GPE) 464 else if (i == num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_GPE)
470 sprintf(buffer, "gpe_all"); 465 sprintf(buffer, "gpe_all");
471 else if (i == num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_SCI) 466 else if (i == num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_SCI)
472 sprintf(buffer, "sci"); 467 sprintf(buffer, "sci");
473 else if (i == num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_ERROR) 468 else if (i == num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_ERROR)
474 sprintf(buffer, "error"); 469 sprintf(buffer, "error");
475 else 470 else
476 sprintf(buffer, "bug%02X", i); 471 sprintf(buffer, "bug%02X", i);
477 472
478 name = kzalloc(strlen(buffer) + 1, GFP_KERNEL); 473 name = kzalloc(strlen(buffer) + 1, GFP_KERNEL);
479 if (name == NULL) 474 if (name == NULL)
480 goto fail; 475 goto fail;
481 strncpy(name, buffer, strlen(buffer) + 1); 476 strncpy(name, buffer, strlen(buffer) + 1);
482 477
483 counter_attrs[i].attr.name = name; 478 counter_attrs[i].attr.name = name;
484 counter_attrs[i].attr.mode = 0644; 479 counter_attrs[i].attr.mode = 0644;
485 counter_attrs[i].show = counter_show; 480 counter_attrs[i].show = counter_show;
486 counter_attrs[i].store = counter_set; 481 counter_attrs[i].store = counter_set;
487 482
488 all_attrs[i] = &counter_attrs[i].attr; 483 all_attrs[i] = &counter_attrs[i].attr;
489 } 484 }
490 485
491 interrupt_stats_attr_group.attrs = all_attrs; 486 interrupt_stats_attr_group.attrs = all_attrs;
492 if (!sysfs_create_group(acpi_kobj, &interrupt_stats_attr_group)) 487 if (!sysfs_create_group(acpi_kobj, &interrupt_stats_attr_group))
493 return; 488 return;
494 489
495 fail: 490 fail:
496 delete_gpe_attr_array(); 491 delete_gpe_attr_array();
497 return; 492 return;
498 } 493 }
499 494
500 static void __exit interrupt_stats_exit(void) 495 static void __exit interrupt_stats_exit(void)
501 { 496 {
502 sysfs_remove_group(acpi_kobj, &interrupt_stats_attr_group); 497 sysfs_remove_group(acpi_kobj, &interrupt_stats_attr_group);
503 498
504 delete_gpe_attr_array(); 499 delete_gpe_attr_array();
505 500
506 return; 501 return;
507 } 502 }
508 503
509 /* -------------------------------------------------------------------------- 504 /* --------------------------------------------------------------------------
510 FS Interface (/proc) 505 FS Interface (/proc)
511 -------------------------------------------------------------------------- */ 506 -------------------------------------------------------------------------- */
512 #ifdef CONFIG_ACPI_PROCFS 507 #ifdef CONFIG_ACPI_PROCFS
513 #define ACPI_SYSTEM_FILE_INFO "info" 508 #define ACPI_SYSTEM_FILE_INFO "info"
514 #define ACPI_SYSTEM_FILE_EVENT "event" 509 #define ACPI_SYSTEM_FILE_EVENT "event"
515 #define ACPI_SYSTEM_FILE_DSDT "dsdt" 510 #define ACPI_SYSTEM_FILE_DSDT "dsdt"
516 #define ACPI_SYSTEM_FILE_FADT "fadt" 511 #define ACPI_SYSTEM_FILE_FADT "fadt"
517 512
518 static int acpi_system_read_info(struct seq_file *seq, void *offset) 513 static int acpi_system_read_info(struct seq_file *seq, void *offset)
519 { 514 {
520 515
521 seq_printf(seq, "version: %x\n", ACPI_CA_VERSION); 516 seq_printf(seq, "version: %x\n", ACPI_CA_VERSION);
522 return 0; 517 return 0;
523 } 518 }
524 519
525 static int acpi_system_info_open_fs(struct inode *inode, struct file *file) 520 static int acpi_system_info_open_fs(struct inode *inode, struct file *file)
526 { 521 {
527 return single_open(file, acpi_system_read_info, PDE(inode)->data); 522 return single_open(file, acpi_system_read_info, PDE(inode)->data);
528 } 523 }
529 524
530 static const struct file_operations acpi_system_info_ops = { 525 static const struct file_operations acpi_system_info_ops = {
531 .owner = THIS_MODULE, 526 .owner = THIS_MODULE,
532 .open = acpi_system_info_open_fs, 527 .open = acpi_system_info_open_fs,
533 .read = seq_read, 528 .read = seq_read,
534 .llseek = seq_lseek, 529 .llseek = seq_lseek,
535 .release = single_release, 530 .release = single_release,
536 }; 531 };
537 532
538 static ssize_t acpi_system_read_dsdt(struct file *, char __user *, size_t, 533 static ssize_t acpi_system_read_dsdt(struct file *, char __user *, size_t,
539 loff_t *); 534 loff_t *);
540 535
541 static const struct file_operations acpi_system_dsdt_ops = { 536 static const struct file_operations acpi_system_dsdt_ops = {
542 .owner = THIS_MODULE, 537 .owner = THIS_MODULE,
543 .read = acpi_system_read_dsdt, 538 .read = acpi_system_read_dsdt,
544 }; 539 };
545 540
546 static ssize_t 541 static ssize_t
547 acpi_system_read_dsdt(struct file *file, 542 acpi_system_read_dsdt(struct file *file,
548 char __user * buffer, size_t count, loff_t * ppos) 543 char __user * buffer, size_t count, loff_t * ppos)
549 { 544 {
550 acpi_status status = AE_OK; 545 acpi_status status = AE_OK;
551 struct acpi_table_header *dsdt = NULL; 546 struct acpi_table_header *dsdt = NULL;
552 ssize_t res; 547 ssize_t res;
553 548
554 status = acpi_get_table(ACPI_SIG_DSDT, 1, &dsdt); 549 status = acpi_get_table(ACPI_SIG_DSDT, 1, &dsdt);
555 if (ACPI_FAILURE(status)) 550 if (ACPI_FAILURE(status))
556 return -ENODEV; 551 return -ENODEV;
557 552
558 res = simple_read_from_buffer(buffer, count, ppos, dsdt, dsdt->length); 553 res = simple_read_from_buffer(buffer, count, ppos, dsdt, dsdt->length);
559 554
560 return res; 555 return res;
561 } 556 }
562 557
563 static ssize_t acpi_system_read_fadt(struct file *, char __user *, size_t, 558 static ssize_t acpi_system_read_fadt(struct file *, char __user *, size_t,
564 loff_t *); 559 loff_t *);
565 560
566 static const struct file_operations acpi_system_fadt_ops = { 561 static const struct file_operations acpi_system_fadt_ops = {
567 .owner = THIS_MODULE, 562 .owner = THIS_MODULE,
568 .read = acpi_system_read_fadt, 563 .read = acpi_system_read_fadt,
569 }; 564 };
570 565
571 static ssize_t 566 static ssize_t
572 acpi_system_read_fadt(struct file *file, 567 acpi_system_read_fadt(struct file *file,
573 char __user * buffer, size_t count, loff_t * ppos) 568 char __user * buffer, size_t count, loff_t * ppos)
574 { 569 {
575 acpi_status status = AE_OK; 570 acpi_status status = AE_OK;
576 struct acpi_table_header *fadt = NULL; 571 struct acpi_table_header *fadt = NULL;
577 ssize_t res; 572 ssize_t res;
578 573
579 status = acpi_get_table(ACPI_SIG_FADT, 1, &fadt); 574 status = acpi_get_table(ACPI_SIG_FADT, 1, &fadt);
580 if (ACPI_FAILURE(status)) 575 if (ACPI_FAILURE(status))
581 return -ENODEV; 576 return -ENODEV;
582 577
583 res = simple_read_from_buffer(buffer, count, ppos, fadt, fadt->length); 578 res = simple_read_from_buffer(buffer, count, ppos, fadt, fadt->length);
584 579
585 return res; 580 return res;
586 } 581 }
587 582
588 static int acpi_system_procfs_init(void) 583 static int acpi_system_procfs_init(void)
589 { 584 {
590 struct proc_dir_entry *entry; 585 struct proc_dir_entry *entry;
591 int error = 0; 586 int error = 0;
592 587
593 /* 'info' [R] */ 588 /* 'info' [R] */
594 entry = proc_create(ACPI_SYSTEM_FILE_INFO, S_IRUGO, acpi_root_dir, 589 entry = proc_create(ACPI_SYSTEM_FILE_INFO, S_IRUGO, acpi_root_dir,
595 &acpi_system_info_ops); 590 &acpi_system_info_ops);
596 if (!entry) 591 if (!entry)
597 goto Error; 592 goto Error;
598 593
599 /* 'dsdt' [R] */ 594 /* 'dsdt' [R] */
600 entry = proc_create(ACPI_SYSTEM_FILE_DSDT, S_IRUSR, acpi_root_dir, 595 entry = proc_create(ACPI_SYSTEM_FILE_DSDT, S_IRUSR, acpi_root_dir,
601 &acpi_system_dsdt_ops); 596 &acpi_system_dsdt_ops);
602 if (!entry) 597 if (!entry)
603 goto Error; 598 goto Error;
604 599
605 /* 'fadt' [R] */ 600 /* 'fadt' [R] */
606 entry = proc_create(ACPI_SYSTEM_FILE_FADT, S_IRUSR, acpi_root_dir, 601 entry = proc_create(ACPI_SYSTEM_FILE_FADT, S_IRUSR, acpi_root_dir,
607 &acpi_system_fadt_ops); 602 &acpi_system_fadt_ops);
608 if (!entry) 603 if (!entry)
609 goto Error; 604 goto Error;
610 605
611 Done: 606 Done:
612 return error; 607 return error;
613 608
614 Error: 609 Error:
615 remove_proc_entry(ACPI_SYSTEM_FILE_FADT, acpi_root_dir); 610 remove_proc_entry(ACPI_SYSTEM_FILE_FADT, acpi_root_dir);
616 remove_proc_entry(ACPI_SYSTEM_FILE_DSDT, acpi_root_dir); 611 remove_proc_entry(ACPI_SYSTEM_FILE_DSDT, acpi_root_dir);
617 remove_proc_entry(ACPI_SYSTEM_FILE_INFO, acpi_root_dir); 612 remove_proc_entry(ACPI_SYSTEM_FILE_INFO, acpi_root_dir);
618 613
619 error = -EFAULT; 614 error = -EFAULT;
620 goto Done; 615 goto Done;
621 } 616 }
622 #else 617 #else
623 static int acpi_system_procfs_init(void) 618 static int acpi_system_procfs_init(void)
624 { 619 {
625 return 0; 620 return 0;
626 } 621 }
627 #endif 622 #endif
628 623
629 static int __init acpi_system_init(void) 624 static int __init acpi_system_init(void)
630 { 625 {
631 int result = 0; 626 int result = 0;
632 627
633 if (acpi_disabled) 628 if (acpi_disabled)
634 return 0; 629 return 0;
635 630
636 result = acpi_system_procfs_init(); 631 result = acpi_system_procfs_init();
637 if (result) 632 if (result)
638 return result; 633 return result;
639 634
640 result = acpi_system_sysfs_init(); 635 result = acpi_system_sysfs_init();
641 636
642 return result; 637 return result;
643 } 638 }
644 639
include/acpi/actypes.h
Diff comments   View file @ ed206fa
1 /****************************************************************************** 1 /******************************************************************************
2 * 2 *
3 * Name: actypes.h - Common data types for the entire ACPI subsystem 3 * Name: actypes.h - Common data types for the entire ACPI subsystem
4 * 4 *
5 *****************************************************************************/ 5 *****************************************************************************/
6 6
7 /* 7 /*
8 * Copyright (C) 2000 - 2008, Intel Corp. 8 * Copyright (C) 2000 - 2008, Intel Corp.
9 * All rights reserved. 9 * All rights reserved.
10 * 10 *
11 * Redistribution and use in source and binary forms, with or without 11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions 12 * modification, are permitted provided that the following conditions
13 * are met: 13 * are met:
14 * 1. Redistributions of source code must retain the above copyright 14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions, and the following disclaimer, 15 * notice, this list of conditions, and the following disclaimer,
16 * without modification. 16 * without modification.
17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18 * substantially similar to the "NO WARRANTY" disclaimer below 18 * substantially similar to the "NO WARRANTY" disclaimer below
19 * ("Disclaimer") and any redistribution must be conditioned upon 19 * ("Disclaimer") and any redistribution must be conditioned upon
20 * including a substantially similar Disclaimer requirement for further 20 * including a substantially similar Disclaimer requirement for further
21 * binary redistribution. 21 * binary redistribution.
22 * 3. Neither the names of the above-listed copyright holders nor the names 22 * 3. Neither the names of the above-listed copyright holders nor the names
23 * of any contributors may be used to endorse or promote products derived 23 * of any contributors may be used to endorse or promote products derived
24 * from this software without specific prior written permission. 24 * from this software without specific prior written permission.
25 * 25 *
26 * Alternatively, this software may be distributed under the terms of the 26 * Alternatively, this software may be distributed under the terms of the
27 * GNU General Public License ("GPL") version 2 as published by the Free 27 * GNU General Public License ("GPL") version 2 as published by the Free
28 * Software Foundation. 28 * Software Foundation.
29 * 29 *
30 * NO WARRANTY 30 * NO WARRANTY
31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR 33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41 * POSSIBILITY OF SUCH DAMAGES. 41 * POSSIBILITY OF SUCH DAMAGES.
42 */ 42 */
43 43
44 #ifndef __ACTYPES_H__ 44 #ifndef __ACTYPES_H__
45 #define __ACTYPES_H__ 45 #define __ACTYPES_H__
46 46
47 /* acpisrc:struct_defs -- for acpisrc conversion */ 47 /* acpisrc:struct_defs -- for acpisrc conversion */
48 48
49 /* 49 /*
50 * ACPI_MACHINE_WIDTH must be specified in an OS- or compiler-dependent header 50 * ACPI_MACHINE_WIDTH must be specified in an OS- or compiler-dependent header
51 * and must be either 32 or 64. 16-bit ACPICA is no longer supported, as of 51 * and must be either 32 or 64. 16-bit ACPICA is no longer supported, as of
52 * 12/2006. 52 * 12/2006.
53 */ 53 */
54 #ifndef ACPI_MACHINE_WIDTH 54 #ifndef ACPI_MACHINE_WIDTH
55 #error ACPI_MACHINE_WIDTH not defined 55 #error ACPI_MACHINE_WIDTH not defined
56 #endif 56 #endif
57 57
58 /*! [Begin] no source code translation */ 58 /*! [Begin] no source code translation */
59 59
60 /* 60 /*
61 * Data type ranges 61 * Data type ranges
62 * Note: These macros are designed to be compiler independent as well as 62 * Note: These macros are designed to be compiler independent as well as
63 * working around problems that some 32-bit compilers have with 64-bit 63 * working around problems that some 32-bit compilers have with 64-bit
64 * constants. 64 * constants.
65 */ 65 */
66 #define ACPI_UINT8_MAX (UINT8) (~((UINT8) 0)) /* 0xFF */ 66 #define ACPI_UINT8_MAX (UINT8) (~((UINT8) 0)) /* 0xFF */
67 #define ACPI_UINT16_MAX (UINT16)(~((UINT16) 0)) /* 0xFFFF */ 67 #define ACPI_UINT16_MAX (UINT16)(~((UINT16) 0)) /* 0xFFFF */
68 #define ACPI_UINT32_MAX (UINT32)(~((UINT32) 0)) /* 0xFFFFFFFF */ 68 #define ACPI_UINT32_MAX (UINT32)(~((UINT32) 0)) /* 0xFFFFFFFF */
69 #define ACPI_UINT64_MAX (UINT64)(~((UINT64) 0)) /* 0xFFFFFFFFFFFFFFFF */ 69 #define ACPI_UINT64_MAX (UINT64)(~((UINT64) 0)) /* 0xFFFFFFFFFFFFFFFF */
70 #define ACPI_ASCII_MAX 0x7F 70 #define ACPI_ASCII_MAX 0x7F
71 71
72 /* 72 /*
73 * Architecture-specific ACPICA Subsystem Data Types 73 * Architecture-specific ACPICA Subsystem Data Types
74 * 74 *
75 * The goal of these types is to provide source code portability across 75 * The goal of these types is to provide source code portability across
76 * 16-bit, 32-bit, and 64-bit targets. 76 * 16-bit, 32-bit, and 64-bit targets.
77 * 77 *
78 * 1) The following types are of fixed size for all targets (16/32/64): 78 * 1) The following types are of fixed size for all targets (16/32/64):
79 * 79 *
80 * BOOLEAN Logical boolean 80 * BOOLEAN Logical boolean
81 * 81 *
82 * UINT8 8-bit (1 byte) unsigned value 82 * UINT8 8-bit (1 byte) unsigned value
83 * UINT16 16-bit (2 byte) unsigned value 83 * UINT16 16-bit (2 byte) unsigned value
84 * UINT32 32-bit (4 byte) unsigned value 84 * UINT32 32-bit (4 byte) unsigned value
85 * UINT64 64-bit (8 byte) unsigned value 85 * UINT64 64-bit (8 byte) unsigned value
86 * 86 *
87 * INT16 16-bit (2 byte) signed value 87 * INT16 16-bit (2 byte) signed value
88 * INT32 32-bit (4 byte) signed value 88 * INT32 32-bit (4 byte) signed value
89 * INT64 64-bit (8 byte) signed value 89 * INT64 64-bit (8 byte) signed value
90 * 90 *
91 * COMPILER_DEPENDENT_UINT64/INT64 - These types are defined in the 91 * COMPILER_DEPENDENT_UINT64/INT64 - These types are defined in the
92 * compiler-dependent header(s) and were introduced because there is no common 92 * compiler-dependent header(s) and were introduced because there is no common
93 * 64-bit integer type across the various compilation models, as shown in 93 * 64-bit integer type across the various compilation models, as shown in
94 * the table below. 94 * the table below.
95 * 95 *
96 * Datatype LP64 ILP64 LLP64 ILP32 LP32 16bit 96 * Datatype LP64 ILP64 LLP64 ILP32 LP32 16bit
97 * char 8 8 8 8 8 8 97 * char 8 8 8 8 8 8
98 * short 16 16 16 16 16 16 98 * short 16 16 16 16 16 16
99 * _int32 32 99 * _int32 32
100 * int 32 64 32 32 16 16 100 * int 32 64 32 32 16 16
101 * long 64 64 32 32 32 32 101 * long 64 64 32 32 32 32
102 * long long 64 64 102 * long long 64 64
103 * pointer 64 64 64 32 32 32 103 * pointer 64 64 64 32 32 32
104 * 104 *
105 * Note: ILP64 and LP32 are currently not supported. 105 * Note: ILP64 and LP32 are currently not supported.
106 * 106 *
107 * 107 *
108 * 2) These types represent the native word size of the target mode of the 108 * 2) These types represent the native word size of the target mode of the
109 * processor, and may be 16-bit, 32-bit, or 64-bit as required. They are 109 * processor, and may be 16-bit, 32-bit, or 64-bit as required. They are
110 * usually used for memory allocation, efficient loop counters, and array 110 * usually used for memory allocation, efficient loop counters, and array
111 * indexes. The types are similar to the size_t type in the C library and are 111 * indexes. The types are similar to the size_t type in the C library and are
112 * required because there is no C type that consistently represents the native 112 * required because there is no C type that consistently represents the native
113 * data width. ACPI_SIZE is needed because there is no guarantee that a 113 * data width. ACPI_SIZE is needed because there is no guarantee that a
114 * kernel-level C library is present. 114 * kernel-level C library is present.
115 * 115 *
116 * ACPI_SIZE 16/32/64-bit unsigned value 116 * ACPI_SIZE 16/32/64-bit unsigned value
117 * ACPI_NATIVE_INT 16/32/64-bit signed value 117 * ACPI_NATIVE_INT 16/32/64-bit signed value
118 * 118 *
119 */ 119 */
120 120
121 /******************************************************************************* 121 /*******************************************************************************
122 * 122 *
123 * Common types for all compilers, all targets 123 * Common types for all compilers, all targets
124 * 124 *
125 ******************************************************************************/ 125 ******************************************************************************/
126 126
127 typedef unsigned char BOOLEAN; 127 typedef unsigned char BOOLEAN;
128 typedef unsigned char UINT8; 128 typedef unsigned char UINT8;
129 typedef unsigned short UINT16; 129 typedef unsigned short UINT16;
130 typedef COMPILER_DEPENDENT_UINT64 UINT64; 130 typedef COMPILER_DEPENDENT_UINT64 UINT64;
131 typedef COMPILER_DEPENDENT_INT64 INT64; 131 typedef COMPILER_DEPENDENT_INT64 INT64;
132 132
133 /*! [End] no source code translation !*/ 133 /*! [End] no source code translation !*/
134 134
135 /******************************************************************************* 135 /*******************************************************************************
136 * 136 *
137 * Types specific to 64-bit targets 137 * Types specific to 64-bit targets
138 * 138 *
139 ******************************************************************************/ 139 ******************************************************************************/
140 140
141 #if ACPI_MACHINE_WIDTH == 64 141 #if ACPI_MACHINE_WIDTH == 64
142 142
143 /*! [Begin] no source code translation (keep the typedefs as-is) */ 143 /*! [Begin] no source code translation (keep the typedefs as-is) */
144 144
145 typedef unsigned int UINT32; 145 typedef unsigned int UINT32;
146 typedef int INT32; 146 typedef int INT32;
147 147
148 /*! [End] no source code translation !*/ 148 /*! [End] no source code translation !*/
149 149
150 typedef s64 acpi_native_int; 150 typedef s64 acpi_native_int;
151 151
152 typedef u64 acpi_size; 152 typedef u64 acpi_size;
153 typedef u64 acpi_io_address; 153 typedef u64 acpi_io_address;
154 typedef u64 acpi_physical_address; 154 typedef u64 acpi_physical_address;
155 155
156 #define ACPI_MAX_PTR ACPI_UINT64_MAX 156 #define ACPI_MAX_PTR ACPI_UINT64_MAX
157 #define ACPI_SIZE_MAX ACPI_UINT64_MAX 157 #define ACPI_SIZE_MAX ACPI_UINT64_MAX
158 158
159 #define ACPI_USE_NATIVE_DIVIDE /* Has native 64-bit integer support */ 159 #define ACPI_USE_NATIVE_DIVIDE /* Has native 64-bit integer support */
160 160
161 /* 161 /*
162 * In the case of the Itanium Processor Family (IPF), the hardware does not 162 * In the case of the Itanium Processor Family (IPF), the hardware does not
163 * support misaligned memory transfers. Set the MISALIGNMENT_NOT_SUPPORTED flag 163 * support misaligned memory transfers. Set the MISALIGNMENT_NOT_SUPPORTED flag
164 * to indicate that special precautions must be taken to avoid alignment faults. 164 * to indicate that special precautions must be taken to avoid alignment faults.
165 * (IA64 or ia64 is currently used by existing compilers to indicate IPF.) 165 * (IA64 or ia64 is currently used by existing compilers to indicate IPF.)
166 * 166 *
167 * Note: Em64_t and other X86-64 processors support misaligned transfers, 167 * Note: Em64_t and other X86-64 processors support misaligned transfers,
168 * so there is no need to define this flag. 168 * so there is no need to define this flag.
169 */ 169 */
170 #if defined (__IA64__) || defined (__ia64__) 170 #if defined (__IA64__) || defined (__ia64__)
171 #define ACPI_MISALIGNMENT_NOT_SUPPORTED 171 #define ACPI_MISALIGNMENT_NOT_SUPPORTED
172 #endif 172 #endif
173 173
174 /******************************************************************************* 174 /*******************************************************************************
175 * 175 *
176 * Types specific to 32-bit targets 176 * Types specific to 32-bit targets
177 * 177 *
178 ******************************************************************************/ 178 ******************************************************************************/
179 179
180 #elif ACPI_MACHINE_WIDTH == 32 180 #elif ACPI_MACHINE_WIDTH == 32
181 181
182 /*! [Begin] no source code translation (keep the typedefs as-is) */ 182 /*! [Begin] no source code translation (keep the typedefs as-is) */
183 183
184 typedef unsigned int UINT32; 184 typedef unsigned int UINT32;
185 typedef int INT32; 185 typedef int INT32;
186 186
187 /*! [End] no source code translation !*/ 187 /*! [End] no source code translation !*/
188 188
189 typedef s32 acpi_native_int; 189 typedef s32 acpi_native_int;
190 190
191 typedef u32 acpi_size; 191 typedef u32 acpi_size;
192 typedef u32 acpi_io_address; 192 typedef u32 acpi_io_address;
193 typedef u32 acpi_physical_address; 193 typedef u32 acpi_physical_address;
194 194
195 #define ACPI_MAX_PTR ACPI_UINT32_MAX 195 #define ACPI_MAX_PTR ACPI_UINT32_MAX
196 #define ACPI_SIZE_MAX ACPI_UINT32_MAX 196 #define ACPI_SIZE_MAX ACPI_UINT32_MAX
197 197
198 #else 198 #else
199 199
200 /* ACPI_MACHINE_WIDTH must be either 64 or 32 */ 200 /* ACPI_MACHINE_WIDTH must be either 64 or 32 */
201 201
202 #error unknown ACPI_MACHINE_WIDTH 202 #error unknown ACPI_MACHINE_WIDTH
203 #endif 203 #endif
204 204
205 /******************************************************************************* 205 /*******************************************************************************
206 * 206 *
207 * OS-dependent and compiler-dependent types 207 * OS-dependent and compiler-dependent types
208 * 208 *
209 * If the defaults below are not appropriate for the host system, they can 209 * If the defaults below are not appropriate for the host system, they can
210 * be defined in the compiler-specific or OS-specific header, and this will 210 * be defined in the compiler-specific or OS-specific header, and this will
211 * take precedence. 211 * take precedence.
212 * 212 *
213 ******************************************************************************/ 213 ******************************************************************************/
214 214
215 /* Value returned by acpi_os_get_thread_id */ 215 /* Value returned by acpi_os_get_thread_id */
216 216
217 #ifndef acpi_thread_id 217 #ifndef acpi_thread_id
218 #define acpi_thread_id acpi_size 218 #define acpi_thread_id acpi_size
219 #endif 219 #endif
220 220
221 /* Object returned from acpi_os_create_lock */ 221 /* Object returned from acpi_os_create_lock */
222 222
223 #ifndef acpi_spinlock 223 #ifndef acpi_spinlock
224 #define acpi_spinlock void * 224 #define acpi_spinlock void *
225 #endif 225 #endif
226 226
227 /* Flags for acpi_os_acquire_lock/acpi_os_release_lock */ 227 /* Flags for acpi_os_acquire_lock/acpi_os_release_lock */
228 228
229 #ifndef acpi_cpu_flags 229 #ifndef acpi_cpu_flags
230 #define acpi_cpu_flags acpi_size 230 #define acpi_cpu_flags acpi_size
231 #endif 231 #endif
232 232
233 /* Object returned from acpi_os_create_cache */ 233 /* Object returned from acpi_os_create_cache */
234 234
235 #ifndef acpi_cache_t 235 #ifndef acpi_cache_t
236 #define acpi_cache_t struct acpi_memory_list 236 #define acpi_cache_t struct acpi_memory_list
237 #endif 237 #endif
238 238
239 /* Use C99 uintptr_t for pointer casting if available, "void *" otherwise */ 239 /* Use C99 uintptr_t for pointer casting if available, "void *" otherwise */
240 240
241 #ifndef acpi_uintptr_t 241 #ifndef acpi_uintptr_t
242 #define acpi_uintptr_t void * 242 #define acpi_uintptr_t void *
243 #endif 243 #endif
244 244
245 /* 245 /*
246 * ACPI_PRINTF_LIKE is used to tag functions as "printf-like" because 246 * ACPI_PRINTF_LIKE is used to tag functions as "printf-like" because
247 * some compilers can catch printf format string problems 247 * some compilers can catch printf format string problems
248 */ 248 */
249 #ifndef ACPI_PRINTF_LIKE 249 #ifndef ACPI_PRINTF_LIKE
250 #define ACPI_PRINTF_LIKE(c) 250 #define ACPI_PRINTF_LIKE(c)
251 #endif 251 #endif
252 252
253 /* 253 /*
254 * Some compilers complain about unused variables. Sometimes we don't want to 254 * Some compilers complain about unused variables. Sometimes we don't want to
255 * use all the variables (for example, _acpi_module_name). This allows us 255 * use all the variables (for example, _acpi_module_name). This allows us
256 * to to tell the compiler in a per-variable manner that a variable 256 * to to tell the compiler in a per-variable manner that a variable
257 * is unused 257 * is unused
258 */ 258 */
259 #ifndef ACPI_UNUSED_VAR 259 #ifndef ACPI_UNUSED_VAR
260 #define ACPI_UNUSED_VAR 260 #define ACPI_UNUSED_VAR
261 #endif 261 #endif
262 262
263 /* 263 /*
264 * All ACPICA functions that are available to the rest of the kernel are 264 * All ACPICA functions that are available to the rest of the kernel are
265 * tagged with this macro which can be defined as appropriate for the host. 265 * tagged with this macro which can be defined as appropriate for the host.
266 */ 266 */
267 #ifndef ACPI_EXPORT_SYMBOL 267 #ifndef ACPI_EXPORT_SYMBOL
268 #define ACPI_EXPORT_SYMBOL(symbol) 268 #define ACPI_EXPORT_SYMBOL(symbol)
269 #endif 269 #endif
270 270
271 /******************************************************************************* 271 /*******************************************************************************
272 * 272 *
273 * Independent types 273 * Independent types
274 * 274 *
275 ******************************************************************************/ 275 ******************************************************************************/
276 276
277 /* Logical defines and NULL */ 277 /* Logical defines and NULL */
278 278
279 #ifdef FALSE 279 #ifdef FALSE
280 #undef FALSE 280 #undef FALSE
281 #endif 281 #endif
282 #define FALSE (1 == 0) 282 #define FALSE (1 == 0)
283 283
284 #ifdef TRUE 284 #ifdef TRUE
285 #undef TRUE 285 #undef TRUE
286 #endif 286 #endif
287 #define TRUE (1 == 1) 287 #define TRUE (1 == 1)
288 288
289 #ifndef NULL 289 #ifndef NULL
290 #define NULL (void *) 0 290 #define NULL (void *) 0
291 #endif 291 #endif
292 292
293 /* 293 /*
294 * Mescellaneous types 294 * Mescellaneous types
295 */ 295 */
296 typedef u32 acpi_status; /* All ACPI Exceptions */ 296 typedef u32 acpi_status; /* All ACPI Exceptions */
297 typedef u32 acpi_name; /* 4-byte ACPI name */ 297 typedef u32 acpi_name; /* 4-byte ACPI name */
298 typedef char *acpi_string; /* Null terminated ASCII string */ 298 typedef char *acpi_string; /* Null terminated ASCII string */
299 typedef void *acpi_handle; /* Actually a ptr to a NS Node */ 299 typedef void *acpi_handle; /* Actually a ptr to a NS Node */
300 300
301 struct uint64_struct { 301 struct uint64_struct {
302 u32 lo; 302 u32 lo;
303 u32 hi; 303 u32 hi;
304 }; 304 };
305 305
306 union uint64_overlay { 306 union uint64_overlay {
307 u64 full; 307 u64 full;
308 struct uint64_struct part; 308 struct uint64_struct part;
309 }; 309 };
310 310
311 struct uint32_struct { 311 struct uint32_struct {
312 u32 lo; 312 u32 lo;
313 u32 hi; 313 u32 hi;
314 }; 314 };
315 315
316 /* Synchronization objects */ 316 /* Synchronization objects */
317 317
318 #define acpi_mutex void * 318 #define acpi_mutex void *
319 #define acpi_semaphore void * 319 #define acpi_semaphore void *
320 320
321 /* 321 /*
322 * Acpi integer width. In ACPI version 1, integers are 32 bits. In ACPI 322 * Acpi integer width. In ACPI version 1, integers are 32 bits. In ACPI
323 * version 2, integers are 64 bits. Note that this pertains to the ACPI integer 323 * version 2, integers are 64 bits. Note that this pertains to the ACPI integer
324 * type only, not other integers used in the implementation of the ACPI CA 324 * type only, not other integers used in the implementation of the ACPI CA
325 * subsystem. 325 * subsystem.
326 */ 326 */
327 typedef unsigned long long acpi_integer; 327 typedef unsigned long long acpi_integer;
328 #define ACPI_INTEGER_MAX ACPI_UINT64_MAX 328 #define ACPI_INTEGER_MAX ACPI_UINT64_MAX
329 #define ACPI_INTEGER_BIT_SIZE 64 329 #define ACPI_INTEGER_BIT_SIZE 64
330 #define ACPI_MAX_DECIMAL_DIGITS 20 /* 2^64 = 18,446,744,073,709,551,616 */ 330 #define ACPI_MAX_DECIMAL_DIGITS 20 /* 2^64 = 18,446,744,073,709,551,616 */
331 331
332 #if ACPI_MACHINE_WIDTH == 64 332 #if ACPI_MACHINE_WIDTH == 64
333 #define ACPI_USE_NATIVE_DIVIDE /* Use compiler native 64-bit divide */ 333 #define ACPI_USE_NATIVE_DIVIDE /* Use compiler native 64-bit divide */
334 #endif 334 #endif
335 335
336 #define ACPI_MAX64_DECIMAL_DIGITS 20 336 #define ACPI_MAX64_DECIMAL_DIGITS 20
337 #define ACPI_MAX32_DECIMAL_DIGITS 10 337 #define ACPI_MAX32_DECIMAL_DIGITS 10
338 #define ACPI_MAX16_DECIMAL_DIGITS 5 338 #define ACPI_MAX16_DECIMAL_DIGITS 5
339 #define ACPI_MAX8_DECIMAL_DIGITS 3 339 #define ACPI_MAX8_DECIMAL_DIGITS 3
340 340
341 /* 341 /*
342 * Constants with special meanings 342 * Constants with special meanings
343 */ 343 */
344 #define ACPI_ROOT_OBJECT ACPI_ADD_PTR (acpi_handle, NULL, ACPI_MAX_PTR) 344 #define ACPI_ROOT_OBJECT ACPI_ADD_PTR (acpi_handle, NULL, ACPI_MAX_PTR)
345 345
346 /* 346 /*
347 * Initialization sequence 347 * Initialization sequence
348 */ 348 */
349 #define ACPI_FULL_INITIALIZATION 0x00 349 #define ACPI_FULL_INITIALIZATION 0x00
350 #define ACPI_NO_ADDRESS_SPACE_INIT 0x01 350 #define ACPI_NO_ADDRESS_SPACE_INIT 0x01
351 #define ACPI_NO_HARDWARE_INIT 0x02 351 #define ACPI_NO_HARDWARE_INIT 0x02
352 #define ACPI_NO_EVENT_INIT 0x04 352 #define ACPI_NO_EVENT_INIT 0x04
353 #define ACPI_NO_HANDLER_INIT 0x08 353 #define ACPI_NO_HANDLER_INIT 0x08
354 #define ACPI_NO_ACPI_ENABLE 0x10 354 #define ACPI_NO_ACPI_ENABLE 0x10
355 #define ACPI_NO_DEVICE_INIT 0x20 355 #define ACPI_NO_DEVICE_INIT 0x20
356 #define ACPI_NO_OBJECT_INIT 0x40 356 #define ACPI_NO_OBJECT_INIT 0x40
357 357
358 /* 358 /*
359 * Initialization state 359 * Initialization state
360 */ 360 */
361 #define ACPI_SUBSYSTEM_INITIALIZE 0x01 361 #define ACPI_SUBSYSTEM_INITIALIZE 0x01
362 #define ACPI_INITIALIZED_OK 0x02 362 #define ACPI_INITIALIZED_OK 0x02
363 363
364 /* 364 /*
365 * Power state values 365 * Power state values
366 */ 366 */
367 #define ACPI_STATE_UNKNOWN (u8) 0xFF 367 #define ACPI_STATE_UNKNOWN (u8) 0xFF
368 368
369 #define ACPI_STATE_S0 (u8) 0 369 #define ACPI_STATE_S0 (u8) 0
370 #define ACPI_STATE_S1 (u8) 1 370 #define ACPI_STATE_S1 (u8) 1
371 #define ACPI_STATE_S2 (u8) 2 371 #define ACPI_STATE_S2 (u8) 2
372 #define ACPI_STATE_S3 (u8) 3 372 #define ACPI_STATE_S3 (u8) 3
373 #define ACPI_STATE_S4 (u8) 4 373 #define ACPI_STATE_S4 (u8) 4
374 #define ACPI_STATE_S5 (u8) 5 374 #define ACPI_STATE_S5 (u8) 5
375 #define ACPI_S_STATES_MAX ACPI_STATE_S5 375 #define ACPI_S_STATES_MAX ACPI_STATE_S5
376 #define ACPI_S_STATE_COUNT 6 376 #define ACPI_S_STATE_COUNT 6
377 377
378 #define ACPI_STATE_D0 (u8) 0 378 #define ACPI_STATE_D0 (u8) 0
379 #define ACPI_STATE_D1 (u8) 1 379 #define ACPI_STATE_D1 (u8) 1
380 #define ACPI_STATE_D2 (u8) 2 380 #define ACPI_STATE_D2 (u8) 2
381 #define ACPI_STATE_D3 (u8) 3 381 #define ACPI_STATE_D3 (u8) 3
382 #define ACPI_D_STATES_MAX ACPI_STATE_D3 382 #define ACPI_D_STATES_MAX ACPI_STATE_D3
383 #define ACPI_D_STATE_COUNT 4 383 #define ACPI_D_STATE_COUNT 4
384 384
385 #define ACPI_STATE_C0 (u8) 0 385 #define ACPI_STATE_C0 (u8) 0
386 #define ACPI_STATE_C1 (u8) 1 386 #define ACPI_STATE_C1 (u8) 1
387 #define ACPI_STATE_C2 (u8) 2 387 #define ACPI_STATE_C2 (u8) 2
388 #define ACPI_STATE_C3 (u8) 3 388 #define ACPI_STATE_C3 (u8) 3
389 #define ACPI_C_STATES_MAX ACPI_STATE_C3 389 #define ACPI_C_STATES_MAX ACPI_STATE_C3
390 #define ACPI_C_STATE_COUNT 4 390 #define ACPI_C_STATE_COUNT 4
391 391
392 /* 392 /*
393 * Sleep type invalid value 393 * Sleep type invalid value
394 */ 394 */
395 #define ACPI_SLEEP_TYPE_MAX 0x7 395 #define ACPI_SLEEP_TYPE_MAX 0x7
396 #define ACPI_SLEEP_TYPE_INVALID 0xFF 396 #define ACPI_SLEEP_TYPE_INVALID 0xFF
397 397
398 /* 398 /*
399 * Standard notify values 399 * Standard notify values
400 */ 400 */
401 #define ACPI_NOTIFY_BUS_CHECK (u8) 0x00 401 #define ACPI_NOTIFY_BUS_CHECK (u8) 0x00
402 #define ACPI_NOTIFY_DEVICE_CHECK (u8) 0x01 402 #define ACPI_NOTIFY_DEVICE_CHECK (u8) 0x01
403 #define ACPI_NOTIFY_DEVICE_WAKE (u8) 0x02 403 #define ACPI_NOTIFY_DEVICE_WAKE (u8) 0x02
404 #define ACPI_NOTIFY_EJECT_REQUEST (u8) 0x03 404 #define ACPI_NOTIFY_EJECT_REQUEST (u8) 0x03
405 #define ACPI_NOTIFY_DEVICE_CHECK_LIGHT (u8) 0x04 405 #define ACPI_NOTIFY_DEVICE_CHECK_LIGHT (u8) 0x04
406 #define ACPI_NOTIFY_FREQUENCY_MISMATCH (u8) 0x05 406 #define ACPI_NOTIFY_FREQUENCY_MISMATCH (u8) 0x05
407 #define ACPI_NOTIFY_BUS_MODE_MISMATCH (u8) 0x06 407 #define ACPI_NOTIFY_BUS_MODE_MISMATCH (u8) 0x06
408 #define ACPI_NOTIFY_POWER_FAULT (u8) 0x07 408 #define ACPI_NOTIFY_POWER_FAULT (u8) 0x07
409 #define ACPI_NOTIFY_CAPABILITIES_CHECK (u8) 0x08 409 #define ACPI_NOTIFY_CAPABILITIES_CHECK (u8) 0x08
410 #define ACPI_NOTIFY_DEVICE_PLD_CHECK (u8) 0x09 410 #define ACPI_NOTIFY_DEVICE_PLD_CHECK (u8) 0x09
411 #define ACPI_NOTIFY_RESERVED (u8) 0x0A 411 #define ACPI_NOTIFY_RESERVED (u8) 0x0A
412 #define ACPI_NOTIFY_LOCALITY_UPDATE (u8) 0x0B 412 #define ACPI_NOTIFY_LOCALITY_UPDATE (u8) 0x0B
413 413
414 #define ACPI_NOTIFY_MAX 0x0B 414 #define ACPI_NOTIFY_MAX 0x0B
415 415
416 /* 416 /*
417 * Types associated with ACPI names and objects. The first group of 417 * Types associated with ACPI names and objects. The first group of
418 * values (up to ACPI_TYPE_EXTERNAL_MAX) correspond to the definition 418 * values (up to ACPI_TYPE_EXTERNAL_MAX) correspond to the definition
419 * of the ACPI object_type() operator (See the ACPI Spec). Therefore, 419 * of the ACPI object_type() operator (See the ACPI Spec). Therefore,
420 * only add to the first group if the spec changes. 420 * only add to the first group if the spec changes.
421 * 421 *
422 * NOTE: Types must be kept in sync with the global acpi_ns_properties 422 * NOTE: Types must be kept in sync with the global acpi_ns_properties
423 * and acpi_ns_type_names arrays. 423 * and acpi_ns_type_names arrays.
424 */ 424 */
425 typedef u32 acpi_object_type; 425 typedef u32 acpi_object_type;
426 426
427 #define ACPI_TYPE_ANY 0x00 427 #define ACPI_TYPE_ANY 0x00
428 #define ACPI_TYPE_INTEGER 0x01 /* Byte/Word/Dword/Zero/One/Ones */ 428 #define ACPI_TYPE_INTEGER 0x01 /* Byte/Word/Dword/Zero/One/Ones */
429 #define ACPI_TYPE_STRING 0x02 429 #define ACPI_TYPE_STRING 0x02
430 #define ACPI_TYPE_BUFFER 0x03 430 #define ACPI_TYPE_BUFFER 0x03
431 #define ACPI_TYPE_PACKAGE 0x04 /* byte_const, multiple data_term/Constant/super_name */ 431 #define ACPI_TYPE_PACKAGE 0x04 /* byte_const, multiple data_term/Constant/super_name */
432 #define ACPI_TYPE_FIELD_UNIT 0x05 432 #define ACPI_TYPE_FIELD_UNIT 0x05
433 #define ACPI_TYPE_DEVICE 0x06 /* Name, multiple Node */ 433 #define ACPI_TYPE_DEVICE 0x06 /* Name, multiple Node */
434 #define ACPI_TYPE_EVENT 0x07 434 #define ACPI_TYPE_EVENT 0x07
435 #define ACPI_TYPE_METHOD 0x08 /* Name, byte_const, multiple Code */ 435 #define ACPI_TYPE_METHOD 0x08 /* Name, byte_const, multiple Code */
436 #define ACPI_TYPE_MUTEX 0x09 436 #define ACPI_TYPE_MUTEX 0x09
437 #define ACPI_TYPE_REGION 0x0A 437 #define ACPI_TYPE_REGION 0x0A
438 #define ACPI_TYPE_POWER 0x0B /* Name,byte_const,word_const,multi Node */ 438 #define ACPI_TYPE_POWER 0x0B /* Name,byte_const,word_const,multi Node */
439 #define ACPI_TYPE_PROCESSOR 0x0C /* Name,byte_const,Dword_const,byte_const,multi nm_o */ 439 #define ACPI_TYPE_PROCESSOR 0x0C /* Name,byte_const,Dword_const,byte_const,multi nm_o */
440 #define ACPI_TYPE_THERMAL 0x0D /* Name, multiple Node */ 440 #define ACPI_TYPE_THERMAL 0x0D /* Name, multiple Node */
441 #define ACPI_TYPE_BUFFER_FIELD 0x0E 441 #define ACPI_TYPE_BUFFER_FIELD 0x0E
442 #define ACPI_TYPE_DDB_HANDLE 0x0F 442 #define ACPI_TYPE_DDB_HANDLE 0x0F
443 #define ACPI_TYPE_DEBUG_OBJECT 0x10 443 #define ACPI_TYPE_DEBUG_OBJECT 0x10
444 444
445 #define ACPI_TYPE_EXTERNAL_MAX 0x10 445 #define ACPI_TYPE_EXTERNAL_MAX 0x10
446 446
447 /* 447 /*
448 * These are object types that do not map directly to the ACPI 448 * These are object types that do not map directly to the ACPI
449 * object_type() operator. They are used for various internal purposes only. 449 * object_type() operator. They are used for various internal purposes only.
450 * If new predefined ACPI_TYPEs are added (via the ACPI specification), these 450 * If new predefined ACPI_TYPEs are added (via the ACPI specification), these
451 * internal types must move upwards. (There is code that depends on these 451 * internal types must move upwards. (There is code that depends on these
452 * values being contiguous with the external types above.) 452 * values being contiguous with the external types above.)
453 */ 453 */
454 #define ACPI_TYPE_LOCAL_REGION_FIELD 0x11 454 #define ACPI_TYPE_LOCAL_REGION_FIELD 0x11
455 #define ACPI_TYPE_LOCAL_BANK_FIELD 0x12 455 #define ACPI_TYPE_LOCAL_BANK_FIELD 0x12
456 #define ACPI_TYPE_LOCAL_INDEX_FIELD 0x13 456 #define ACPI_TYPE_LOCAL_INDEX_FIELD 0x13
457 #define ACPI_TYPE_LOCAL_REFERENCE 0x14 /* Arg#, Local#, Name, Debug, ref_of, Index */ 457 #define ACPI_TYPE_LOCAL_REFERENCE 0x14 /* Arg#, Local#, Name, Debug, ref_of, Index */
458 #define ACPI_TYPE_LOCAL_ALIAS 0x15 458 #define ACPI_TYPE_LOCAL_ALIAS 0x15
459 #define ACPI_TYPE_LOCAL_METHOD_ALIAS 0x16 459 #define ACPI_TYPE_LOCAL_METHOD_ALIAS 0x16
460 #define ACPI_TYPE_LOCAL_NOTIFY 0x17 460 #define ACPI_TYPE_LOCAL_NOTIFY 0x17
461 #define ACPI_TYPE_LOCAL_ADDRESS_HANDLER 0x18 461 #define ACPI_TYPE_LOCAL_ADDRESS_HANDLER 0x18
462 #define ACPI_TYPE_LOCAL_RESOURCE 0x19 462 #define ACPI_TYPE_LOCAL_RESOURCE 0x19
463 #define ACPI_TYPE_LOCAL_RESOURCE_FIELD 0x1A 463 #define ACPI_TYPE_LOCAL_RESOURCE_FIELD 0x1A
464 #define ACPI_TYPE_LOCAL_SCOPE 0x1B /* 1 Name, multiple object_list Nodes */ 464 #define ACPI_TYPE_LOCAL_SCOPE 0x1B /* 1 Name, multiple object_list Nodes */
465 465
466 #define ACPI_TYPE_NS_NODE_MAX 0x1B /* Last typecode used within a NS Node */ 466 #define ACPI_TYPE_NS_NODE_MAX 0x1B /* Last typecode used within a NS Node */
467 467
468 /* 468 /*
469 * These are special object types that never appear in 469 * These are special object types that never appear in
470 * a Namespace node, only in an union acpi_operand_object 470 * a Namespace node, only in an union acpi_operand_object
471 */ 471 */
472 #define ACPI_TYPE_LOCAL_EXTRA 0x1C 472 #define ACPI_TYPE_LOCAL_EXTRA 0x1C
473 #define ACPI_TYPE_LOCAL_DATA 0x1D 473 #define ACPI_TYPE_LOCAL_DATA 0x1D
474 474
475 #define ACPI_TYPE_LOCAL_MAX 0x1D 475 #define ACPI_TYPE_LOCAL_MAX 0x1D
476 476
477 /* All types above here are invalid */ 477 /* All types above here are invalid */
478 478
479 #define ACPI_TYPE_INVALID 0x1E 479 #define ACPI_TYPE_INVALID 0x1E
480 #define ACPI_TYPE_NOT_FOUND 0xFF 480 #define ACPI_TYPE_NOT_FOUND 0xFF
481 481
482 #define ACPI_NUM_NS_TYPES (ACPI_TYPE_INVALID + 1) 482 #define ACPI_NUM_NS_TYPES (ACPI_TYPE_INVALID + 1)
483 483
484 /* 484 /*
485 * All I/O 485 * All I/O
486 */ 486 */
487 #define ACPI_READ 0 487 #define ACPI_READ 0
488 #define ACPI_WRITE 1 488 #define ACPI_WRITE 1
489 #define ACPI_IO_MASK 1 489 #define ACPI_IO_MASK 1
490 490
491 /* 491 /*
492 * Event Types: Fixed & General Purpose 492 * Event Types: Fixed & General Purpose
493 */ 493 */
494 typedef u32 acpi_event_type; 494 typedef u32 acpi_event_type;
495 495
496 /* 496 /*
497 * Fixed events 497 * Fixed events
498 */ 498 */
499 #define ACPI_EVENT_PMTIMER 0 499 #define ACPI_EVENT_PMTIMER 0
500 #define ACPI_EVENT_GLOBAL 1 500 #define ACPI_EVENT_GLOBAL 1
501 #define ACPI_EVENT_POWER_BUTTON 2 501 #define ACPI_EVENT_POWER_BUTTON 2
502 #define ACPI_EVENT_SLEEP_BUTTON 3 502 #define ACPI_EVENT_SLEEP_BUTTON 3
503 #define ACPI_EVENT_RTC 4 503 #define ACPI_EVENT_RTC 4
504 #define ACPI_EVENT_MAX 4 504 #define ACPI_EVENT_MAX 4
505 #define ACPI_NUM_FIXED_EVENTS ACPI_EVENT_MAX + 1 505 #define ACPI_NUM_FIXED_EVENTS ACPI_EVENT_MAX + 1
506 506
507 /* 507 /*
508 * Event Status - Per event 508 * Event Status - Per event
509 * ------------- 509 * -------------
510 * The encoding of acpi_event_status is illustrated below. 510 * The encoding of acpi_event_status is illustrated below.
511 * Note that a set bit (1) indicates the property is TRUE 511 * Note that a set bit (1) indicates the property is TRUE
512 * (e.g. if bit 0 is set then the event is enabled). 512 * (e.g. if bit 0 is set then the event is enabled).
513 * +-------------+-+-+-+ 513 * +-------------+-+-+-+
514 * | Bits 31:3 |2|1|0| 514 * | Bits 31:3 |2|1|0|
515 * +-------------+-+-+-+ 515 * +-------------+-+-+-+
516 * | | | | 516 * | | | |
517 * | | | +- Enabled? 517 * | | | +- Enabled?
518 * | | +--- Enabled for wake? 518 * | | +--- Enabled for wake?
519 * | +----- Set? 519 * | +----- Set?
520 * +----------- <Reserved> 520 * +----------- <Reserved>
521 */ 521 */
522 typedef u32 acpi_event_status; 522 typedef u32 acpi_event_status;
523 523
524 #define ACPI_EVENT_FLAG_DISABLED (acpi_event_status) 0x00 524 #define ACPI_EVENT_FLAG_DISABLED (acpi_event_status) 0x00
525 #define ACPI_EVENT_FLAG_ENABLED (acpi_event_status) 0x01 525 #define ACPI_EVENT_FLAG_ENABLED (acpi_event_status) 0x01
526 #define ACPI_EVENT_FLAG_WAKE_ENABLED (acpi_event_status) 0x02 526 #define ACPI_EVENT_FLAG_WAKE_ENABLED (acpi_event_status) 0x02
527 #define ACPI_EVENT_FLAG_SET (acpi_event_status) 0x04 527 #define ACPI_EVENT_FLAG_SET (acpi_event_status) 0x04
528 #define ACPI_EVENT_FLAG_HANDLE (acpi_event_status) 0x08
528 529
529 /* 530 /*
530 * General Purpose Events (GPE) 531 * General Purpose Events (GPE)
531 */ 532 */
532 #define ACPI_GPE_INVALID 0xFF 533 #define ACPI_GPE_INVALID 0xFF
533 #define ACPI_GPE_MAX 0xFF 534 #define ACPI_GPE_MAX 0xFF
534 #define ACPI_NUM_GPE 256 535 #define ACPI_NUM_GPE 256
535 536
536 #define ACPI_GPE_ENABLE 0 537 #define ACPI_GPE_ENABLE 0
537 #define ACPI_GPE_DISABLE 1 538 #define ACPI_GPE_DISABLE 1
538 539
539 /* 540 /*
540 * GPE info flags - Per GPE 541 * GPE info flags - Per GPE
541 * +-+-+-+---+---+-+ 542 * +-+-+-+---+---+-+
542 * |7|6|5|4:3|2:1|0| 543 * |7|6|5|4:3|2:1|0|
543 * +-+-+-+---+---+-+ 544 * +-+-+-+---+---+-+
544 * | | | | | | 545 * | | | | | |
545 * | | | | | +--- Interrupt type: Edge or Level Triggered 546 * | | | | | +--- Interrupt type: Edge or Level Triggered
546 * | | | | +--- Type: Wake-only, Runtime-only, or wake/runtime 547 * | | | | +--- Type: Wake-only, Runtime-only, or wake/runtime
547 * | | | +--- Type of dispatch -- to method, handler, or none 548 * | | | +--- Type of dispatch -- to method, handler, or none
548 * | | +--- Enabled for runtime? 549 * | | +--- Enabled for runtime?
549 * | +--- Enabled for wake? 550 * | +--- Enabled for wake?
550 * +--- Unused 551 * +--- Unused
551 */ 552 */
552 #define ACPI_GPE_XRUPT_TYPE_MASK (u8) 0x01 553 #define ACPI_GPE_XRUPT_TYPE_MASK (u8) 0x01
553 #define ACPI_GPE_LEVEL_TRIGGERED (u8) 0x01 554 #define ACPI_GPE_LEVEL_TRIGGERED (u8) 0x01
554 #define ACPI_GPE_EDGE_TRIGGERED (u8) 0x00 555 #define ACPI_GPE_EDGE_TRIGGERED (u8) 0x00
555 556
556 #define ACPI_GPE_TYPE_MASK (u8) 0x06 557 #define ACPI_GPE_TYPE_MASK (u8) 0x06
557 #define ACPI_GPE_TYPE_WAKE_RUN (u8) 0x06 558 #define ACPI_GPE_TYPE_WAKE_RUN (u8) 0x06
558 #define ACPI_GPE_TYPE_WAKE (u8) 0x02 559 #define ACPI_GPE_TYPE_WAKE (u8) 0x02
559 #define ACPI_GPE_TYPE_RUNTIME (u8) 0x04 /* Default */ 560 #define ACPI_GPE_TYPE_RUNTIME (u8) 0x04 /* Default */
560 561
561 #define ACPI_GPE_DISPATCH_MASK (u8) 0x18 562 #define ACPI_GPE_DISPATCH_MASK (u8) 0x18
562 #define ACPI_GPE_DISPATCH_HANDLER (u8) 0x08 563 #define ACPI_GPE_DISPATCH_HANDLER (u8) 0x08
563 #define ACPI_GPE_DISPATCH_METHOD (u8) 0x10 564 #define ACPI_GPE_DISPATCH_METHOD (u8) 0x10
564 #define ACPI_GPE_DISPATCH_NOT_USED (u8) 0x00 /* Default */ 565 #define ACPI_GPE_DISPATCH_NOT_USED (u8) 0x00 /* Default */
565 566
566 #define ACPI_GPE_RUN_ENABLE_MASK (u8) 0x20 567 #define ACPI_GPE_RUN_ENABLE_MASK (u8) 0x20
567 #define ACPI_GPE_RUN_ENABLED (u8) 0x20 568 #define ACPI_GPE_RUN_ENABLED (u8) 0x20
568 #define ACPI_GPE_RUN_DISABLED (u8) 0x00 /* Default */ 569 #define ACPI_GPE_RUN_DISABLED (u8) 0x00 /* Default */
569 570
570 #define ACPI_GPE_WAKE_ENABLE_MASK (u8) 0x40 571 #define ACPI_GPE_WAKE_ENABLE_MASK (u8) 0x40
571 #define ACPI_GPE_WAKE_ENABLED (u8) 0x40 572 #define ACPI_GPE_WAKE_ENABLED (u8) 0x40
572 #define ACPI_GPE_WAKE_DISABLED (u8) 0x00 /* Default */ 573 #define ACPI_GPE_WAKE_DISABLED (u8) 0x00 /* Default */
573 574
574 #define ACPI_GPE_ENABLE_MASK (u8) 0x60 /* Both run/wake */ 575 #define ACPI_GPE_ENABLE_MASK (u8) 0x60 /* Both run/wake */
575 576
576 /* 577 /*
577 * Flags for GPE and Lock interfaces 578 * Flags for GPE and Lock interfaces
578 */ 579 */
579 #define ACPI_EVENT_WAKE_ENABLE 0x2 /* acpi_gpe_enable */ 580 #define ACPI_EVENT_WAKE_ENABLE 0x2 /* acpi_gpe_enable */
580 #define ACPI_EVENT_WAKE_DISABLE 0x2 /* acpi_gpe_disable */ 581 #define ACPI_EVENT_WAKE_DISABLE 0x2 /* acpi_gpe_disable */
581 582
582 #define ACPI_NOT_ISR 0x1 583 #define ACPI_NOT_ISR 0x1
583 #define ACPI_ISR 0x0 584 #define ACPI_ISR 0x0
584 585
585 /* Notify types */ 586 /* Notify types */
586 587
587 #define ACPI_SYSTEM_NOTIFY 0x1 588 #define ACPI_SYSTEM_NOTIFY 0x1
588 #define ACPI_DEVICE_NOTIFY 0x2 589 #define ACPI_DEVICE_NOTIFY 0x2
589 #define ACPI_ALL_NOTIFY (ACPI_SYSTEM_NOTIFY | ACPI_DEVICE_NOTIFY) 590 #define ACPI_ALL_NOTIFY (ACPI_SYSTEM_NOTIFY | ACPI_DEVICE_NOTIFY)
590 #define ACPI_MAX_NOTIFY_HANDLER_TYPE 0x3 591 #define ACPI_MAX_NOTIFY_HANDLER_TYPE 0x3
591 592
592 #define ACPI_MAX_SYS_NOTIFY 0x7f 593 #define ACPI_MAX_SYS_NOTIFY 0x7f
593 594
594 /* Address Space (Operation Region) Types */ 595 /* Address Space (Operation Region) Types */
595 596
596 typedef u8 acpi_adr_space_type; 597 typedef u8 acpi_adr_space_type;
597 598
598 #define ACPI_ADR_SPACE_SYSTEM_MEMORY (acpi_adr_space_type) 0 599 #define ACPI_ADR_SPACE_SYSTEM_MEMORY (acpi_adr_space_type) 0
599 #define ACPI_ADR_SPACE_SYSTEM_IO (acpi_adr_space_type) 1 600 #define ACPI_ADR_SPACE_SYSTEM_IO (acpi_adr_space_type) 1
600 #define ACPI_ADR_SPACE_PCI_CONFIG (acpi_adr_space_type) 2 601 #define ACPI_ADR_SPACE_PCI_CONFIG (acpi_adr_space_type) 2
601 #define ACPI_ADR_SPACE_EC (acpi_adr_space_type) 3 602 #define ACPI_ADR_SPACE_EC (acpi_adr_space_type) 3
602 #define ACPI_ADR_SPACE_SMBUS (acpi_adr_space_type) 4 603 #define ACPI_ADR_SPACE_SMBUS (acpi_adr_space_type) 4
603 #define ACPI_ADR_SPACE_CMOS (acpi_adr_space_type) 5 604 #define ACPI_ADR_SPACE_CMOS (acpi_adr_space_type) 5
604 #define ACPI_ADR_SPACE_PCI_BAR_TARGET (acpi_adr_space_type) 6 605 #define ACPI_ADR_SPACE_PCI_BAR_TARGET (acpi_adr_space_type) 6
605 #define ACPI_ADR_SPACE_DATA_TABLE (acpi_adr_space_type) 7 606 #define ACPI_ADR_SPACE_DATA_TABLE (acpi_adr_space_type) 7
606 #define ACPI_ADR_SPACE_FIXED_HARDWARE (acpi_adr_space_type) 127 607 #define ACPI_ADR_SPACE_FIXED_HARDWARE (acpi_adr_space_type) 127
607 608
608 /* 609 /*
609 * bit_register IDs 610 * bit_register IDs
610 * 611 *
611 * These values are intended to be used by the hardware interfaces 612 * These values are intended to be used by the hardware interfaces
612 * and are mapped to individual bitfields defined within the ACPI 613 * and are mapped to individual bitfields defined within the ACPI
613 * registers. See the acpi_gbl_bit_register_info global table in utglobal.c 614 * registers. See the acpi_gbl_bit_register_info global table in utglobal.c
614 * for this mapping. 615 * for this mapping.
615 */ 616 */
616 617
617 /* PM1 Status register */ 618 /* PM1 Status register */
618 619
619 #define ACPI_BITREG_TIMER_STATUS 0x00 620 #define ACPI_BITREG_TIMER_STATUS 0x00
620 #define ACPI_BITREG_BUS_MASTER_STATUS 0x01 621 #define ACPI_BITREG_BUS_MASTER_STATUS 0x01
621 #define ACPI_BITREG_GLOBAL_LOCK_STATUS 0x02 622 #define ACPI_BITREG_GLOBAL_LOCK_STATUS 0x02
622 #define ACPI_BITREG_POWER_BUTTON_STATUS 0x03 623 #define ACPI_BITREG_POWER_BUTTON_STATUS 0x03
623 #define ACPI_BITREG_SLEEP_BUTTON_STATUS 0x04 624 #define ACPI_BITREG_SLEEP_BUTTON_STATUS 0x04
624 #define ACPI_BITREG_RT_CLOCK_STATUS 0x05 625 #define ACPI_BITREG_RT_CLOCK_STATUS 0x05
625 #define ACPI_BITREG_WAKE_STATUS 0x06 626 #define ACPI_BITREG_WAKE_STATUS 0x06
626 #define ACPI_BITREG_PCIEXP_WAKE_STATUS 0x07 627 #define ACPI_BITREG_PCIEXP_WAKE_STATUS 0x07
627 628
628 /* PM1 Enable register */ 629 /* PM1 Enable register */
629 630
630 #define ACPI_BITREG_TIMER_ENABLE 0x08 631 #define ACPI_BITREG_TIMER_ENABLE 0x08
631 #define ACPI_BITREG_GLOBAL_LOCK_ENABLE 0x09 632 #define ACPI_BITREG_GLOBAL_LOCK_ENABLE 0x09
632 #define ACPI_BITREG_POWER_BUTTON_ENABLE 0x0A 633 #define ACPI_BITREG_POWER_BUTTON_ENABLE 0x0A
633 #define ACPI_BITREG_SLEEP_BUTTON_ENABLE 0x0B 634 #define ACPI_BITREG_SLEEP_BUTTON_ENABLE 0x0B
634 #define ACPI_BITREG_RT_CLOCK_ENABLE 0x0C 635 #define ACPI_BITREG_RT_CLOCK_ENABLE 0x0C
635 #define ACPI_BITREG_PCIEXP_WAKE_DISABLE 0x0D 636 #define ACPI_BITREG_PCIEXP_WAKE_DISABLE 0x0D
636 637
637 /* PM1 Control register */ 638 /* PM1 Control register */
638 639
639 #define ACPI_BITREG_SCI_ENABLE 0x0E 640 #define ACPI_BITREG_SCI_ENABLE 0x0E
640 #define ACPI_BITREG_BUS_MASTER_RLD 0x0F 641 #define ACPI_BITREG_BUS_MASTER_RLD 0x0F
641 #define ACPI_BITREG_GLOBAL_LOCK_RELEASE 0x10 642 #define ACPI_BITREG_GLOBAL_LOCK_RELEASE 0x10
642 #define ACPI_BITREG_SLEEP_TYPE_A 0x11 643 #define ACPI_BITREG_SLEEP_TYPE_A 0x11
643 #define ACPI_BITREG_SLEEP_TYPE_B 0x12 644 #define ACPI_BITREG_SLEEP_TYPE_B 0x12
644 #define ACPI_BITREG_SLEEP_ENABLE 0x13 645 #define ACPI_BITREG_SLEEP_ENABLE 0x13
645 646
646 /* PM2 Control register */ 647 /* PM2 Control register */
647 648
648 #define ACPI_BITREG_ARB_DISABLE 0x14 649 #define ACPI_BITREG_ARB_DISABLE 0x14
649 650
650 #define ACPI_BITREG_MAX 0x14 651 #define ACPI_BITREG_MAX 0x14
651 #define ACPI_NUM_BITREG ACPI_BITREG_MAX + 1 652 #define ACPI_NUM_BITREG ACPI_BITREG_MAX + 1
652 653
653 /* 654 /*
654 * External ACPI object definition 655 * External ACPI object definition
655 */ 656 */
656 657
657 /* 658 /*
658 * Note: Type == ACPI_TYPE_ANY (0) is used to indicate a NULL package element 659 * Note: Type == ACPI_TYPE_ANY (0) is used to indicate a NULL package element
659 * or an unresolved named reference. 660 * or an unresolved named reference.
660 */ 661 */
661 union acpi_object { 662 union acpi_object {
662 acpi_object_type type; /* See definition of acpi_ns_type for values */ 663 acpi_object_type type; /* See definition of acpi_ns_type for values */
663 struct { 664 struct {
664 acpi_object_type type; /* ACPI_TYPE_INTEGER */ 665 acpi_object_type type; /* ACPI_TYPE_INTEGER */
665 acpi_integer value; /* The actual number */ 666 acpi_integer value; /* The actual number */
666 } integer; 667 } integer;
667 668
668 struct { 669 struct {
669 acpi_object_type type; /* ACPI_TYPE_STRING */ 670 acpi_object_type type; /* ACPI_TYPE_STRING */
670 u32 length; /* # of bytes in string, excluding trailing null */ 671 u32 length; /* # of bytes in string, excluding trailing null */
671 char *pointer; /* points to the string value */ 672 char *pointer; /* points to the string value */
672 } string; 673 } string;
673 674
674 struct { 675 struct {
675 acpi_object_type type; /* ACPI_TYPE_BUFFER */ 676 acpi_object_type type; /* ACPI_TYPE_BUFFER */
676 u32 length; /* # of bytes in buffer */ 677 u32 length; /* # of bytes in buffer */
677 u8 *pointer; /* points to the buffer */ 678 u8 *pointer; /* points to the buffer */
678 } buffer; 679 } buffer;
679 680
680 struct { 681 struct {
681 acpi_object_type type; /* ACPI_TYPE_PACKAGE */ 682 acpi_object_type type; /* ACPI_TYPE_PACKAGE */
682 u32 count; /* # of elements in package */ 683 u32 count; /* # of elements in package */
683 union acpi_object *elements; /* Pointer to an array of ACPI_OBJECTs */ 684 union acpi_object *elements; /* Pointer to an array of ACPI_OBJECTs */
684 } package; 685 } package;
685 686
686 struct { 687 struct {
687 acpi_object_type type; /* ACPI_TYPE_LOCAL_REFERENCE */ 688 acpi_object_type type; /* ACPI_TYPE_LOCAL_REFERENCE */
688 acpi_object_type actual_type; /* Type associated with the Handle */ 689 acpi_object_type actual_type; /* Type associated with the Handle */
689 acpi_handle handle; /* object reference */ 690 acpi_handle handle; /* object reference */
690 } reference; 691 } reference;
691 692
692 struct { 693 struct {
693 acpi_object_type type; /* ACPI_TYPE_PROCESSOR */ 694 acpi_object_type type; /* ACPI_TYPE_PROCESSOR */
694 u32 proc_id; 695 u32 proc_id;
695 acpi_io_address pblk_address; 696 acpi_io_address pblk_address;
696 u32 pblk_length; 697 u32 pblk_length;
697 } processor; 698 } processor;
698 699
699 struct { 700 struct {
700 acpi_object_type type; /* ACPI_TYPE_POWER */ 701 acpi_object_type type; /* ACPI_TYPE_POWER */
701 u32 system_level; 702 u32 system_level;
702 u32 resource_order; 703 u32 resource_order;
703 } power_resource; 704 } power_resource;
704 }; 705 };
705 706
706 /* 707 /*
707 * List of objects, used as a parameter list for control method evaluation 708 * List of objects, used as a parameter list for control method evaluation
708 */ 709 */
709 struct acpi_object_list { 710 struct acpi_object_list {
710 u32 count; 711 u32 count;
711 union acpi_object *pointer; 712 union acpi_object *pointer;
712 }; 713 };
713 714
714 /* 715 /*
715 * Miscellaneous common Data Structures used by the interfaces 716 * Miscellaneous common Data Structures used by the interfaces
716 */ 717 */
717 #define ACPI_NO_BUFFER 0 718 #define ACPI_NO_BUFFER 0
718 #define ACPI_ALLOCATE_BUFFER (acpi_size) (-1) 719 #define ACPI_ALLOCATE_BUFFER (acpi_size) (-1)
719 #define ACPI_ALLOCATE_LOCAL_BUFFER (acpi_size) (-2) 720 #define ACPI_ALLOCATE_LOCAL_BUFFER (acpi_size) (-2)
720 721
721 struct acpi_buffer { 722 struct acpi_buffer {
722 acpi_size length; /* Length in bytes of the buffer */ 723 acpi_size length; /* Length in bytes of the buffer */
723 void *pointer; /* pointer to buffer */ 724 void *pointer; /* pointer to buffer */
724 }; 725 };
725 726
726 /* 727 /*
727 * name_type for acpi_get_name 728 * name_type for acpi_get_name
728 */ 729 */
729 #define ACPI_FULL_PATHNAME 0 730 #define ACPI_FULL_PATHNAME 0
730 #define ACPI_SINGLE_NAME 1 731 #define ACPI_SINGLE_NAME 1
731 #define ACPI_NAME_TYPE_MAX 1 732 #define ACPI_NAME_TYPE_MAX 1
732 733
733 /* 734 /*
734 * Structure and flags for acpi_get_system_info 735 * Structure and flags for acpi_get_system_info
735 */ 736 */
736 #define ACPI_SYS_MODE_UNKNOWN 0x0000 737 #define ACPI_SYS_MODE_UNKNOWN 0x0000
737 #define ACPI_SYS_MODE_ACPI 0x0001 738 #define ACPI_SYS_MODE_ACPI 0x0001
738 #define ACPI_SYS_MODE_LEGACY 0x0002 739 #define ACPI_SYS_MODE_LEGACY 0x0002
739 #define ACPI_SYS_MODES_MASK 0x0003 740 #define ACPI_SYS_MODES_MASK 0x0003
740 741
741 /* 742 /*
742 * System info returned by acpi_get_system_info() 743 * System info returned by acpi_get_system_info()
743 */ 744 */
744 struct acpi_system_info { 745 struct acpi_system_info {
745 u32 acpi_ca_version; 746 u32 acpi_ca_version;
746 u32 flags; 747 u32 flags;
747 u32 timer_resolution; 748 u32 timer_resolution;
748 u32 reserved1; 749 u32 reserved1;
749 u32 reserved2; 750 u32 reserved2;
750 u32 debug_level; 751 u32 debug_level;
751 u32 debug_layer; 752 u32 debug_layer;
752 }; 753 };
753 754
754 /* Table Event Types */ 755 /* Table Event Types */
755 756
756 #define ACPI_TABLE_EVENT_LOAD 0x0 757 #define ACPI_TABLE_EVENT_LOAD 0x0
757 #define ACPI_TABLE_EVENT_UNLOAD 0x1 758 #define ACPI_TABLE_EVENT_UNLOAD 0x1
758 #define ACPI_NUM_TABLE_EVENTS 2 759 #define ACPI_NUM_TABLE_EVENTS 2
759 760
760 /* 761 /*
761 * Types specific to the OS service interfaces 762 * Types specific to the OS service interfaces
762 */ 763 */
763 typedef u32(ACPI_SYSTEM_XFACE * acpi_osd_handler) (void *context); 764 typedef u32(ACPI_SYSTEM_XFACE * acpi_osd_handler) (void *context);
764 765
765 typedef void 766 typedef void
766 (ACPI_SYSTEM_XFACE * acpi_osd_exec_callback) (void *context); 767 (ACPI_SYSTEM_XFACE * acpi_osd_exec_callback) (void *context);
767 768
768 /* 769 /*
769 * Various handlers and callback procedures 770 * Various handlers and callback procedures
770 */ 771 */
771 typedef u32(*acpi_event_handler) (void *context); 772 typedef u32(*acpi_event_handler) (void *context);
772 773
773 typedef 774 typedef
774 void (*acpi_notify_handler) (acpi_handle device, u32 value, void *context); 775 void (*acpi_notify_handler) (acpi_handle device, u32 value, void *context);
775 776
776 typedef 777 typedef
777 void (*acpi_object_handler) (acpi_handle object, u32 function, void *data); 778 void (*acpi_object_handler) (acpi_handle object, u32 function, void *data);
778 779
779 typedef acpi_status(*acpi_init_handler) (acpi_handle object, u32 function); 780 typedef acpi_status(*acpi_init_handler) (acpi_handle object, u32 function);
780 781
781 #define ACPI_INIT_DEVICE_INI 1 782 #define ACPI_INIT_DEVICE_INI 1
782 783
783 typedef 784 typedef
784 acpi_status(*acpi_exception_handler) (acpi_status aml_status, 785 acpi_status(*acpi_exception_handler) (acpi_status aml_status,
785 acpi_name name, 786 acpi_name name,
786 u16 opcode, 787 u16 opcode,
787 u32 aml_offset, void *context); 788 u32 aml_offset, void *context);
788 789
789 /* Table Event handler (Load, load_table etc) and types */ 790 /* Table Event handler (Load, load_table etc) and types */
790 791
791 typedef 792 typedef
792 acpi_status(*acpi_tbl_handler) (u32 event, void *table, void *context); 793 acpi_status(*acpi_tbl_handler) (u32 event, void *table, void *context);
793 794
794 /* Address Spaces (For Operation Regions) */ 795 /* Address Spaces (For Operation Regions) */
795 796
796 typedef 797 typedef
797 acpi_status(*acpi_adr_space_handler) (u32 function, 798 acpi_status(*acpi_adr_space_handler) (u32 function,
798 acpi_physical_address address, 799 acpi_physical_address address,
799 u32 bit_width, 800 u32 bit_width,
800 acpi_integer * value, 801 acpi_integer * value,
801 void *handler_context, 802 void *handler_context,
802 void *region_context); 803 void *region_context);
803 804
804 #define ACPI_DEFAULT_HANDLER NULL 805 #define ACPI_DEFAULT_HANDLER NULL
805 806
806 typedef 807 typedef
807 acpi_status(*acpi_adr_space_setup) (acpi_handle region_handle, 808 acpi_status(*acpi_adr_space_setup) (acpi_handle region_handle,
808 u32 function, 809 u32 function,
809 void *handler_context, 810 void *handler_context,
810 void **region_context); 811 void **region_context);
811 812
812 #define ACPI_REGION_ACTIVATE 0 813 #define ACPI_REGION_ACTIVATE 0
813 #define ACPI_REGION_DEACTIVATE 1 814 #define ACPI_REGION_DEACTIVATE 1
814 815
815 typedef 816 typedef
816 acpi_status(*acpi_walk_callback) (acpi_handle obj_handle, 817 acpi_status(*acpi_walk_callback) (acpi_handle obj_handle,
817 u32 nesting_level, 818 u32 nesting_level,
818 void *context, void **return_value); 819 void *context, void **return_value);
819 820
820 /* Interrupt handler return values */ 821 /* Interrupt handler return values */
821 822
822 #define ACPI_INTERRUPT_NOT_HANDLED 0x00 823 #define ACPI_INTERRUPT_NOT_HANDLED 0x00
823 #define ACPI_INTERRUPT_HANDLED 0x01 824 #define ACPI_INTERRUPT_HANDLED 0x01
824 825
825 /* Common string version of device HIDs and UIDs */ 826 /* Common string version of device HIDs and UIDs */
826 827
827 struct acpica_device_id { 828 struct acpica_device_id {
828 char value[ACPI_DEVICE_ID_LENGTH]; 829 char value[ACPI_DEVICE_ID_LENGTH];
829 }; 830 };
830 831
831 /* Common string version of device CIDs */ 832 /* Common string version of device CIDs */
832 833
833 struct acpi_compatible_id { 834 struct acpi_compatible_id {
834 char value[ACPI_MAX_CID_LENGTH]; 835 char value[ACPI_MAX_CID_LENGTH];
835 }; 836 };
836 837
837 struct acpi_compatible_id_list { 838 struct acpi_compatible_id_list {
838 u32 count; 839 u32 count;
839 u32 size; 840 u32 size;
840 struct acpi_compatible_id id[1]; 841 struct acpi_compatible_id id[1];
841 }; 842 };
842 843
843 /* Structure and flags for acpi_get_object_info */ 844 /* Structure and flags for acpi_get_object_info */
844 845
845 #define ACPI_VALID_STA 0x0001 846 #define ACPI_VALID_STA 0x0001
846 #define ACPI_VALID_ADR 0x0002 847 #define ACPI_VALID_ADR 0x0002
847 #define ACPI_VALID_HID 0x0004 848 #define ACPI_VALID_HID 0x0004
848 #define ACPI_VALID_UID 0x0008 849 #define ACPI_VALID_UID 0x0008
849 #define ACPI_VALID_CID 0x0010 850 #define ACPI_VALID_CID 0x0010
850 #define ACPI_VALID_SXDS 0x0020 851 #define ACPI_VALID_SXDS 0x0020
851 852
852 /* Flags for _STA method */ 853 /* Flags for _STA method */
853 854
854 #define ACPI_STA_DEVICE_PRESENT 0x01 855 #define ACPI_STA_DEVICE_PRESENT 0x01
855 #define ACPI_STA_DEVICE_ENABLED 0x02 856 #define ACPI_STA_DEVICE_ENABLED 0x02
856 #define ACPI_STA_DEVICE_UI 0x04 857 #define ACPI_STA_DEVICE_UI 0x04
857 #define ACPI_STA_DEVICE_FUNCTIONING 0x08 858 #define ACPI_STA_DEVICE_FUNCTIONING 0x08
858 #define ACPI_STA_DEVICE_OK 0x08 /* Synonym */ 859 #define ACPI_STA_DEVICE_OK 0x08 /* Synonym */
859 #define ACPI_STA_BATTERY_PRESENT 0x10 860 #define ACPI_STA_BATTERY_PRESENT 0x10
860 861
861 #define ACPI_COMMON_OBJ_INFO \ 862 #define ACPI_COMMON_OBJ_INFO \
862 acpi_object_type type; /* ACPI object type */ \ 863 acpi_object_type type; /* ACPI object type */ \
863 acpi_name name /* ACPI object Name */ 864 acpi_name name /* ACPI object Name */
864 865
865 struct acpi_obj_info_header { 866 struct acpi_obj_info_header {
866 ACPI_COMMON_OBJ_INFO; 867 ACPI_COMMON_OBJ_INFO;
867 }; 868 };
868 869
869 /* Structure returned from Get Object Info */ 870 /* Structure returned from Get Object Info */
870 871
871 struct acpi_device_info { 872 struct acpi_device_info {
872 ACPI_COMMON_OBJ_INFO; 873 ACPI_COMMON_OBJ_INFO;
873 874
874 u32 param_count; /* If a method, required parameter count */ 875 u32 param_count; /* If a method, required parameter count */
875 u32 valid; /* Indicates which fields below are valid */ 876 u32 valid; /* Indicates which fields below are valid */
876 u32 current_status; /* _STA value */ 877 u32 current_status; /* _STA value */
877 acpi_integer address; /* _ADR value if any */ 878 acpi_integer address; /* _ADR value if any */
878 struct acpica_device_id hardware_id; /* _HID value if any */ 879 struct acpica_device_id hardware_id; /* _HID value if any */
879 struct acpica_device_id unique_id; /* _UID value if any */ 880 struct acpica_device_id unique_id; /* _UID value if any */
880 u8 highest_dstates[4]; /* _sx_d values: 0xFF indicates not valid */ 881 u8 highest_dstates[4]; /* _sx_d values: 0xFF indicates not valid */
881 struct acpi_compatible_id_list compatibility_id; /* List of _CIDs if any */ 882 struct acpi_compatible_id_list compatibility_id; /* List of _CIDs if any */
882 }; 883 };
883 884
884 /* Context structs for address space handlers */ 885 /* Context structs for address space handlers */
885 886
886 struct acpi_pci_id { 887 struct acpi_pci_id {
887 u16 segment; 888 u16 segment;
888 u16 bus; 889 u16 bus;
889 u16 device; 890 u16 device;
890 u16 function; 891 u16 function;
891 }; 892 };
892 893
893 struct acpi_mem_space_context { 894 struct acpi_mem_space_context {
894 u32 length; 895 u32 length;
895 acpi_physical_address address; 896 acpi_physical_address address;
896 acpi_physical_address mapped_physical_address; 897 acpi_physical_address mapped_physical_address;
897 u8 *mapped_logical_address; 898 u8 *mapped_logical_address;
898 acpi_size mapped_length; 899 acpi_size mapped_length;
899 }; 900 };
900 901
901 /* 902 /*
902 * Definitions for Resource Attributes 903 * Definitions for Resource Attributes
903 */ 904 */
904 typedef u16 acpi_rs_length; /* Resource Length field is fixed at 16 bits */ 905 typedef u16 acpi_rs_length; /* Resource Length field is fixed at 16 bits */
905 typedef u32 acpi_rsdesc_size; /* Max Resource Descriptor size is (Length+3) = (64_k-1)+3 */ 906 typedef u32 acpi_rsdesc_size; /* Max Resource Descriptor size is (Length+3) = (64_k-1)+3 */
906 907
907 /* 908 /*
908 * Memory Attributes 909 * Memory Attributes
909 */ 910 */
910 #define ACPI_READ_ONLY_MEMORY (u8) 0x00 911 #define ACPI_READ_ONLY_MEMORY (u8) 0x00
911 #define ACPI_READ_WRITE_MEMORY (u8) 0x01 912 #define ACPI_READ_WRITE_MEMORY (u8) 0x01
912 913
913 #define ACPI_NON_CACHEABLE_MEMORY (u8) 0x00 914 #define ACPI_NON_CACHEABLE_MEMORY (u8) 0x00
914 #define ACPI_CACHABLE_MEMORY (u8) 0x01 915 #define ACPI_CACHABLE_MEMORY (u8) 0x01
915 #define ACPI_WRITE_COMBINING_MEMORY (u8) 0x02 916 #define ACPI_WRITE_COMBINING_MEMORY (u8) 0x02
916 #define ACPI_PREFETCHABLE_MEMORY (u8) 0x03 917 #define ACPI_PREFETCHABLE_MEMORY (u8) 0x03
917 918
918 /* 919 /*
919 * IO Attributes 920 * IO Attributes
920 * The ISA IO ranges are: n000-n0_fFh, n400-n4_fFh, n800-n8_fFh, n_c00-n_cFFh. 921 * The ISA IO ranges are: n000-n0_fFh, n400-n4_fFh, n800-n8_fFh, n_c00-n_cFFh.
921 * The non-ISA IO ranges are: n100-n3_fFh, n500-n7_fFh, n900-n_bFFh, n_cd0-n_fFFh. 922 * The non-ISA IO ranges are: n100-n3_fFh, n500-n7_fFh, n900-n_bFFh, n_cd0-n_fFFh.
922 */ 923 */
923 #define ACPI_NON_ISA_ONLY_RANGES (u8) 0x01 924 #define ACPI_NON_ISA_ONLY_RANGES (u8) 0x01
924 #define ACPI_ISA_ONLY_RANGES (u8) 0x02 925 #define ACPI_ISA_ONLY_RANGES (u8) 0x02
925 #define ACPI_ENTIRE_RANGE (ACPI_NON_ISA_ONLY_RANGES | ACPI_ISA_ONLY_RANGES) 926 #define ACPI_ENTIRE_RANGE (ACPI_NON_ISA_ONLY_RANGES | ACPI_ISA_ONLY_RANGES)
926 927
927 /* Type of translation - 1=Sparse, 0=Dense */ 928 /* Type of translation - 1=Sparse, 0=Dense */
928 929
929 #define ACPI_SPARSE_TRANSLATION (u8) 0x01 930 #define ACPI_SPARSE_TRANSLATION (u8) 0x01
930 931
931 /* 932 /*
932 * IO Port Descriptor Decode 933 * IO Port Descriptor Decode
933 */ 934 */
934 #define ACPI_DECODE_10 (u8) 0x00 /* 10-bit IO address decode */ 935 #define ACPI_DECODE_10 (u8) 0x00 /* 10-bit IO address decode */
935 #define ACPI_DECODE_16 (u8) 0x01 /* 16-bit IO address decode */ 936 #define ACPI_DECODE_16 (u8) 0x01 /* 16-bit IO address decode */
936 937
937 /* 938 /*
938 * IRQ Attributes 939 * IRQ Attributes
939 */ 940 */
940 #define ACPI_LEVEL_SENSITIVE (u8) 0x00 941 #define ACPI_LEVEL_SENSITIVE (u8) 0x00
941 #define ACPI_EDGE_SENSITIVE (u8) 0x01 942 #define ACPI_EDGE_SENSITIVE (u8) 0x01
942 943
943 #define ACPI_ACTIVE_HIGH (u8) 0x00 944 #define ACPI_ACTIVE_HIGH (u8) 0x00
944 #define ACPI_ACTIVE_LOW (u8) 0x01 945 #define ACPI_ACTIVE_LOW (u8) 0x01
945 946
946 #define ACPI_EXCLUSIVE (u8) 0x00 947 #define ACPI_EXCLUSIVE (u8) 0x00
947 #define ACPI_SHARED (u8) 0x01 948 #define ACPI_SHARED (u8) 0x01
948 949
949 /* 950 /*
950 * DMA Attributes 951 * DMA Attributes
951 */ 952 */
952 #define ACPI_COMPATIBILITY (u8) 0x00 953 #define ACPI_COMPATIBILITY (u8) 0x00
953 #define ACPI_TYPE_A (u8) 0x01 954 #define ACPI_TYPE_A (u8) 0x01
954 #define ACPI_TYPE_B (u8) 0x02 955 #define ACPI_TYPE_B (u8) 0x02
955 #define ACPI_TYPE_F (u8) 0x03 956 #define ACPI_TYPE_F (u8) 0x03
956 957
957 #define ACPI_NOT_BUS_MASTER (u8) 0x00 958 #define ACPI_NOT_BUS_MASTER (u8) 0x00
958 #define ACPI_BUS_MASTER (u8) 0x01 959 #define ACPI_BUS_MASTER (u8) 0x01
959 960
960 #define ACPI_TRANSFER_8 (u8) 0x00 961 #define ACPI_TRANSFER_8 (u8) 0x00
961 #define ACPI_TRANSFER_8_16 (u8) 0x01 962 #define ACPI_TRANSFER_8_16 (u8) 0x01
962 #define ACPI_TRANSFER_16 (u8) 0x02 963 #define ACPI_TRANSFER_16 (u8) 0x02
963 964
964 /* 965 /*
965 * Start Dependent Functions Priority definitions 966 * Start Dependent Functions Priority definitions
966 */ 967 */
967 #define ACPI_GOOD_CONFIGURATION (u8) 0x00 968 #define ACPI_GOOD_CONFIGURATION (u8) 0x00
968 #define ACPI_ACCEPTABLE_CONFIGURATION (u8) 0x01 969 #define ACPI_ACCEPTABLE_CONFIGURATION (u8) 0x01
969 #define ACPI_SUB_OPTIMAL_CONFIGURATION (u8) 0x02 970 #define ACPI_SUB_OPTIMAL_CONFIGURATION (u8) 0x02
970 971
971 /* 972 /*
972 * 16, 32 and 64-bit Address Descriptor resource types 973 * 16, 32 and 64-bit Address Descriptor resource types
973 */ 974 */
974 #define ACPI_MEMORY_RANGE (u8) 0x00 975 #define ACPI_MEMORY_RANGE (u8) 0x00
975 #define ACPI_IO_RANGE (u8) 0x01 976 #define ACPI_IO_RANGE (u8) 0x01
976 #define ACPI_BUS_NUMBER_RANGE (u8) 0x02 977 #define ACPI_BUS_NUMBER_RANGE (u8) 0x02
977 978
978 #define ACPI_ADDRESS_NOT_FIXED (u8) 0x00 979 #define ACPI_ADDRESS_NOT_FIXED (u8) 0x00
979 #define ACPI_ADDRESS_FIXED (u8) 0x01 980 #define ACPI_ADDRESS_FIXED (u8) 0x01
980 981
981 #define ACPI_POS_DECODE (u8) 0x00 982 #define ACPI_POS_DECODE (u8) 0x00
982 #define ACPI_SUB_DECODE (u8) 0x01 983 #define ACPI_SUB_DECODE (u8) 0x01
983 984
984 #define ACPI_PRODUCER (u8) 0x00 985 #define ACPI_PRODUCER (u8) 0x00
985 #define ACPI_CONSUMER (u8) 0x01 986 #define ACPI_CONSUMER (u8) 0x01
986 987
987 /* 988 /*
988 * If possible, pack the following structures to byte alignment 989 * If possible, pack the following structures to byte alignment
989 */ 990 */
990 #ifndef ACPI_MISALIGNMENT_NOT_SUPPORTED 991 #ifndef ACPI_MISALIGNMENT_NOT_SUPPORTED
991 #pragma pack(1) 992 #pragma pack(1)
992 #endif 993 #endif
993 994
994 /* UUID data structures for use in vendor-defined resource descriptors */ 995 /* UUID data structures for use in vendor-defined resource descriptors */
995 996
996 struct acpi_uuid { 997 struct acpi_uuid {
997 u8 data[ACPI_UUID_LENGTH]; 998 u8 data[ACPI_UUID_LENGTH];
998 }; 999 };
999 1000
1000 struct acpi_vendor_uuid { 1001 struct acpi_vendor_uuid {
1001 u8 subtype; 1002 u8 subtype;
1002 u8 data[ACPI_UUID_LENGTH]; 1003 u8 data[ACPI_UUID_LENGTH];
1003 }; 1004 };
1004 1005
1005 /* 1006 /*
1006 * Structures used to describe device resources 1007 * Structures used to describe device resources
1007 */ 1008 */
1008 struct acpi_resource_irq { 1009 struct acpi_resource_irq {
1009 u8 descriptor_length; 1010 u8 descriptor_length;
1010 u8 triggering; 1011 u8 triggering;
1011 u8 polarity; 1012 u8 polarity;
1012 u8 sharable; 1013 u8 sharable;
1013 u8 interrupt_count; 1014 u8 interrupt_count;
1014 u8 interrupts[1]; 1015 u8 interrupts[1];
1015 }; 1016 };
1016 1017
1017 struct acpi_resource_dma { 1018 struct acpi_resource_dma {
1018 u8 type; 1019 u8 type;
1019 u8 bus_master; 1020 u8 bus_master;
1020 u8 transfer; 1021 u8 transfer;
1021 u8 channel_count; 1022 u8 channel_count;
1022 u8 channels[1]; 1023 u8 channels[1];
1023 }; 1024 };
1024 1025
1025 struct acpi_resource_start_dependent { 1026 struct acpi_resource_start_dependent {
1026 u8 descriptor_length; 1027 u8 descriptor_length;
1027 u8 compatibility_priority; 1028 u8 compatibility_priority;
1028 u8 performance_robustness; 1029 u8 performance_robustness;
1029 }; 1030 };
1030 1031
1031 /* 1032 /*
1032 * END_DEPENDENT_FUNCTIONS_RESOURCE struct is not 1033 * END_DEPENDENT_FUNCTIONS_RESOURCE struct is not
1033 * needed because it has no fields 1034 * needed because it has no fields
1034 */ 1035 */
1035 1036
1036 struct acpi_resource_io { 1037 struct acpi_resource_io {
1037 u8 io_decode; 1038 u8 io_decode;
1038 u8 alignment; 1039 u8 alignment;
1039 u8 address_length; 1040 u8 address_length;
1040 u16 minimum; 1041 u16 minimum;
1041 u16 maximum; 1042 u16 maximum;
1042 }; 1043 };
1043 1044
1044 struct acpi_resource_fixed_io { 1045 struct acpi_resource_fixed_io {
1045 u16 address; 1046 u16 address;
1046 u8 address_length; 1047 u8 address_length;
1047 }; 1048 };
1048 1049
1049 struct acpi_resource_vendor { 1050 struct acpi_resource_vendor {
1050 u16 byte_length; 1051 u16 byte_length;
1051 u8 byte_data[1]; 1052 u8 byte_data[1];
1052 }; 1053 };
1053 1054
1054 /* Vendor resource with UUID info (introduced in ACPI 3.0) */ 1055 /* Vendor resource with UUID info (introduced in ACPI 3.0) */
1055 1056
1056 struct acpi_resource_vendor_typed { 1057 struct acpi_resource_vendor_typed {
1057 u16 byte_length; 1058 u16 byte_length;
1058 u8 uuid_subtype; 1059 u8 uuid_subtype;
1059 u8 uuid[ACPI_UUID_LENGTH]; 1060 u8 uuid[ACPI_UUID_LENGTH];
1060 u8 byte_data[1]; 1061 u8 byte_data[1];
1061 }; 1062 };
1062 1063
1063 struct acpi_resource_end_tag { 1064 struct acpi_resource_end_tag {
1064 u8 checksum; 1065 u8 checksum;
1065 }; 1066 };
1066 1067
1067 struct acpi_resource_memory24 { 1068 struct acpi_resource_memory24 {
1068 u8 write_protect; 1069 u8 write_protect;
1069 u16 minimum; 1070 u16 minimum;
1070 u16 maximum; 1071 u16 maximum;
1071 u16 alignment; 1072 u16 alignment;
1072 u16 address_length; 1073 u16 address_length;
1073 }; 1074 };
1074 1075
1075 struct acpi_resource_memory32 { 1076 struct acpi_resource_memory32 {
1076 u8 write_protect; 1077 u8 write_protect;
1077 u32 minimum; 1078 u32 minimum;
1078 u32 maximum; 1079 u32 maximum;
1079 u32 alignment; 1080 u32 alignment;
1080 u32 address_length; 1081 u32 address_length;
1081 }; 1082 };
1082 1083
1083 struct acpi_resource_fixed_memory32 { 1084 struct acpi_resource_fixed_memory32 {
1084 u8 write_protect; 1085 u8 write_protect;
1085 u32 address; 1086 u32 address;
1086 u32 address_length; 1087 u32 address_length;
1087 }; 1088 };
1088 1089
1089 struct acpi_memory_attribute { 1090 struct acpi_memory_attribute {
1090 u8 write_protect; 1091 u8 write_protect;
1091 u8 caching; 1092 u8 caching;
1092 u8 range_type; 1093 u8 range_type;
1093 u8 translation; 1094 u8 translation;
1094 }; 1095 };
1095 1096
1096 struct acpi_io_attribute { 1097 struct acpi_io_attribute {
1097 u8 range_type; 1098 u8 range_type;
1098 u8 translation; 1099 u8 translation;
1099 u8 translation_type; 1100 u8 translation_type;
1100 u8 reserved1; 1101 u8 reserved1;
1101 }; 1102 };
1102 1103
1103 union acpi_resource_attribute { 1104 union acpi_resource_attribute {
1104 struct acpi_memory_attribute mem; 1105 struct acpi_memory_attribute mem;
1105 struct acpi_io_attribute io; 1106 struct acpi_io_attribute io;
1106 1107
1107 /* Used for the *word_space macros */ 1108 /* Used for the *word_space macros */
1108 1109
1109 u8 type_specific; 1110 u8 type_specific;
1110 }; 1111 };
1111 1112
1112 struct acpi_resource_source { 1113 struct acpi_resource_source {
1113 u8 index; 1114 u8 index;
1114 u16 string_length; 1115 u16 string_length;
1115 char *string_ptr; 1116 char *string_ptr;
1116 }; 1117 };
1117 1118
1118 /* Fields common to all address descriptors, 16/32/64 bit */ 1119 /* Fields common to all address descriptors, 16/32/64 bit */
1119 1120
1120 #define ACPI_RESOURCE_ADDRESS_COMMON \ 1121 #define ACPI_RESOURCE_ADDRESS_COMMON \
1121 u8 resource_type; \ 1122 u8 resource_type; \
1122 u8 producer_consumer; \ 1123 u8 producer_consumer; \
1123 u8 decode; \ 1124 u8 decode; \
1124 u8 min_address_fixed; \ 1125 u8 min_address_fixed; \
1125 u8 max_address_fixed; \ 1126 u8 max_address_fixed; \
1126 union acpi_resource_attribute info; 1127 union acpi_resource_attribute info;
1127 1128
1128 struct acpi_resource_address { 1129 struct acpi_resource_address {
1129 ACPI_RESOURCE_ADDRESS_COMMON}; 1130 ACPI_RESOURCE_ADDRESS_COMMON};
1130 1131
1131 struct acpi_resource_address16 { 1132 struct acpi_resource_address16 {
1132 ACPI_RESOURCE_ADDRESS_COMMON u16 granularity; 1133 ACPI_RESOURCE_ADDRESS_COMMON u16 granularity;
1133 u16 minimum; 1134 u16 minimum;
1134 u16 maximum; 1135 u16 maximum;
1135 u16 translation_offset; 1136 u16 translation_offset;
1136 u16 address_length; 1137 u16 address_length;
1137 struct acpi_resource_source resource_source; 1138 struct acpi_resource_source resource_source;
1138 }; 1139 };
1139 1140
1140 struct acpi_resource_address32 { 1141 struct acpi_resource_address32 {
1141 ACPI_RESOURCE_ADDRESS_COMMON u32 granularity; 1142 ACPI_RESOURCE_ADDRESS_COMMON u32 granularity;
1142 u32 minimum; 1143 u32 minimum;
1143 u32 maximum; 1144 u32 maximum;
1144 u32 translation_offset; 1145 u32 translation_offset;
1145 u32 address_length; 1146 u32 address_length;
1146 struct acpi_resource_source resource_source; 1147 struct acpi_resource_source resource_source;
1147 }; 1148 };
1148 1149
1149 struct acpi_resource_address64 { 1150 struct acpi_resource_address64 {
1150 ACPI_RESOURCE_ADDRESS_COMMON u64 granularity; 1151 ACPI_RESOURCE_ADDRESS_COMMON u64 granularity;
1151 u64 minimum; 1152 u64 minimum;
1152 u64 maximum; 1153 u64 maximum;
1153 u64 translation_offset; 1154 u64 translation_offset;
1154 u64 address_length; 1155 u64 address_length;
1155 struct acpi_resource_source resource_source; 1156 struct acpi_resource_source resource_source;
1156 }; 1157 };
1157 1158
1158 struct acpi_resource_extended_address64 { 1159 struct acpi_resource_extended_address64 {
1159 ACPI_RESOURCE_ADDRESS_COMMON u8 revision_iD; 1160 ACPI_RESOURCE_ADDRESS_COMMON u8 revision_iD;
1160 u64 granularity; 1161 u64 granularity;
1161 u64 minimum; 1162 u64 minimum;
1162 u64 maximum; 1163 u64 maximum;
1163 u64 translation_offset; 1164 u64 translation_offset;
1164 u64 address_length; 1165 u64 address_length;
1165 u64 type_specific; 1166 u64 type_specific;
1166 }; 1167 };
1167 1168
1168 struct acpi_resource_extended_irq { 1169 struct acpi_resource_extended_irq {
1169 u8 producer_consumer; 1170 u8 producer_consumer;
1170 u8 triggering; 1171 u8 triggering;
1171 u8 polarity; 1172 u8 polarity;
1172 u8 sharable; 1173 u8 sharable;
1173 u8 interrupt_count; 1174 u8 interrupt_count;
1174 struct acpi_resource_source resource_source; 1175 struct acpi_resource_source resource_source;
1175 u32 interrupts[1]; 1176 u32 interrupts[1];
1176 }; 1177 };
1177 1178
1178 struct acpi_resource_generic_register { 1179 struct acpi_resource_generic_register {
1179 u8 space_id; 1180 u8 space_id;
1180 u8 bit_width; 1181 u8 bit_width;
1181 u8 bit_offset; 1182 u8 bit_offset;
1182 u8 access_size; 1183 u8 access_size;
1183 u64 address; 1184 u64 address;
1184 }; 1185 };
1185 1186
1186 /* ACPI_RESOURCE_TYPEs */ 1187 /* ACPI_RESOURCE_TYPEs */
1187 1188
1188 #define ACPI_RESOURCE_TYPE_IRQ 0 1189 #define ACPI_RESOURCE_TYPE_IRQ 0
1189 #define ACPI_RESOURCE_TYPE_DMA 1 1190 #define ACPI_RESOURCE_TYPE_DMA 1
1190 #define ACPI_RESOURCE_TYPE_START_DEPENDENT 2 1191 #define ACPI_RESOURCE_TYPE_START_DEPENDENT 2
1191 #define ACPI_RESOURCE_TYPE_END_DEPENDENT 3 1192 #define ACPI_RESOURCE_TYPE_END_DEPENDENT 3
1192 #define ACPI_RESOURCE_TYPE_IO 4 1193 #define ACPI_RESOURCE_TYPE_IO 4
1193 #define ACPI_RESOURCE_TYPE_FIXED_IO 5 1194 #define ACPI_RESOURCE_TYPE_FIXED_IO 5
1194 #define ACPI_RESOURCE_TYPE_VENDOR 6 1195 #define ACPI_RESOURCE_TYPE_VENDOR 6
1195 #define ACPI_RESOURCE_TYPE_END_TAG 7 1196 #define ACPI_RESOURCE_TYPE_END_TAG 7
1196 #define ACPI_RESOURCE_TYPE_MEMORY24 8 1197 #define ACPI_RESOURCE_TYPE_MEMORY24 8
1197 #define ACPI_RESOURCE_TYPE_MEMORY32 9 1198 #define ACPI_RESOURCE_TYPE_MEMORY32 9
1198 #define ACPI_RESOURCE_TYPE_FIXED_MEMORY32 10 1199 #define ACPI_RESOURCE_TYPE_FIXED_MEMORY32 10
1199 #define ACPI_RESOURCE_TYPE_ADDRESS16 11 1200 #define ACPI_RESOURCE_TYPE_ADDRESS16 11
1200 #define ACPI_RESOURCE_TYPE_ADDRESS32 12 1201 #define ACPI_RESOURCE_TYPE_ADDRESS32 12
1201 #define ACPI_RESOURCE_TYPE_ADDRESS64 13 1202 #define ACPI_RESOURCE_TYPE_ADDRESS64 13
1202 #define ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64 14 /* ACPI 3.0 */ 1203 #define ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64 14 /* ACPI 3.0 */
1203 #define ACPI_RESOURCE_TYPE_EXTENDED_IRQ 15 1204 #define ACPI_RESOURCE_TYPE_EXTENDED_IRQ 15
1204 #define ACPI_RESOURCE_TYPE_GENERIC_REGISTER 16 1205 #define ACPI_RESOURCE_TYPE_GENERIC_REGISTER 16
1205 #define ACPI_RESOURCE_TYPE_MAX 16 1206 #define ACPI_RESOURCE_TYPE_MAX 16
1206 1207
1207 union acpi_resource_data { 1208 union acpi_resource_data {
1208 struct acpi_resource_irq irq; 1209 struct acpi_resource_irq irq;
1209 struct acpi_resource_dma dma; 1210 struct acpi_resource_dma dma;
1210 struct acpi_resource_start_dependent start_dpf; 1211 struct acpi_resource_start_dependent start_dpf;
1211 struct acpi_resource_io io; 1212 struct acpi_resource_io io;
1212 struct acpi_resource_fixed_io fixed_io; 1213 struct acpi_resource_fixed_io fixed_io;
1213 struct acpi_resource_vendor vendor; 1214 struct acpi_resource_vendor vendor;
1214 struct acpi_resource_vendor_typed vendor_typed; 1215 struct acpi_resource_vendor_typed vendor_typed;
1215 struct acpi_resource_end_tag end_tag; 1216 struct acpi_resource_end_tag end_tag;
1216 struct acpi_resource_memory24 memory24; 1217 struct acpi_resource_memory24 memory24;
1217 struct acpi_resource_memory32 memory32; 1218 struct acpi_resource_memory32 memory32;
1218 struct acpi_resource_fixed_memory32 fixed_memory32; 1219 struct acpi_resource_fixed_memory32 fixed_memory32;
1219 struct acpi_resource_address16 address16; 1220 struct acpi_resource_address16 address16;
1220 struct acpi_resource_address32 address32; 1221 struct acpi_resource_address32 address32;
1221 struct acpi_resource_address64 address64; 1222 struct acpi_resource_address64 address64;
1222 struct acpi_resource_extended_address64 ext_address64; 1223 struct acpi_resource_extended_address64 ext_address64;
1223 struct acpi_resource_extended_irq extended_irq; 1224 struct acpi_resource_extended_irq extended_irq;
1224 struct acpi_resource_generic_register generic_reg; 1225 struct acpi_resource_generic_register generic_reg;
1225 1226
1226 /* Common fields */ 1227 /* Common fields */
1227 1228
1228 struct acpi_resource_address address; /* Common 16/32/64 address fields */ 1229 struct acpi_resource_address address; /* Common 16/32/64 address fields */
1229 }; 1230 };
1230 1231
1231 struct acpi_resource { 1232 struct acpi_resource {
1232 u32 type; 1233 u32 type;
1233 u32 length; 1234 u32 length;
1234 union acpi_resource_data data; 1235 union acpi_resource_data data;
1235 }; 1236 };
1236 1237
1237 /* restore default alignment */ 1238 /* restore default alignment */
1238 1239
1239 #pragma pack() 1240 #pragma pack()
1240 1241
1241 #define ACPI_RS_SIZE_NO_DATA 8 /* Id + Length fields */ 1242 #define ACPI_RS_SIZE_NO_DATA 8 /* Id + Length fields */
1242 #define ACPI_RS_SIZE_MIN (u32) ACPI_ROUND_UP_TO_NATIVE_WORD (12) 1243 #define ACPI_RS_SIZE_MIN (u32) ACPI_ROUND_UP_TO_NATIVE_WORD (12)
1243 #define ACPI_RS_SIZE(type) (u32) (ACPI_RS_SIZE_NO_DATA + sizeof (type)) 1244 #define ACPI_RS_SIZE(type) (u32) (ACPI_RS_SIZE_NO_DATA + sizeof (type))
1244 1245
1245 #define ACPI_NEXT_RESOURCE(res) (struct acpi_resource *)((u8 *) res + res->length) 1246 #define ACPI_NEXT_RESOURCE(res) (struct acpi_resource *)((u8 *) res + res->length)
1246 1247
1247 struct acpi_pci_routing_table { 1248 struct acpi_pci_routing_table {
1248 u32 length; 1249 u32 length;
1249 u32 pin; 1250 u32 pin;
1250 acpi_integer address; /* here for 64-bit alignment */ 1251 acpi_integer address; /* here for 64-bit alignment */
1251 u32 source_index; 1252 u32 source_index;
1252 char source[4]; /* pad to 64 bits so sizeof() works in all cases */ 1253 char source[4]; /* pad to 64 bits so sizeof() works in all cases */
1253 }; 1254 };
1254 1255
1255 #endif /* __ACTYPES_H__ */ 1256 #endif /* __ACTYPES_H__ */
1256 1257