]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | |
2 | /******************************************************************************* | |
3 | * | |
4 | * Module Name: hwregs - Read/write access functions for the various ACPI | |
5 | * control and status registers. | |
6 | * | |
7 | ******************************************************************************/ | |
8 | ||
9 | /* | |
75a44ce0 | 10 | * Copyright (C) 2000 - 2008, Intel Corp. |
1da177e4 LT |
11 | * All rights reserved. |
12 | * | |
13 | * Redistribution and use in source and binary forms, with or without | |
14 | * modification, are permitted provided that the following conditions | |
15 | * are met: | |
16 | * 1. Redistributions of source code must retain the above copyright | |
17 | * notice, this list of conditions, and the following disclaimer, | |
18 | * without modification. | |
19 | * 2. Redistributions in binary form must reproduce at minimum a disclaimer | |
20 | * substantially similar to the "NO WARRANTY" disclaimer below | |
21 | * ("Disclaimer") and any redistribution must be conditioned upon | |
22 | * including a substantially similar Disclaimer requirement for further | |
23 | * binary redistribution. | |
24 | * 3. Neither the names of the above-listed copyright holders nor the names | |
25 | * of any contributors may be used to endorse or promote products derived | |
26 | * from this software without specific prior written permission. | |
27 | * | |
28 | * Alternatively, this software may be distributed under the terms of the | |
29 | * GNU General Public License ("GPL") version 2 as published by the Free | |
30 | * Software Foundation. | |
31 | * | |
32 | * NO WARRANTY | |
33 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |
34 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
35 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR | |
36 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |
37 | * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | |
38 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | |
39 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | |
40 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, | |
41 | * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING | |
42 | * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE | |
43 | * POSSIBILITY OF SUCH DAMAGES. | |
44 | */ | |
45 | ||
1da177e4 LT |
46 | #include <acpi/acpi.h> |
47 | #include <acpi/acnamesp.h> | |
48 | #include <acpi/acevents.h> | |
49 | ||
50 | #define _COMPONENT ACPI_HARDWARE | |
4be44fcd | 51 | ACPI_MODULE_NAME("hwregs") |
1da177e4 LT |
52 | |
53 | /******************************************************************************* | |
54 | * | |
55 | * FUNCTION: acpi_hw_clear_acpi_status | |
56 | * | |
d8c71b6d | 57 | * PARAMETERS: None |
1da177e4 | 58 | * |
d8c71b6d | 59 | * RETURN: None |
1da177e4 LT |
60 | * |
61 | * DESCRIPTION: Clears all fixed and general purpose status bits | |
62 | * THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED | |
63 | * | |
64 | ******************************************************************************/ | |
d8c71b6d | 65 | acpi_status acpi_hw_clear_acpi_status(void) |
1da177e4 | 66 | { |
4be44fcd | 67 | acpi_status status; |
4c90ece2 | 68 | acpi_cpu_flags lock_flags = 0; |
1da177e4 | 69 | |
b229cf92 | 70 | ACPI_FUNCTION_TRACE(hw_clear_acpi_status); |
1da177e4 | 71 | |
4be44fcd LB |
72 | ACPI_DEBUG_PRINT((ACPI_DB_IO, "About to write %04X to %04X\n", |
73 | ACPI_BITMASK_ALL_FIXED_STATUS, | |
f3d2e786 | 74 | (u16) acpi_gbl_FADT.xpm1a_event_block.address)); |
1da177e4 | 75 | |
4c90ece2 | 76 | lock_flags = acpi_os_acquire_lock(acpi_gbl_hardware_lock); |
1da177e4 | 77 | |
d30dc9ab | 78 | status = acpi_hw_register_write(ACPI_REGISTER_PM1_STATUS, |
4be44fcd LB |
79 | ACPI_BITMASK_ALL_FIXED_STATUS); |
80 | if (ACPI_FAILURE(status)) { | |
1da177e4 LT |
81 | goto unlock_and_exit; |
82 | } | |
83 | ||
84 | /* Clear the fixed events */ | |
85 | ||
f3d2e786 | 86 | if (acpi_gbl_FADT.xpm1b_event_block.address) { |
ecfbbc7b BM |
87 | status = acpi_write(ACPI_BITMASK_ALL_FIXED_STATUS, |
88 | &acpi_gbl_FADT.xpm1b_event_block); | |
4be44fcd | 89 | if (ACPI_FAILURE(status)) { |
1da177e4 LT |
90 | goto unlock_and_exit; |
91 | } | |
92 | } | |
93 | ||
94 | /* Clear the GPE Bits in all GPE registers in all GPE blocks */ | |
95 | ||
e97d6bf1 | 96 | status = acpi_ev_walk_gpe_list(acpi_hw_clear_gpe_block, NULL); |
1da177e4 | 97 | |
4be44fcd | 98 | unlock_and_exit: |
4c90ece2 | 99 | acpi_os_release_lock(acpi_gbl_hardware_lock, lock_flags); |
4be44fcd | 100 | return_ACPI_STATUS(status); |
1da177e4 LT |
101 | } |
102 | ||
1da177e4 LT |
103 | /******************************************************************************* |
104 | * | |
105 | * FUNCTION: acpi_get_sleep_type_data | |
106 | * | |
107 | * PARAMETERS: sleep_state - Numeric sleep state | |
108 | * *sleep_type_a - Where SLP_TYPa is returned | |
109 | * *sleep_type_b - Where SLP_TYPb is returned | |
110 | * | |
111 | * RETURN: Status - ACPI status | |
112 | * | |
113 | * DESCRIPTION: Obtain the SLP_TYPa and SLP_TYPb values for the requested sleep | |
114 | * state. | |
115 | * | |
116 | ******************************************************************************/ | |
117 | ||
118 | acpi_status | |
4be44fcd | 119 | acpi_get_sleep_type_data(u8 sleep_state, u8 * sleep_type_a, u8 * sleep_type_b) |
1da177e4 | 120 | { |
4be44fcd | 121 | acpi_status status = AE_OK; |
4119532c | 122 | struct acpi_evaluate_info *info; |
1da177e4 | 123 | |
b229cf92 | 124 | ACPI_FUNCTION_TRACE(acpi_get_sleep_type_data); |
1da177e4 | 125 | |
44f6c012 RM |
126 | /* Validate parameters */ |
127 | ||
4be44fcd LB |
128 | if ((sleep_state > ACPI_S_STATES_MAX) || !sleep_type_a || !sleep_type_b) { |
129 | return_ACPI_STATUS(AE_BAD_PARAMETER); | |
1da177e4 LT |
130 | } |
131 | ||
4119532c BM |
132 | /* Allocate the evaluation information block */ |
133 | ||
134 | info = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_evaluate_info)); | |
135 | if (!info) { | |
136 | return_ACPI_STATUS(AE_NO_MEMORY); | |
137 | } | |
44f6c012 | 138 | |
4119532c | 139 | info->pathname = |
defba1d8 | 140 | ACPI_CAST_PTR(char, acpi_gbl_sleep_state_names[sleep_state]); |
44f6c012 | 141 | |
4119532c BM |
142 | /* Evaluate the namespace object containing the values for this state */ |
143 | ||
144 | status = acpi_ns_evaluate(info); | |
4be44fcd LB |
145 | if (ACPI_FAILURE(status)) { |
146 | ACPI_DEBUG_PRINT((ACPI_DB_EXEC, | |
b229cf92 | 147 | "%s while evaluating SleepState [%s]\n", |
4be44fcd | 148 | acpi_format_exception(status), |
4119532c | 149 | info->pathname)); |
1da177e4 | 150 | |
4119532c | 151 | goto cleanup; |
1da177e4 LT |
152 | } |
153 | ||
154 | /* Must have a return object */ | |
155 | ||
4119532c | 156 | if (!info->return_object) { |
b8e4d893 | 157 | ACPI_ERROR((AE_INFO, "No Sleep State object returned from [%s]", |
4119532c | 158 | info->pathname)); |
1da177e4 LT |
159 | status = AE_NOT_EXIST; |
160 | } | |
161 | ||
162 | /* It must be of type Package */ | |
163 | ||
4119532c | 164 | else if (ACPI_GET_OBJECT_TYPE(info->return_object) != ACPI_TYPE_PACKAGE) { |
b8e4d893 BM |
165 | ACPI_ERROR((AE_INFO, |
166 | "Sleep State return object is not a Package")); | |
1da177e4 LT |
167 | status = AE_AML_OPERAND_TYPE; |
168 | } | |
169 | ||
44f6c012 | 170 | /* |
967440e3 | 171 | * The package must have at least two elements. NOTE (March 2005): This |
44f6c012 | 172 | * goes against the current ACPI spec which defines this object as a |
967440e3 | 173 | * package with one encoded DWORD element. However, existing practice |
44f6c012 RM |
174 | * by BIOS vendors seems to be to have 2 or more elements, at least |
175 | * one per sleep type (A/B). | |
176 | */ | |
4119532c | 177 | else if (info->return_object->package.count < 2) { |
b8e4d893 BM |
178 | ACPI_ERROR((AE_INFO, |
179 | "Sleep State return package does not have at least two elements")); | |
1da177e4 LT |
180 | status = AE_AML_NO_OPERAND; |
181 | } | |
182 | ||
183 | /* The first two elements must both be of type Integer */ | |
184 | ||
4119532c | 185 | else if ((ACPI_GET_OBJECT_TYPE(info->return_object->package.elements[0]) |
4be44fcd | 186 | != ACPI_TYPE_INTEGER) || |
4119532c | 187 | (ACPI_GET_OBJECT_TYPE(info->return_object->package.elements[1]) |
4be44fcd | 188 | != ACPI_TYPE_INTEGER)) { |
b8e4d893 BM |
189 | ACPI_ERROR((AE_INFO, |
190 | "Sleep State return package elements are not both Integers (%s, %s)", | |
4119532c | 191 | acpi_ut_get_object_type_name(info->return_object-> |
b8e4d893 | 192 | package.elements[0]), |
4119532c | 193 | acpi_ut_get_object_type_name(info->return_object-> |
b8e4d893 | 194 | package.elements[1]))); |
1da177e4 | 195 | status = AE_AML_OPERAND_TYPE; |
4be44fcd | 196 | } else { |
44f6c012 RM |
197 | /* Valid _Sx_ package size, type, and value */ |
198 | ||
199 | *sleep_type_a = (u8) | |
4119532c | 200 | (info->return_object->package.elements[0])->integer.value; |
44f6c012 | 201 | *sleep_type_b = (u8) |
4119532c | 202 | (info->return_object->package.elements[1])->integer.value; |
1da177e4 LT |
203 | } |
204 | ||
4be44fcd | 205 | if (ACPI_FAILURE(status)) { |
b8e4d893 | 206 | ACPI_EXCEPTION((AE_INFO, status, |
b229cf92 | 207 | "While evaluating SleepState [%s], bad Sleep object %p type %s", |
4119532c BM |
208 | info->pathname, info->return_object, |
209 | acpi_ut_get_object_type_name(info-> | |
b8e4d893 | 210 | return_object))); |
1da177e4 LT |
211 | } |
212 | ||
4119532c BM |
213 | acpi_ut_remove_reference(info->return_object); |
214 | ||
215 | cleanup: | |
216 | ACPI_FREE(info); | |
4be44fcd | 217 | return_ACPI_STATUS(status); |
1da177e4 | 218 | } |
1da177e4 | 219 | |
8313524a | 220 | ACPI_EXPORT_SYMBOL(acpi_get_sleep_type_data) |
1da177e4 LT |
221 | |
222 | /******************************************************************************* | |
223 | * | |
224 | * FUNCTION: acpi_hw_get_register_bit_mask | |
225 | * | |
226 | * PARAMETERS: register_id - Index of ACPI Register to access | |
227 | * | |
44f6c012 | 228 | * RETURN: The bitmask to be used when accessing the register |
1da177e4 | 229 | * |
44f6c012 | 230 | * DESCRIPTION: Map register_id into a register bitmask. |
1da177e4 LT |
231 | * |
232 | ******************************************************************************/ | |
4be44fcd | 233 | struct acpi_bit_register_info *acpi_hw_get_bit_register_info(u32 register_id) |
1da177e4 | 234 | { |
4a90c7e8 | 235 | ACPI_FUNCTION_ENTRY(); |
1da177e4 LT |
236 | |
237 | if (register_id > ACPI_BITREG_MAX) { | |
b229cf92 | 238 | ACPI_ERROR((AE_INFO, "Invalid BitRegister ID: %X", |
b8e4d893 | 239 | register_id)); |
1da177e4 LT |
240 | return (NULL); |
241 | } | |
242 | ||
243 | return (&acpi_gbl_bit_register_info[register_id]); | |
244 | } | |
245 | ||
ecfbbc7b BM |
246 | ACPI_EXPORT_SYMBOL(acpi_get_register_unlocked) |
247 | ||
1da177e4 LT |
248 | /******************************************************************************* |
249 | * | |
250 | * FUNCTION: acpi_get_register | |
251 | * | |
252 | * PARAMETERS: register_id - ID of ACPI bit_register to access | |
253 | * return_value - Value that was read from the register | |
1da177e4 | 254 | * |
967440e3 | 255 | * RETURN: Status and the value read from specified Register. Value |
1da177e4 LT |
256 | * returned is normalized to bit0 (is shifted all the way right) |
257 | * | |
258 | * DESCRIPTION: ACPI bit_register read function. | |
259 | * | |
260 | ******************************************************************************/ | |
261 | ||
d30dc9ab | 262 | acpi_status acpi_get_register_unlocked(u32 register_id, u32 * return_value) |
1da177e4 | 263 | { |
4be44fcd LB |
264 | u32 register_value = 0; |
265 | struct acpi_bit_register_info *bit_reg_info; | |
266 | acpi_status status; | |
1da177e4 | 267 | |
b229cf92 | 268 | ACPI_FUNCTION_TRACE(acpi_get_register); |
1da177e4 LT |
269 | |
270 | /* Get the info structure corresponding to the requested ACPI Register */ | |
271 | ||
4be44fcd | 272 | bit_reg_info = acpi_hw_get_bit_register_info(register_id); |
1da177e4 | 273 | if (!bit_reg_info) { |
4be44fcd | 274 | return_ACPI_STATUS(AE_BAD_PARAMETER); |
1da177e4 LT |
275 | } |
276 | ||
1da177e4 LT |
277 | /* Read from the register */ |
278 | ||
d30dc9ab | 279 | status = acpi_hw_register_read(bit_reg_info->parent_register, |
4be44fcd | 280 | ®ister_value); |
1da177e4 | 281 | |
4be44fcd | 282 | if (ACPI_SUCCESS(status)) { |
52fc0b02 | 283 | |
1da177e4 LT |
284 | /* Normalize the value that was read */ |
285 | ||
4be44fcd LB |
286 | register_value = |
287 | ((register_value & bit_reg_info->access_bit_mask) | |
288 | >> bit_reg_info->bit_position); | |
1da177e4 LT |
289 | |
290 | *return_value = register_value; | |
291 | ||
4be44fcd LB |
292 | ACPI_DEBUG_PRINT((ACPI_DB_IO, "Read value %8.8X register %X\n", |
293 | register_value, | |
294 | bit_reg_info->parent_register)); | |
1da177e4 LT |
295 | } |
296 | ||
4be44fcd | 297 | return_ACPI_STATUS(status); |
1da177e4 | 298 | } |
1da177e4 | 299 | |
d30dc9ab AS |
300 | acpi_status acpi_get_register(u32 register_id, u32 * return_value) |
301 | { | |
302 | acpi_status status; | |
303 | acpi_cpu_flags flags; | |
304 | flags = acpi_os_acquire_lock(acpi_gbl_hardware_lock); | |
305 | status = acpi_get_register_unlocked(register_id, return_value); | |
306 | acpi_os_release_lock(acpi_gbl_hardware_lock, flags); | |
307 | return status; | |
308 | } | |
309 | ||
8313524a | 310 | ACPI_EXPORT_SYMBOL(acpi_get_register) |
1da177e4 LT |
311 | |
312 | /******************************************************************************* | |
313 | * | |
314 | * FUNCTION: acpi_set_register | |
315 | * | |
316 | * PARAMETERS: register_id - ID of ACPI bit_register to access | |
317 | * Value - (only used on write) value to write to the | |
318 | * Register, NOT pre-normalized to the bit pos | |
1da177e4 LT |
319 | * |
320 | * RETURN: Status | |
321 | * | |
322 | * DESCRIPTION: ACPI Bit Register write function. | |
323 | * | |
324 | ******************************************************************************/ | |
d8c71b6d | 325 | acpi_status acpi_set_register(u32 register_id, u32 value) |
1da177e4 | 326 | { |
4be44fcd LB |
327 | u32 register_value = 0; |
328 | struct acpi_bit_register_info *bit_reg_info; | |
329 | acpi_status status; | |
4c90ece2 | 330 | acpi_cpu_flags lock_flags; |
1da177e4 | 331 | |
b229cf92 | 332 | ACPI_FUNCTION_TRACE_U32(acpi_set_register, register_id); |
1da177e4 LT |
333 | |
334 | /* Get the info structure corresponding to the requested ACPI Register */ | |
335 | ||
4be44fcd | 336 | bit_reg_info = acpi_hw_get_bit_register_info(register_id); |
1da177e4 | 337 | if (!bit_reg_info) { |
b229cf92 | 338 | ACPI_ERROR((AE_INFO, "Bad ACPI HW RegisterId: %X", |
b8e4d893 | 339 | register_id)); |
4be44fcd | 340 | return_ACPI_STATUS(AE_BAD_PARAMETER); |
1da177e4 LT |
341 | } |
342 | ||
4c90ece2 | 343 | lock_flags = acpi_os_acquire_lock(acpi_gbl_hardware_lock); |
1da177e4 LT |
344 | |
345 | /* Always do a register read first so we can insert the new bits */ | |
346 | ||
d30dc9ab | 347 | status = acpi_hw_register_read(bit_reg_info->parent_register, |
4be44fcd LB |
348 | ®ister_value); |
349 | if (ACPI_FAILURE(status)) { | |
1da177e4 LT |
350 | goto unlock_and_exit; |
351 | } | |
352 | ||
353 | /* | |
354 | * Decode the Register ID | |
355 | * Register ID = [Register block ID] | [bit ID] | |
356 | * | |
357 | * Check bit ID to fine locate Register offset. | |
358 | * Check Mask to determine Register offset, and then read-write. | |
359 | */ | |
360 | switch (bit_reg_info->parent_register) { | |
361 | case ACPI_REGISTER_PM1_STATUS: | |
362 | ||
363 | /* | |
967440e3 BM |
364 | * Status Registers are different from the rest. Clear by |
365 | * writing 1, and writing 0 has no effect. So, the only relevant | |
1da177e4 LT |
366 | * information is the single bit we're interested in, all others should |
367 | * be written as 0 so they will be left unchanged. | |
368 | */ | |
4be44fcd LB |
369 | value = ACPI_REGISTER_PREPARE_BITS(value, |
370 | bit_reg_info->bit_position, | |
371 | bit_reg_info-> | |
372 | access_bit_mask); | |
1da177e4 | 373 | if (value) { |
d30dc9ab | 374 | status = acpi_hw_register_write(ACPI_REGISTER_PM1_STATUS, |
4be44fcd | 375 | (u16) value); |
1da177e4 LT |
376 | register_value = 0; |
377 | } | |
378 | break; | |
379 | ||
1da177e4 LT |
380 | case ACPI_REGISTER_PM1_ENABLE: |
381 | ||
4be44fcd LB |
382 | ACPI_REGISTER_INSERT_VALUE(register_value, |
383 | bit_reg_info->bit_position, | |
384 | bit_reg_info->access_bit_mask, | |
385 | value); | |
1da177e4 | 386 | |
d30dc9ab | 387 | status = acpi_hw_register_write(ACPI_REGISTER_PM1_ENABLE, |
4be44fcd | 388 | (u16) register_value); |
1da177e4 LT |
389 | break; |
390 | ||
1da177e4 LT |
391 | case ACPI_REGISTER_PM1_CONTROL: |
392 | ||
393 | /* | |
394 | * Write the PM1 Control register. | |
395 | * Note that at this level, the fact that there are actually TWO | |
396 | * registers (A and B - and B may not exist) is abstracted. | |
397 | */ | |
4be44fcd LB |
398 | ACPI_DEBUG_PRINT((ACPI_DB_IO, "PM1 control: Read %X\n", |
399 | register_value)); | |
1da177e4 | 400 | |
4be44fcd LB |
401 | ACPI_REGISTER_INSERT_VALUE(register_value, |
402 | bit_reg_info->bit_position, | |
403 | bit_reg_info->access_bit_mask, | |
404 | value); | |
1da177e4 | 405 | |
d30dc9ab | 406 | status = acpi_hw_register_write(ACPI_REGISTER_PM1_CONTROL, |
4be44fcd | 407 | (u16) register_value); |
1da177e4 LT |
408 | break; |
409 | ||
1da177e4 LT |
410 | case ACPI_REGISTER_PM2_CONTROL: |
411 | ||
d30dc9ab | 412 | status = acpi_hw_register_read(ACPI_REGISTER_PM2_CONTROL, |
4be44fcd LB |
413 | ®ister_value); |
414 | if (ACPI_FAILURE(status)) { | |
1da177e4 LT |
415 | goto unlock_and_exit; |
416 | } | |
417 | ||
4be44fcd LB |
418 | ACPI_DEBUG_PRINT((ACPI_DB_IO, |
419 | "PM2 control: Read %X from %8.8X%8.8X\n", | |
420 | register_value, | |
f3d2e786 BM |
421 | ACPI_FORMAT_UINT64(acpi_gbl_FADT. |
422 | xpm2_control_block. | |
423 | address))); | |
4be44fcd LB |
424 | |
425 | ACPI_REGISTER_INSERT_VALUE(register_value, | |
426 | bit_reg_info->bit_position, | |
427 | bit_reg_info->access_bit_mask, | |
428 | value); | |
429 | ||
430 | ACPI_DEBUG_PRINT((ACPI_DB_IO, | |
431 | "About to write %4.4X to %8.8X%8.8X\n", | |
432 | register_value, | |
f3d2e786 BM |
433 | ACPI_FORMAT_UINT64(acpi_gbl_FADT. |
434 | xpm2_control_block. | |
435 | address))); | |
4be44fcd | 436 | |
d30dc9ab | 437 | status = acpi_hw_register_write(ACPI_REGISTER_PM2_CONTROL, |
4be44fcd | 438 | (u8) (register_value)); |
1da177e4 LT |
439 | break; |
440 | ||
1da177e4 LT |
441 | default: |
442 | break; | |
443 | } | |
444 | ||
4be44fcd | 445 | unlock_and_exit: |
1da177e4 | 446 | |
4c90ece2 | 447 | acpi_os_release_lock(acpi_gbl_hardware_lock, lock_flags); |
1da177e4 LT |
448 | |
449 | /* Normalize the value that was read */ | |
450 | ||
4be44fcd LB |
451 | ACPI_DEBUG_EXEC(register_value = |
452 | ((register_value & bit_reg_info->access_bit_mask) >> | |
453 | bit_reg_info->bit_position)); | |
1da177e4 | 454 | |
4be44fcd LB |
455 | ACPI_DEBUG_PRINT((ACPI_DB_IO, |
456 | "Set bits: %8.8X actual %8.8X register %X\n", value, | |
457 | register_value, bit_reg_info->parent_register)); | |
458 | return_ACPI_STATUS(status); | |
1da177e4 | 459 | } |
1da177e4 | 460 | |
8313524a | 461 | ACPI_EXPORT_SYMBOL(acpi_set_register) |
1da177e4 LT |
462 | |
463 | /****************************************************************************** | |
464 | * | |
465 | * FUNCTION: acpi_hw_register_read | |
466 | * | |
d30dc9ab | 467 | * PARAMETERS: register_id - ACPI Register ID |
44f6c012 | 468 | * return_value - Where the register value is returned |
1da177e4 LT |
469 | * |
470 | * RETURN: Status and the value read. | |
471 | * | |
967440e3 | 472 | * DESCRIPTION: Read from the specified ACPI register |
1da177e4 LT |
473 | * |
474 | ******************************************************************************/ | |
1da177e4 | 475 | acpi_status |
d30dc9ab | 476 | acpi_hw_register_read(u32 register_id, u32 * return_value) |
1da177e4 | 477 | { |
4be44fcd LB |
478 | u32 value1 = 0; |
479 | u32 value2 = 0; | |
480 | acpi_status status; | |
1da177e4 | 481 | |
b229cf92 | 482 | ACPI_FUNCTION_TRACE(hw_register_read); |
1da177e4 | 483 | |
1da177e4 | 484 | switch (register_id) { |
4be44fcd | 485 | case ACPI_REGISTER_PM1_STATUS: /* 16-bit access */ |
1da177e4 | 486 | |
ecfbbc7b | 487 | status = acpi_read(&value1, &acpi_gbl_FADT.xpm1a_event_block); |
4be44fcd | 488 | if (ACPI_FAILURE(status)) { |
d30dc9ab | 489 | goto exit; |
1da177e4 LT |
490 | } |
491 | ||
492 | /* PM1B is optional */ | |
493 | ||
ecfbbc7b | 494 | status = acpi_read(&value2, &acpi_gbl_FADT.xpm1b_event_block); |
1da177e4 LT |
495 | value1 |= value2; |
496 | break; | |
497 | ||
4be44fcd | 498 | case ACPI_REGISTER_PM1_ENABLE: /* 16-bit access */ |
1da177e4 | 499 | |
ecfbbc7b | 500 | status = acpi_read(&value1, &acpi_gbl_xpm1a_enable); |
4be44fcd | 501 | if (ACPI_FAILURE(status)) { |
d30dc9ab | 502 | goto exit; |
1da177e4 LT |
503 | } |
504 | ||
505 | /* PM1B is optional */ | |
506 | ||
ecfbbc7b | 507 | status = acpi_read(&value2, &acpi_gbl_xpm1b_enable); |
1da177e4 LT |
508 | value1 |= value2; |
509 | break; | |
510 | ||
4be44fcd | 511 | case ACPI_REGISTER_PM1_CONTROL: /* 16-bit access */ |
1da177e4 | 512 | |
ecfbbc7b | 513 | status = acpi_read(&value1, &acpi_gbl_FADT.xpm1a_control_block); |
4be44fcd | 514 | if (ACPI_FAILURE(status)) { |
d30dc9ab | 515 | goto exit; |
1da177e4 LT |
516 | } |
517 | ||
ecfbbc7b | 518 | status = acpi_read(&value2, &acpi_gbl_FADT.xpm1b_control_block); |
1da177e4 LT |
519 | value1 |= value2; |
520 | break; | |
521 | ||
4be44fcd | 522 | case ACPI_REGISTER_PM2_CONTROL: /* 8-bit access */ |
1da177e4 | 523 | |
ecfbbc7b | 524 | status = acpi_read(&value1, &acpi_gbl_FADT.xpm2_control_block); |
1da177e4 LT |
525 | break; |
526 | ||
4be44fcd | 527 | case ACPI_REGISTER_PM_TIMER: /* 32-bit access */ |
1da177e4 | 528 | |
ecfbbc7b | 529 | status = acpi_read(&value1, &acpi_gbl_FADT.xpm_timer_block); |
1da177e4 LT |
530 | break; |
531 | ||
4be44fcd | 532 | case ACPI_REGISTER_SMI_COMMAND_BLOCK: /* 8-bit access */ |
1da177e4 | 533 | |
f3d2e786 BM |
534 | status = |
535 | acpi_os_read_port(acpi_gbl_FADT.smi_command, &value1, 8); | |
1da177e4 LT |
536 | break; |
537 | ||
538 | default: | |
b8e4d893 | 539 | ACPI_ERROR((AE_INFO, "Unknown Register ID: %X", register_id)); |
1da177e4 LT |
540 | status = AE_BAD_PARAMETER; |
541 | break; | |
542 | } | |
543 | ||
d30dc9ab | 544 | exit: |
1da177e4 | 545 | |
4be44fcd | 546 | if (ACPI_SUCCESS(status)) { |
1da177e4 LT |
547 | *return_value = value1; |
548 | } | |
549 | ||
4be44fcd | 550 | return_ACPI_STATUS(status); |
1da177e4 LT |
551 | } |
552 | ||
1da177e4 LT |
553 | /****************************************************************************** |
554 | * | |
555 | * FUNCTION: acpi_hw_register_write | |
556 | * | |
d30dc9ab | 557 | * PARAMETERS: register_id - ACPI Register ID |
1da177e4 LT |
558 | * Value - The value to write |
559 | * | |
560 | * RETURN: Status | |
561 | * | |
967440e3 BM |
562 | * DESCRIPTION: Write to the specified ACPI register |
563 | * | |
564 | * NOTE: In accordance with the ACPI specification, this function automatically | |
565 | * preserves the value of the following bits, meaning that these bits cannot be | |
566 | * changed via this interface: | |
567 | * | |
568 | * PM1_CONTROL[0] = SCI_EN | |
569 | * PM1_CONTROL[9] | |
570 | * PM1_STATUS[11] | |
571 | * | |
572 | * ACPI References: | |
573 | * 1) Hardware Ignored Bits: When software writes to a register with ignored | |
574 | * bit fields, it preserves the ignored bit fields | |
575 | * 2) SCI_EN: OSPM always preserves this bit position | |
1da177e4 LT |
576 | * |
577 | ******************************************************************************/ | |
578 | ||
d30dc9ab | 579 | acpi_status acpi_hw_register_write(u32 register_id, u32 value) |
1da177e4 | 580 | { |
4be44fcd | 581 | acpi_status status; |
967440e3 | 582 | u32 read_value; |
1da177e4 | 583 | |
b229cf92 | 584 | ACPI_FUNCTION_TRACE(hw_register_write); |
1da177e4 | 585 | |
1da177e4 | 586 | switch (register_id) { |
4be44fcd | 587 | case ACPI_REGISTER_PM1_STATUS: /* 16-bit access */ |
1da177e4 | 588 | |
967440e3 BM |
589 | /* Perform a read first to preserve certain bits (per ACPI spec) */ |
590 | ||
d30dc9ab | 591 | status = acpi_hw_register_read(ACPI_REGISTER_PM1_STATUS, |
967440e3 BM |
592 | &read_value); |
593 | if (ACPI_FAILURE(status)) { | |
d30dc9ab | 594 | goto exit; |
967440e3 BM |
595 | } |
596 | ||
597 | /* Insert the bits to be preserved */ | |
598 | ||
599 | ACPI_INSERT_BITS(value, ACPI_PM1_STATUS_PRESERVED_BITS, | |
600 | read_value); | |
601 | ||
602 | /* Now we can write the data */ | |
603 | ||
ecfbbc7b | 604 | status = acpi_write(value, &acpi_gbl_FADT.xpm1a_event_block); |
4be44fcd | 605 | if (ACPI_FAILURE(status)) { |
d30dc9ab | 606 | goto exit; |
1da177e4 LT |
607 | } |
608 | ||
609 | /* PM1B is optional */ | |
610 | ||
ecfbbc7b | 611 | status = acpi_write(value, &acpi_gbl_FADT.xpm1b_event_block); |
1da177e4 LT |
612 | break; |
613 | ||
4be44fcd | 614 | case ACPI_REGISTER_PM1_ENABLE: /* 16-bit access */ |
1da177e4 | 615 | |
ecfbbc7b | 616 | status = acpi_write(value, &acpi_gbl_xpm1a_enable); |
4be44fcd | 617 | if (ACPI_FAILURE(status)) { |
d30dc9ab | 618 | goto exit; |
1da177e4 LT |
619 | } |
620 | ||
621 | /* PM1B is optional */ | |
622 | ||
ecfbbc7b | 623 | status = acpi_write(value, &acpi_gbl_xpm1b_enable); |
1da177e4 LT |
624 | break; |
625 | ||
4be44fcd | 626 | case ACPI_REGISTER_PM1_CONTROL: /* 16-bit access */ |
1da177e4 | 627 | |
967440e3 BM |
628 | /* |
629 | * Perform a read first to preserve certain bits (per ACPI spec) | |
967440e3 | 630 | */ |
d30dc9ab | 631 | status = acpi_hw_register_read(ACPI_REGISTER_PM1_CONTROL, |
967440e3 BM |
632 | &read_value); |
633 | if (ACPI_FAILURE(status)) { | |
d30dc9ab | 634 | goto exit; |
967440e3 BM |
635 | } |
636 | ||
637 | /* Insert the bits to be preserved */ | |
638 | ||
639 | ACPI_INSERT_BITS(value, ACPI_PM1_CONTROL_PRESERVED_BITS, | |
640 | read_value); | |
641 | ||
642 | /* Now we can write the data */ | |
643 | ||
ecfbbc7b | 644 | status = acpi_write(value, &acpi_gbl_FADT.xpm1a_control_block); |
4be44fcd | 645 | if (ACPI_FAILURE(status)) { |
d30dc9ab | 646 | goto exit; |
1da177e4 LT |
647 | } |
648 | ||
ecfbbc7b | 649 | status = acpi_write(value, &acpi_gbl_FADT.xpm1b_control_block); |
1da177e4 LT |
650 | break; |
651 | ||
4be44fcd | 652 | case ACPI_REGISTER_PM1A_CONTROL: /* 16-bit access */ |
1da177e4 | 653 | |
ecfbbc7b | 654 | status = acpi_write(value, &acpi_gbl_FADT.xpm1a_control_block); |
1da177e4 LT |
655 | break; |
656 | ||
4be44fcd | 657 | case ACPI_REGISTER_PM1B_CONTROL: /* 16-bit access */ |
1da177e4 | 658 | |
ecfbbc7b | 659 | status = acpi_write(value, &acpi_gbl_FADT.xpm1b_control_block); |
1da177e4 LT |
660 | break; |
661 | ||
4be44fcd | 662 | case ACPI_REGISTER_PM2_CONTROL: /* 8-bit access */ |
1da177e4 | 663 | |
ecfbbc7b | 664 | status = acpi_write(value, &acpi_gbl_FADT.xpm2_control_block); |
1da177e4 LT |
665 | break; |
666 | ||
4be44fcd | 667 | case ACPI_REGISTER_PM_TIMER: /* 32-bit access */ |
1da177e4 | 668 | |
ecfbbc7b | 669 | status = acpi_write(value, &acpi_gbl_FADT.xpm_timer_block); |
1da177e4 LT |
670 | break; |
671 | ||
4be44fcd | 672 | case ACPI_REGISTER_SMI_COMMAND_BLOCK: /* 8-bit access */ |
1da177e4 LT |
673 | |
674 | /* SMI_CMD is currently always in IO space */ | |
675 | ||
f3d2e786 BM |
676 | status = |
677 | acpi_os_write_port(acpi_gbl_FADT.smi_command, value, 8); | |
1da177e4 LT |
678 | break; |
679 | ||
1da177e4 LT |
680 | default: |
681 | status = AE_BAD_PARAMETER; | |
682 | break; | |
683 | } | |
684 | ||
d30dc9ab | 685 | exit: |
4be44fcd | 686 | return_ACPI_STATUS(status); |
1da177e4 LT |
687 | } |
688 | ||
1da177e4 LT |
689 | /****************************************************************************** |
690 | * | |
ecfbbc7b | 691 | * FUNCTION: acpi_read |
1da177e4 | 692 | * |
ecfbbc7b | 693 | * PARAMETERS: Value - Where the value is returned |
1da177e4 LT |
694 | * Reg - GAS register structure |
695 | * | |
696 | * RETURN: Status | |
697 | * | |
698 | * DESCRIPTION: Read from either memory or IO space. | |
699 | * | |
700 | ******************************************************************************/ | |
701 | ||
ecfbbc7b | 702 | acpi_status acpi_read(u32 *value, struct acpi_generic_address *reg) |
1da177e4 | 703 | { |
ecfbbc7b | 704 | u32 width; |
4be44fcd LB |
705 | u64 address; |
706 | acpi_status status; | |
1da177e4 | 707 | |
ecfbbc7b | 708 | ACPI_FUNCTION_NAME(acpi_read); |
1da177e4 LT |
709 | |
710 | /* | |
711 | * Must have a valid pointer to a GAS structure, and | |
712 | * a non-zero address within. However, don't return an error | |
713 | * because the PM1A/B code must not fail if B isn't present. | |
714 | */ | |
715 | if (!reg) { | |
716 | return (AE_OK); | |
717 | } | |
718 | ||
967440e3 | 719 | /* Get a local copy of the address. Handles possible alignment issues */ |
1da177e4 | 720 | |
4be44fcd | 721 | ACPI_MOVE_64_TO_64(&address, ®->address); |
1da177e4 LT |
722 | if (!address) { |
723 | return (AE_OK); | |
724 | } | |
ecfbbc7b BM |
725 | |
726 | /* Supported widths are 8/16/32 */ | |
727 | ||
728 | width = reg->bit_width; | |
729 | if ((width != 8) && (width != 16) && (width != 32)) { | |
730 | return (AE_SUPPORT); | |
731 | } | |
732 | ||
733 | /* Initialize entire 32-bit return value to zero */ | |
734 | ||
1da177e4 LT |
735 | *value = 0; |
736 | ||
737 | /* | |
738 | * Two address spaces supported: Memory or IO. | |
739 | * PCI_Config is not supported here because the GAS struct is insufficient | |
740 | */ | |
f3d2e786 | 741 | switch (reg->space_id) { |
1da177e4 LT |
742 | case ACPI_ADR_SPACE_SYSTEM_MEMORY: |
743 | ||
4be44fcd LB |
744 | status = acpi_os_read_memory((acpi_physical_address) address, |
745 | value, width); | |
1da177e4 LT |
746 | break; |
747 | ||
1da177e4 LT |
748 | case ACPI_ADR_SPACE_SYSTEM_IO: |
749 | ||
59fa8505 BM |
750 | status = |
751 | acpi_os_read_port((acpi_io_address) address, value, width); | |
1da177e4 LT |
752 | break; |
753 | ||
1da177e4 | 754 | default: |
b8e4d893 | 755 | ACPI_ERROR((AE_INFO, |
f3d2e786 | 756 | "Unsupported address space: %X", reg->space_id)); |
1da177e4 LT |
757 | return (AE_BAD_PARAMETER); |
758 | } | |
759 | ||
4be44fcd LB |
760 | ACPI_DEBUG_PRINT((ACPI_DB_IO, |
761 | "Read: %8.8X width %2d from %8.8X%8.8X (%s)\n", | |
59fa8505 | 762 | *value, width, ACPI_FORMAT_UINT64(address), |
f3d2e786 | 763 | acpi_ut_get_region_name(reg->space_id))); |
1da177e4 LT |
764 | |
765 | return (status); | |
766 | } | |
767 | ||
ecfbbc7b BM |
768 | ACPI_EXPORT_SYMBOL(acpi_read) |
769 | ||
1da177e4 LT |
770 | /****************************************************************************** |
771 | * | |
ecfbbc7b | 772 | * FUNCTION: acpi_write |
1da177e4 | 773 | * |
ecfbbc7b | 774 | * PARAMETERS: Value - To be written |
1da177e4 LT |
775 | * Reg - GAS register structure |
776 | * | |
777 | * RETURN: Status | |
778 | * | |
779 | * DESCRIPTION: Write to either memory or IO space. | |
780 | * | |
781 | ******************************************************************************/ | |
782 | ||
783 | acpi_status | |
ecfbbc7b | 784 | acpi_write(u32 value, struct acpi_generic_address *reg) |
1da177e4 | 785 | { |
ecfbbc7b | 786 | u32 width; |
4be44fcd LB |
787 | u64 address; |
788 | acpi_status status; | |
1da177e4 | 789 | |
ecfbbc7b | 790 | ACPI_FUNCTION_NAME(acpi_write); |
1da177e4 LT |
791 | |
792 | /* | |
793 | * Must have a valid pointer to a GAS structure, and | |
794 | * a non-zero address within. However, don't return an error | |
795 | * because the PM1A/B code must not fail if B isn't present. | |
796 | */ | |
797 | if (!reg) { | |
798 | return (AE_OK); | |
799 | } | |
800 | ||
967440e3 | 801 | /* Get a local copy of the address. Handles possible alignment issues */ |
1da177e4 | 802 | |
4be44fcd | 803 | ACPI_MOVE_64_TO_64(&address, ®->address); |
1da177e4 LT |
804 | if (!address) { |
805 | return (AE_OK); | |
806 | } | |
807 | ||
ecfbbc7b BM |
808 | /* Supported widths are 8/16/32 */ |
809 | ||
810 | width = reg->bit_width; | |
811 | if ((width != 8) && (width != 16) && (width != 32)) { | |
812 | return (AE_SUPPORT); | |
813 | } | |
814 | ||
1da177e4 LT |
815 | /* |
816 | * Two address spaces supported: Memory or IO. | |
817 | * PCI_Config is not supported here because the GAS struct is insufficient | |
818 | */ | |
f3d2e786 | 819 | switch (reg->space_id) { |
1da177e4 LT |
820 | case ACPI_ADR_SPACE_SYSTEM_MEMORY: |
821 | ||
4be44fcd LB |
822 | status = acpi_os_write_memory((acpi_physical_address) address, |
823 | value, width); | |
1da177e4 LT |
824 | break; |
825 | ||
1da177e4 LT |
826 | case ACPI_ADR_SPACE_SYSTEM_IO: |
827 | ||
59fa8505 BM |
828 | status = acpi_os_write_port((acpi_io_address) address, value, |
829 | width); | |
1da177e4 LT |
830 | break; |
831 | ||
1da177e4 | 832 | default: |
b8e4d893 | 833 | ACPI_ERROR((AE_INFO, |
f3d2e786 | 834 | "Unsupported address space: %X", reg->space_id)); |
1da177e4 LT |
835 | return (AE_BAD_PARAMETER); |
836 | } | |
837 | ||
4be44fcd LB |
838 | ACPI_DEBUG_PRINT((ACPI_DB_IO, |
839 | "Wrote: %8.8X width %2d to %8.8X%8.8X (%s)\n", | |
59fa8505 | 840 | value, width, ACPI_FORMAT_UINT64(address), |
f3d2e786 | 841 | acpi_ut_get_region_name(reg->space_id))); |
1da177e4 LT |
842 | |
843 | return (status); | |
844 | } | |
ecfbbc7b BM |
845 | |
846 | ACPI_EXPORT_SYMBOL(acpi_write) |