1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0 2 /****************************************************************************** 3 * 4 * Module Name: hwxface - Public ACPICA hardware interfaces 5 * 6 * Copyright (C) 2000 - 2018, Intel Corp. 7 * 8 *****************************************************************************/ 9 10 #define EXPORT_ACPI_INTERFACES 11 12 #include <acpi/acpi.h> 13 #include "accommon.h" 14 #include "acnamesp.h" 15 16 #define _COMPONENT ACPI_HARDWARE 17 ACPI_MODULE_NAME("hwxface") 18 19 /****************************************************************************** 20 * 21 * FUNCTION: acpi_reset 22 * 23 * PARAMETERS: None 24 * 25 * RETURN: Status 26 * 27 * DESCRIPTION: Set reset register in memory or IO space. Note: Does not 28 * support reset register in PCI config space, this must be 29 * handled separately. 30 * 31 ******************************************************************************/ 32 acpi_status acpi_reset(void) 33 { 34 struct acpi_generic_address *reset_reg; 35 acpi_status status; 36 37 ACPI_FUNCTION_TRACE(acpi_reset); 38 39 reset_reg = &acpi_gbl_FADT.reset_register; 40 41 /* Check if the reset register is supported */ 42 43 if (!(acpi_gbl_FADT.flags & ACPI_FADT_RESET_REGISTER) || 44 !reset_reg->address) { 45 return_ACPI_STATUS(AE_NOT_EXIST); 46 } 47 48 if (reset_reg->space_id == ACPI_ADR_SPACE_SYSTEM_IO) { 49 /* 50 * For I/O space, write directly to the OSL. This bypasses the port 51 * validation mechanism, which may block a valid write to the reset 52 * register. 53 * 54 * NOTE: 55 * The ACPI spec requires the reset register width to be 8, so we 56 * hardcode it here and ignore the FADT value. This maintains 57 * compatibility with other ACPI implementations that have allowed 58 * BIOS code with bad register width values to go unnoticed. 59 */ 60 status = acpi_os_write_port((acpi_io_address)reset_reg->address, 61 acpi_gbl_FADT.reset_value, 62 ACPI_RESET_REGISTER_WIDTH); 63 } else { 64 /* Write the reset value to the reset register */ 65 66 status = acpi_hw_write(acpi_gbl_FADT.reset_value, reset_reg); 67 } 68 69 return_ACPI_STATUS(status); 70 } 71 72 ACPI_EXPORT_SYMBOL(acpi_reset) 73 74 /****************************************************************************** 75 * 76 * FUNCTION: acpi_read 77 * 78 * PARAMETERS: value - Where the value is returned 79 * reg - GAS register structure 80 * 81 * RETURN: Status 82 * 83 * DESCRIPTION: Read from either memory or IO space. 84 * 85 * LIMITATIONS: <These limitations also apply to acpi_write> 86 * bit_width must be exactly 8, 16, 32, or 64. 87 * space_ID must be system_memory or system_IO. 88 * bit_offset and access_width are currently ignored, as there has 89 * not been a need to implement these. 90 * 91 ******************************************************************************/ 92 acpi_status acpi_read(u64 *return_value, struct acpi_generic_address *reg) 93 { 94 acpi_status status; 95 96 ACPI_FUNCTION_NAME(acpi_read); 97 98 status = acpi_hw_read(return_value, reg); 99 return (status); 100 } 101 102 ACPI_EXPORT_SYMBOL(acpi_read) 103 104 /****************************************************************************** 105 * 106 * FUNCTION: acpi_write 107 * 108 * PARAMETERS: value - Value to be written 109 * reg - GAS register structure 110 * 111 * RETURN: Status 112 * 113 * DESCRIPTION: Write to either memory or IO space. 114 * 115 ******************************************************************************/ 116 acpi_status acpi_write(u64 value, struct acpi_generic_address *reg) 117 { 118 acpi_status status; 119 120 ACPI_FUNCTION_NAME(acpi_write); 121 122 status = acpi_hw_write(value, reg); 123 return (status); 124 } 125 126 ACPI_EXPORT_SYMBOL(acpi_write) 127 128 #if (!ACPI_REDUCED_HARDWARE) 129 /******************************************************************************* 130 * 131 * FUNCTION: acpi_read_bit_register 132 * 133 * PARAMETERS: register_id - ID of ACPI Bit Register to access 134 * return_value - Value that was read from the register, 135 * normalized to bit position zero. 136 * 137 * RETURN: Status and the value read from the specified Register. Value 138 * returned is normalized to bit0 (is shifted all the way right) 139 * 140 * DESCRIPTION: ACPI bit_register read function. Does not acquire the HW lock. 141 * 142 * SUPPORTS: Bit fields in PM1 Status, PM1 Enable, PM1 Control, and 143 * PM2 Control. 144 * 145 * Note: The hardware lock is not required when reading the ACPI bit registers 146 * since almost all of them are single bit and it does not matter that 147 * the parent hardware register can be split across two physical 148 * registers. The only multi-bit field is SLP_TYP in the PM1 control 149 * register, but this field does not cross an 8-bit boundary (nor does 150 * it make much sense to actually read this field.) 151 * 152 ******************************************************************************/ 153 acpi_status acpi_read_bit_register(u32 register_id, u32 *return_value) 154 { 155 struct acpi_bit_register_info *bit_reg_info; 156 u32 register_value; 157 u32 value; 158 acpi_status status; 159 160 ACPI_FUNCTION_TRACE_U32(acpi_read_bit_register, register_id); 161 162 /* Get the info structure corresponding to the requested ACPI Register */ 163 164 bit_reg_info = acpi_hw_get_bit_register_info(register_id); 165 if (!bit_reg_info) { 166 return_ACPI_STATUS(AE_BAD_PARAMETER); 167 } 168 169 /* Read the entire parent register */ 170 171 status = acpi_hw_register_read(bit_reg_info->parent_register, 172 ®ister_value); 173 if (ACPI_FAILURE(status)) { 174 return_ACPI_STATUS(status); 175 } 176 177 /* Normalize the value that was read, mask off other bits */ 178 179 value = ((register_value & bit_reg_info->access_bit_mask) 180 >> bit_reg_info->bit_position); 181 182 ACPI_DEBUG_PRINT((ACPI_DB_IO, 183 "BitReg %X, ParentReg %X, Actual %8.8X, ReturnValue %8.8X\n", 184 register_id, bit_reg_info->parent_register, 185 register_value, value)); 186 187 *return_value = value; 188 return_ACPI_STATUS(AE_OK); 189 } 190 191 ACPI_EXPORT_SYMBOL(acpi_read_bit_register) 192 193 /******************************************************************************* 194 * 195 * FUNCTION: acpi_write_bit_register 196 * 197 * PARAMETERS: register_id - ID of ACPI Bit Register to access 198 * value - Value to write to the register, in bit 199 * position zero. The bit is automatically 200 * shifted to the correct position. 201 * 202 * RETURN: Status 203 * 204 * DESCRIPTION: ACPI Bit Register write function. Acquires the hardware lock 205 * since most operations require a read/modify/write sequence. 206 * 207 * SUPPORTS: Bit fields in PM1 Status, PM1 Enable, PM1 Control, and 208 * PM2 Control. 209 * 210 * Note that at this level, the fact that there may be actually two 211 * hardware registers (A and B - and B may not exist) is abstracted. 212 * 213 ******************************************************************************/ 214 acpi_status acpi_write_bit_register(u32 register_id, u32 value) 215 { 216 struct acpi_bit_register_info *bit_reg_info; 217 acpi_cpu_flags lock_flags; 218 u32 register_value; 219 acpi_status status = AE_OK; 220 221 ACPI_FUNCTION_TRACE_U32(acpi_write_bit_register, register_id); 222 223 /* Get the info structure corresponding to the requested ACPI Register */ 224 225 bit_reg_info = acpi_hw_get_bit_register_info(register_id); 226 if (!bit_reg_info) { 227 return_ACPI_STATUS(AE_BAD_PARAMETER); 228 } 229 230 lock_flags = acpi_os_acquire_lock(acpi_gbl_hardware_lock); 231 232 /* 233 * At this point, we know that the parent register is one of the 234 * following: PM1 Status, PM1 Enable, PM1 Control, or PM2 Control 235 */ 236 if (bit_reg_info->parent_register != ACPI_REGISTER_PM1_STATUS) { 237 /* 238 * 1) Case for PM1 Enable, PM1 Control, and PM2 Control 239 * 240 * Perform a register read to preserve the bits that we are not 241 * interested in 242 */ 243 status = acpi_hw_register_read(bit_reg_info->parent_register, 244 ®ister_value); 245 if (ACPI_FAILURE(status)) { 246 goto unlock_and_exit; 247 } 248 249 /* 250 * Insert the input bit into the value that was just read 251 * and write the register 252 */ 253 ACPI_REGISTER_INSERT_VALUE(register_value, 254 bit_reg_info->bit_position, 255 bit_reg_info->access_bit_mask, 256 value); 257 258 status = acpi_hw_register_write(bit_reg_info->parent_register, 259 register_value); 260 } else { 261 /* 262 * 2) Case for PM1 Status 263 * 264 * The Status register is different from the rest. Clear an event 265 * by writing 1, writing 0 has no effect. So, the only relevant 266 * information is the single bit we're interested in, all others 267 * should be written as 0 so they will be left unchanged. 268 */ 269 register_value = ACPI_REGISTER_PREPARE_BITS(value, 270 bit_reg_info-> 271 bit_position, 272 bit_reg_info-> 273 access_bit_mask); 274 275 /* No need to write the register if value is all zeros */ 276 277 if (register_value) { 278 status = 279 acpi_hw_register_write(ACPI_REGISTER_PM1_STATUS, 280 register_value); 281 } 282 } 283 284 ACPI_DEBUG_PRINT((ACPI_DB_IO, 285 "BitReg %X, ParentReg %X, Value %8.8X, Actual %8.8X\n", 286 register_id, bit_reg_info->parent_register, value, 287 register_value)); 288 289 unlock_and_exit: 290 291 acpi_os_release_lock(acpi_gbl_hardware_lock, lock_flags); 292 return_ACPI_STATUS(status); 293 } 294 295 ACPI_EXPORT_SYMBOL(acpi_write_bit_register) 296 #endif /* !ACPI_REDUCED_HARDWARE */ 297 /******************************************************************************* 298 * 299 * FUNCTION: acpi_get_sleep_type_data 300 * 301 * PARAMETERS: sleep_state - Numeric sleep state 302 * *sleep_type_a - Where SLP_TYPa is returned 303 * *sleep_type_b - Where SLP_TYPb is returned 304 * 305 * RETURN: Status 306 * 307 * DESCRIPTION: Obtain the SLP_TYPa and SLP_TYPb values for the requested 308 * sleep state via the appropriate \_Sx object. 309 * 310 * The sleep state package returned from the corresponding \_Sx_ object 311 * must contain at least one integer. 312 * 313 * March 2005: 314 * Added support for a package that contains two integers. This 315 * goes against the ACPI specification which defines this object as a 316 * package with one encoded DWORD integer. However, existing practice 317 * by many BIOS vendors is to return a package with 2 or more integer 318 * elements, at least one per sleep type (A/B). 319 * 320 * January 2013: 321 * Therefore, we must be prepared to accept a package with either a 322 * single integer or multiple integers. 323 * 324 * The single integer DWORD format is as follows: 325 * BYTE 0 - Value for the PM1A SLP_TYP register 326 * BYTE 1 - Value for the PM1B SLP_TYP register 327 * BYTE 2-3 - Reserved 328 * 329 * The dual integer format is as follows: 330 * Integer 0 - Value for the PM1A SLP_TYP register 331 * Integer 1 - Value for the PM1A SLP_TYP register 332 * 333 ******************************************************************************/ 334 acpi_status 335 acpi_get_sleep_type_data(u8 sleep_state, u8 *sleep_type_a, u8 *sleep_type_b) 336 { 337 acpi_status status; 338 struct acpi_evaluate_info *info; 339 union acpi_operand_object **elements; 340 341 ACPI_FUNCTION_TRACE(acpi_get_sleep_type_data); 342 343 /* Validate parameters */ 344 345 if ((sleep_state > ACPI_S_STATES_MAX) || !sleep_type_a || !sleep_type_b) { 346 return_ACPI_STATUS(AE_BAD_PARAMETER); 347 } 348 349 /* Allocate the evaluation information block */ 350 351 info = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_evaluate_info)); 352 if (!info) { 353 return_ACPI_STATUS(AE_NO_MEMORY); 354 } 355 356 /* 357 * Evaluate the \_Sx namespace object containing the register values 358 * for this state 359 */ 360 info->relative_pathname = acpi_gbl_sleep_state_names[sleep_state]; 361 362 status = acpi_ns_evaluate(info); 363 if (ACPI_FAILURE(status)) { 364 if (status == AE_NOT_FOUND) { 365 366 /* The _Sx states are optional, ignore NOT_FOUND */ 367 368 goto final_cleanup; 369 } 370 371 goto warning_cleanup; 372 } 373 374 /* Must have a return object */ 375 376 if (!info->return_object) { 377 ACPI_ERROR((AE_INFO, "No Sleep State object returned from [%s]", 378 info->relative_pathname)); 379 status = AE_AML_NO_RETURN_VALUE; 380 goto warning_cleanup; 381 } 382 383 /* Return object must be of type Package */ 384 385 if (info->return_object->common.type != ACPI_TYPE_PACKAGE) { 386 ACPI_ERROR((AE_INFO, 387 "Sleep State return object is not a Package")); 388 status = AE_AML_OPERAND_TYPE; 389 goto return_value_cleanup; 390 } 391 392 /* 393 * Any warnings about the package length or the object types have 394 * already been issued by the predefined name module -- there is no 395 * need to repeat them here. 396 */ 397 elements = info->return_object->package.elements; 398 switch (info->return_object->package.count) { 399 case 0: 400 401 status = AE_AML_PACKAGE_LIMIT; 402 break; 403 404 case 1: 405 406 if (elements[0]->common.type != ACPI_TYPE_INTEGER) { 407 status = AE_AML_OPERAND_TYPE; 408 break; 409 } 410 411 /* A valid _Sx_ package with one integer */ 412 413 *sleep_type_a = (u8)elements[0]->integer.value; 414 *sleep_type_b = (u8)(elements[0]->integer.value >> 8); 415 break; 416 417 case 2: 418 default: 419 420 if ((elements[0]->common.type != ACPI_TYPE_INTEGER) || 421 (elements[1]->common.type != ACPI_TYPE_INTEGER)) { 422 status = AE_AML_OPERAND_TYPE; 423 break; 424 } 425 426 /* A valid _Sx_ package with two integers */ 427 428 *sleep_type_a = (u8)elements[0]->integer.value; 429 *sleep_type_b = (u8)elements[1]->integer.value; 430 break; 431 } 432 433 return_value_cleanup: 434 acpi_ut_remove_reference(info->return_object); 435 436 warning_cleanup: 437 if (ACPI_FAILURE(status)) { 438 ACPI_EXCEPTION((AE_INFO, status, 439 "While evaluating Sleep State [%s]", 440 info->relative_pathname)); 441 } 442 443 final_cleanup: 444 ACPI_FREE(info); 445 return_ACPI_STATUS(status); 446 } 447 448 ACPI_EXPORT_SYMBOL(acpi_get_sleep_type_data) 449