1 2 /****************************************************************************** 3 * 4 * Module Name: hwxface - Public ACPICA hardware interfaces 5 * 6 *****************************************************************************/ 7 8 /* 9 * Copyright (C) 2000 - 2012, Intel Corp. 10 * All rights reserved. 11 * 12 * Redistribution and use in source and binary forms, with or without 13 * modification, are permitted provided that the following conditions 14 * are met: 15 * 1. Redistributions of source code must retain the above copyright 16 * notice, this list of conditions, and the following disclaimer, 17 * without modification. 18 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 19 * substantially similar to the "NO WARRANTY" disclaimer below 20 * ("Disclaimer") and any redistribution must be conditioned upon 21 * including a substantially similar Disclaimer requirement for further 22 * binary redistribution. 23 * 3. Neither the names of the above-listed copyright holders nor the names 24 * of any contributors may be used to endorse or promote products derived 25 * from this software without specific prior written permission. 26 * 27 * Alternatively, this software may be distributed under the terms of the 28 * GNU General Public License ("GPL") version 2 as published by the Free 29 * Software Foundation. 30 * 31 * NO WARRANTY 32 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 33 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 34 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR 35 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 36 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 37 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 38 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 39 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 40 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 41 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 42 * POSSIBILITY OF SUCH DAMAGES. 43 */ 44 45 #include <linux/export.h> 46 #include <acpi/acpi.h> 47 #include "accommon.h" 48 #include "acnamesp.h" 49 50 #define _COMPONENT ACPI_HARDWARE 51 ACPI_MODULE_NAME("hwxface") 52 53 /****************************************************************************** 54 * 55 * FUNCTION: acpi_reset 56 * 57 * PARAMETERS: None 58 * 59 * RETURN: Status 60 * 61 * DESCRIPTION: Set reset register in memory or IO space. Note: Does not 62 * support reset register in PCI config space, this must be 63 * handled separately. 64 * 65 ******************************************************************************/ 66 acpi_status acpi_reset(void) 67 { 68 struct acpi_generic_address *reset_reg; 69 acpi_status status; 70 71 ACPI_FUNCTION_TRACE(acpi_reset); 72 73 reset_reg = &acpi_gbl_FADT.reset_register; 74 75 /* Check if the reset register is supported */ 76 77 if (!(acpi_gbl_FADT.flags & ACPI_FADT_RESET_REGISTER) || 78 !reset_reg->address) { 79 return_ACPI_STATUS(AE_NOT_EXIST); 80 } 81 82 if (reset_reg->space_id == ACPI_ADR_SPACE_SYSTEM_IO) { 83 /* 84 * For I/O space, write directly to the OSL. This 85 * bypasses the port validation mechanism, which may 86 * block a valid write to the reset register. Spec 87 * section 4.7.3.6 requires register width to be 8. 88 */ 89 status = 90 acpi_os_write_port((acpi_io_address) reset_reg->address, 91 acpi_gbl_FADT.reset_value, 8); 92 } else { 93 /* Write the reset value to the reset register */ 94 95 status = acpi_hw_write(acpi_gbl_FADT.reset_value, reset_reg); 96 } 97 98 return_ACPI_STATUS(status); 99 } 100 101 ACPI_EXPORT_SYMBOL(acpi_reset) 102 103 /****************************************************************************** 104 * 105 * FUNCTION: acpi_read 106 * 107 * PARAMETERS: Value - Where the value is returned 108 * Reg - GAS register structure 109 * 110 * RETURN: Status 111 * 112 * DESCRIPTION: Read from either memory or IO space. 113 * 114 * LIMITATIONS: <These limitations also apply to acpi_write> 115 * bit_width must be exactly 8, 16, 32, or 64. 116 * space_iD must be system_memory or system_iO. 117 * bit_offset and access_width are currently ignored, as there has 118 * not been a need to implement these. 119 * 120 ******************************************************************************/ 121 acpi_status acpi_read(u64 *return_value, struct acpi_generic_address *reg) 122 { 123 u32 value; 124 u32 width; 125 u64 address; 126 acpi_status status; 127 128 ACPI_FUNCTION_NAME(acpi_read); 129 130 if (!return_value) { 131 return (AE_BAD_PARAMETER); 132 } 133 134 /* Validate contents of the GAS register. Allow 64-bit transfers */ 135 136 status = acpi_hw_validate_register(reg, 64, &address); 137 if (ACPI_FAILURE(status)) { 138 return (status); 139 } 140 141 width = reg->bit_width; 142 if (width == 64) { 143 width = 32; /* Break into two 32-bit transfers */ 144 } 145 146 /* Initialize entire 64-bit return value to zero */ 147 148 *return_value = 0; 149 value = 0; 150 151 /* 152 * Two address spaces supported: Memory or IO. PCI_Config is 153 * not supported here because the GAS structure is insufficient 154 */ 155 if (reg->space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY) { 156 status = acpi_os_read_memory((acpi_physical_address) 157 address, &value, width); 158 if (ACPI_FAILURE(status)) { 159 return (status); 160 } 161 *return_value = value; 162 163 if (reg->bit_width == 64) { 164 165 /* Read the top 32 bits */ 166 167 status = acpi_os_read_memory((acpi_physical_address) 168 (address + 4), &value, 32); 169 if (ACPI_FAILURE(status)) { 170 return (status); 171 } 172 *return_value |= ((u64)value << 32); 173 } 174 } else { /* ACPI_ADR_SPACE_SYSTEM_IO, validated earlier */ 175 176 status = acpi_hw_read_port((acpi_io_address) 177 address, &value, width); 178 if (ACPI_FAILURE(status)) { 179 return (status); 180 } 181 *return_value = value; 182 183 if (reg->bit_width == 64) { 184 185 /* Read the top 32 bits */ 186 187 status = acpi_hw_read_port((acpi_io_address) 188 (address + 4), &value, 32); 189 if (ACPI_FAILURE(status)) { 190 return (status); 191 } 192 *return_value |= ((u64)value << 32); 193 } 194 } 195 196 ACPI_DEBUG_PRINT((ACPI_DB_IO, 197 "Read: %8.8X%8.8X width %2d from %8.8X%8.8X (%s)\n", 198 ACPI_FORMAT_UINT64(*return_value), reg->bit_width, 199 ACPI_FORMAT_UINT64(address), 200 acpi_ut_get_region_name(reg->space_id))); 201 202 return (status); 203 } 204 205 ACPI_EXPORT_SYMBOL(acpi_read) 206 207 /****************************************************************************** 208 * 209 * FUNCTION: acpi_write 210 * 211 * PARAMETERS: Value - Value to be written 212 * Reg - GAS register structure 213 * 214 * RETURN: Status 215 * 216 * DESCRIPTION: Write to either memory or IO space. 217 * 218 ******************************************************************************/ 219 acpi_status acpi_write(u64 value, struct acpi_generic_address *reg) 220 { 221 u32 width; 222 u64 address; 223 acpi_status status; 224 225 ACPI_FUNCTION_NAME(acpi_write); 226 227 /* Validate contents of the GAS register. Allow 64-bit transfers */ 228 229 status = acpi_hw_validate_register(reg, 64, &address); 230 if (ACPI_FAILURE(status)) { 231 return (status); 232 } 233 234 width = reg->bit_width; 235 if (width == 64) { 236 width = 32; /* Break into two 32-bit transfers */ 237 } 238 239 /* 240 * Two address spaces supported: Memory or IO. PCI_Config is 241 * not supported here because the GAS structure is insufficient 242 */ 243 if (reg->space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY) { 244 status = acpi_os_write_memory((acpi_physical_address) 245 address, ACPI_LODWORD(value), 246 width); 247 if (ACPI_FAILURE(status)) { 248 return (status); 249 } 250 251 if (reg->bit_width == 64) { 252 status = acpi_os_write_memory((acpi_physical_address) 253 (address + 4), 254 ACPI_HIDWORD(value), 32); 255 if (ACPI_FAILURE(status)) { 256 return (status); 257 } 258 } 259 } else { /* ACPI_ADR_SPACE_SYSTEM_IO, validated earlier */ 260 261 status = acpi_hw_write_port((acpi_io_address) 262 address, ACPI_LODWORD(value), 263 width); 264 if (ACPI_FAILURE(status)) { 265 return (status); 266 } 267 268 if (reg->bit_width == 64) { 269 status = acpi_hw_write_port((acpi_io_address) 270 (address + 4), 271 ACPI_HIDWORD(value), 32); 272 if (ACPI_FAILURE(status)) { 273 return (status); 274 } 275 } 276 } 277 278 ACPI_DEBUG_PRINT((ACPI_DB_IO, 279 "Wrote: %8.8X%8.8X width %2d to %8.8X%8.8X (%s)\n", 280 ACPI_FORMAT_UINT64(value), reg->bit_width, 281 ACPI_FORMAT_UINT64(address), 282 acpi_ut_get_region_name(reg->space_id))); 283 284 return (status); 285 } 286 287 ACPI_EXPORT_SYMBOL(acpi_write) 288 289 /******************************************************************************* 290 * 291 * FUNCTION: acpi_read_bit_register 292 * 293 * PARAMETERS: register_id - ID of ACPI Bit Register to access 294 * return_value - Value that was read from the register, 295 * normalized to bit position zero. 296 * 297 * RETURN: Status and the value read from the specified Register. Value 298 * returned is normalized to bit0 (is shifted all the way right) 299 * 300 * DESCRIPTION: ACPI bit_register read function. Does not acquire the HW lock. 301 * 302 * SUPPORTS: Bit fields in PM1 Status, PM1 Enable, PM1 Control, and 303 * PM2 Control. 304 * 305 * Note: The hardware lock is not required when reading the ACPI bit registers 306 * since almost all of them are single bit and it does not matter that 307 * the parent hardware register can be split across two physical 308 * registers. The only multi-bit field is SLP_TYP in the PM1 control 309 * register, but this field does not cross an 8-bit boundary (nor does 310 * it make much sense to actually read this field.) 311 * 312 ******************************************************************************/ 313 acpi_status acpi_read_bit_register(u32 register_id, u32 *return_value) 314 { 315 struct acpi_bit_register_info *bit_reg_info; 316 u32 register_value; 317 u32 value; 318 acpi_status status; 319 320 ACPI_FUNCTION_TRACE_U32(acpi_read_bit_register, register_id); 321 322 /* Get the info structure corresponding to the requested ACPI Register */ 323 324 bit_reg_info = acpi_hw_get_bit_register_info(register_id); 325 if (!bit_reg_info) { 326 return_ACPI_STATUS(AE_BAD_PARAMETER); 327 } 328 329 /* Read the entire parent register */ 330 331 status = acpi_hw_register_read(bit_reg_info->parent_register, 332 ®ister_value); 333 if (ACPI_FAILURE(status)) { 334 return_ACPI_STATUS(status); 335 } 336 337 /* Normalize the value that was read, mask off other bits */ 338 339 value = ((register_value & bit_reg_info->access_bit_mask) 340 >> bit_reg_info->bit_position); 341 342 ACPI_DEBUG_PRINT((ACPI_DB_IO, 343 "BitReg %X, ParentReg %X, Actual %8.8X, ReturnValue %8.8X\n", 344 register_id, bit_reg_info->parent_register, 345 register_value, value)); 346 347 *return_value = value; 348 return_ACPI_STATUS(AE_OK); 349 } 350 351 ACPI_EXPORT_SYMBOL(acpi_read_bit_register) 352 353 /******************************************************************************* 354 * 355 * FUNCTION: acpi_write_bit_register 356 * 357 * PARAMETERS: register_id - ID of ACPI Bit Register to access 358 * Value - Value to write to the register, in bit 359 * position zero. The bit is automatically 360 * shifted to the correct position. 361 * 362 * RETURN: Status 363 * 364 * DESCRIPTION: ACPI Bit Register write function. Acquires the hardware lock 365 * since most operations require a read/modify/write sequence. 366 * 367 * SUPPORTS: Bit fields in PM1 Status, PM1 Enable, PM1 Control, and 368 * PM2 Control. 369 * 370 * Note that at this level, the fact that there may be actually two 371 * hardware registers (A and B - and B may not exist) is abstracted. 372 * 373 ******************************************************************************/ 374 acpi_status acpi_write_bit_register(u32 register_id, u32 value) 375 { 376 struct acpi_bit_register_info *bit_reg_info; 377 acpi_cpu_flags lock_flags; 378 u32 register_value; 379 acpi_status status = AE_OK; 380 381 ACPI_FUNCTION_TRACE_U32(acpi_write_bit_register, register_id); 382 383 /* Get the info structure corresponding to the requested ACPI Register */ 384 385 bit_reg_info = acpi_hw_get_bit_register_info(register_id); 386 if (!bit_reg_info) { 387 return_ACPI_STATUS(AE_BAD_PARAMETER); 388 } 389 390 lock_flags = acpi_os_acquire_lock(acpi_gbl_hardware_lock); 391 392 /* 393 * At this point, we know that the parent register is one of the 394 * following: PM1 Status, PM1 Enable, PM1 Control, or PM2 Control 395 */ 396 if (bit_reg_info->parent_register != ACPI_REGISTER_PM1_STATUS) { 397 /* 398 * 1) Case for PM1 Enable, PM1 Control, and PM2 Control 399 * 400 * Perform a register read to preserve the bits that we are not 401 * interested in 402 */ 403 status = acpi_hw_register_read(bit_reg_info->parent_register, 404 ®ister_value); 405 if (ACPI_FAILURE(status)) { 406 goto unlock_and_exit; 407 } 408 409 /* 410 * Insert the input bit into the value that was just read 411 * and write the register 412 */ 413 ACPI_REGISTER_INSERT_VALUE(register_value, 414 bit_reg_info->bit_position, 415 bit_reg_info->access_bit_mask, 416 value); 417 418 status = acpi_hw_register_write(bit_reg_info->parent_register, 419 register_value); 420 } else { 421 /* 422 * 2) Case for PM1 Status 423 * 424 * The Status register is different from the rest. Clear an event 425 * by writing 1, writing 0 has no effect. So, the only relevant 426 * information is the single bit we're interested in, all others 427 * should be written as 0 so they will be left unchanged. 428 */ 429 register_value = ACPI_REGISTER_PREPARE_BITS(value, 430 bit_reg_info-> 431 bit_position, 432 bit_reg_info-> 433 access_bit_mask); 434 435 /* No need to write the register if value is all zeros */ 436 437 if (register_value) { 438 status = 439 acpi_hw_register_write(ACPI_REGISTER_PM1_STATUS, 440 register_value); 441 } 442 } 443 444 ACPI_DEBUG_PRINT((ACPI_DB_IO, 445 "BitReg %X, ParentReg %X, Value %8.8X, Actual %8.8X\n", 446 register_id, bit_reg_info->parent_register, value, 447 register_value)); 448 449 unlock_and_exit: 450 451 acpi_os_release_lock(acpi_gbl_hardware_lock, lock_flags); 452 return_ACPI_STATUS(status); 453 } 454 455 ACPI_EXPORT_SYMBOL(acpi_write_bit_register) 456 457 /******************************************************************************* 458 * 459 * FUNCTION: acpi_get_sleep_type_data 460 * 461 * PARAMETERS: sleep_state - Numeric sleep state 462 * *sleep_type_a - Where SLP_TYPa is returned 463 * *sleep_type_b - Where SLP_TYPb is returned 464 * 465 * RETURN: Status - ACPI status 466 * 467 * DESCRIPTION: Obtain the SLP_TYPa and SLP_TYPb values for the requested sleep 468 * state. 469 * 470 ******************************************************************************/ 471 acpi_status 472 acpi_get_sleep_type_data(u8 sleep_state, u8 *sleep_type_a, u8 *sleep_type_b) 473 { 474 acpi_status status = AE_OK; 475 struct acpi_evaluate_info *info; 476 477 ACPI_FUNCTION_TRACE(acpi_get_sleep_type_data); 478 479 /* Validate parameters */ 480 481 if ((sleep_state > ACPI_S_STATES_MAX) || !sleep_type_a || !sleep_type_b) { 482 return_ACPI_STATUS(AE_BAD_PARAMETER); 483 } 484 485 /* Allocate the evaluation information block */ 486 487 info = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_evaluate_info)); 488 if (!info) { 489 return_ACPI_STATUS(AE_NO_MEMORY); 490 } 491 492 info->pathname = 493 ACPI_CAST_PTR(char, acpi_gbl_sleep_state_names[sleep_state]); 494 495 /* Evaluate the namespace object containing the values for this state */ 496 497 status = acpi_ns_evaluate(info); 498 if (ACPI_FAILURE(status)) { 499 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, 500 "%s while evaluating SleepState [%s]\n", 501 acpi_format_exception(status), 502 info->pathname)); 503 504 goto cleanup; 505 } 506 507 /* Must have a return object */ 508 509 if (!info->return_object) { 510 ACPI_ERROR((AE_INFO, "No Sleep State object returned from [%s]", 511 info->pathname)); 512 status = AE_NOT_EXIST; 513 } 514 515 /* It must be of type Package */ 516 517 else if (info->return_object->common.type != ACPI_TYPE_PACKAGE) { 518 ACPI_ERROR((AE_INFO, 519 "Sleep State return object is not a Package")); 520 status = AE_AML_OPERAND_TYPE; 521 } 522 523 /* 524 * The package must have at least two elements. NOTE (March 2005): This 525 * goes against the current ACPI spec which defines this object as a 526 * package with one encoded DWORD element. However, existing practice 527 * by BIOS vendors seems to be to have 2 or more elements, at least 528 * one per sleep type (A/B). 529 */ 530 else if (info->return_object->package.count < 2) { 531 ACPI_ERROR((AE_INFO, 532 "Sleep State return package does not have at least two elements")); 533 status = AE_AML_NO_OPERAND; 534 } 535 536 /* The first two elements must both be of type Integer */ 537 538 else if (((info->return_object->package.elements[0])->common.type 539 != ACPI_TYPE_INTEGER) || 540 ((info->return_object->package.elements[1])->common.type 541 != ACPI_TYPE_INTEGER)) { 542 ACPI_ERROR((AE_INFO, 543 "Sleep State return package elements are not both Integers " 544 "(%s, %s)", 545 acpi_ut_get_object_type_name(info->return_object-> 546 package.elements[0]), 547 acpi_ut_get_object_type_name(info->return_object-> 548 package.elements[1]))); 549 status = AE_AML_OPERAND_TYPE; 550 } else { 551 /* Valid _Sx_ package size, type, and value */ 552 553 *sleep_type_a = (u8) 554 (info->return_object->package.elements[0])->integer.value; 555 *sleep_type_b = (u8) 556 (info->return_object->package.elements[1])->integer.value; 557 } 558 559 if (ACPI_FAILURE(status)) { 560 ACPI_EXCEPTION((AE_INFO, status, 561 "While evaluating SleepState [%s], bad Sleep object %p type %s", 562 info->pathname, info->return_object, 563 acpi_ut_get_object_type_name(info-> 564 return_object))); 565 } 566 567 acpi_ut_remove_reference(info->return_object); 568 569 cleanup: 570 ACPI_FREE(info); 571 return_ACPI_STATUS(status); 572 } 573 574 ACPI_EXPORT_SYMBOL(acpi_get_sleep_type_data) 575