1 2 /****************************************************************************** 3 * 4 * Module Name: exregion - ACPI default OpRegion (address space) handlers 5 * 6 *****************************************************************************/ 7 8 /* 9 * Copyright (C) 2000 - 2011, 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 46 #define __EXREGION_C__ 47 48 #include "acpi.h" 49 #include "accommon.h" 50 #include "acinterp.h" 51 52 53 #define _COMPONENT ACPI_EXECUTER 54 ACPI_MODULE_NAME ("exregion") 55 56 57 /******************************************************************************* 58 * 59 * FUNCTION: AcpiExSystemMemorySpaceHandler 60 * 61 * PARAMETERS: Function - Read or Write operation 62 * Address - Where in the space to read or write 63 * BitWidth - Field width in bits (8, 16, or 32) 64 * Value - Pointer to in or out value 65 * HandlerContext - Pointer to Handler's context 66 * RegionContext - Pointer to context specific to the 67 * accessed region 68 * 69 * RETURN: Status 70 * 71 * DESCRIPTION: Handler for the System Memory address space (Op Region) 72 * 73 ******************************************************************************/ 74 75 ACPI_STATUS 76 AcpiExSystemMemorySpaceHandler ( 77 UINT32 Function, 78 ACPI_PHYSICAL_ADDRESS Address, 79 UINT32 BitWidth, 80 UINT64 *Value, 81 void *HandlerContext, 82 void *RegionContext) 83 { 84 ACPI_STATUS Status = AE_OK; 85 void *LogicalAddrPtr = NULL; 86 ACPI_MEM_SPACE_CONTEXT *MemInfo = RegionContext; 87 UINT32 Length; 88 ACPI_SIZE MapLength; 89 ACPI_SIZE PageBoundaryMapLength; 90 #ifdef ACPI_MISALIGNMENT_NOT_SUPPORTED 91 UINT32 Remainder; 92 #endif 93 94 95 ACPI_FUNCTION_TRACE (ExSystemMemorySpaceHandler); 96 97 98 /* Validate and translate the bit width */ 99 100 switch (BitWidth) 101 { 102 case 8: 103 Length = 1; 104 break; 105 106 case 16: 107 Length = 2; 108 break; 109 110 case 32: 111 Length = 4; 112 break; 113 114 case 64: 115 Length = 8; 116 break; 117 118 default: 119 ACPI_ERROR ((AE_INFO, "Invalid SystemMemory width %u", 120 BitWidth)); 121 return_ACPI_STATUS (AE_AML_OPERAND_VALUE); 122 } 123 124 #ifdef ACPI_MISALIGNMENT_NOT_SUPPORTED 125 /* 126 * Hardware does not support non-aligned data transfers, we must verify 127 * the request. 128 */ 129 (void) AcpiUtShortDivide ((UINT64) Address, Length, NULL, &Remainder); 130 if (Remainder != 0) 131 { 132 return_ACPI_STATUS (AE_AML_ALIGNMENT); 133 } 134 #endif 135 136 /* 137 * Does the request fit into the cached memory mapping? 138 * Is 1) Address below the current mapping? OR 139 * 2) Address beyond the current mapping? 140 */ 141 if ((Address < MemInfo->MappedPhysicalAddress) || 142 (((UINT64) Address + Length) > 143 ((UINT64) 144 MemInfo->MappedPhysicalAddress + MemInfo->MappedLength))) 145 { 146 /* 147 * The request cannot be resolved by the current memory mapping; 148 * Delete the existing mapping and create a new one. 149 */ 150 if (MemInfo->MappedLength) 151 { 152 /* Valid mapping, delete it */ 153 154 AcpiOsUnmapMemory (MemInfo->MappedLogicalAddress, 155 MemInfo->MappedLength); 156 } 157 158 /* 159 * October 2009: Attempt to map from the requested address to the 160 * end of the region. However, we will never map more than one 161 * page, nor will we cross a page boundary. 162 */ 163 MapLength = (ACPI_SIZE) 164 ((MemInfo->Address + MemInfo->Length) - Address); 165 166 /* 167 * If mapping the entire remaining portion of the region will cross 168 * a page boundary, just map up to the page boundary, do not cross. 169 * On some systems, crossing a page boundary while mapping regions 170 * can cause warnings if the pages have different attributes 171 * due to resource management. 172 * 173 * This has the added benefit of constraining a single mapping to 174 * one page, which is similar to the original code that used a 4k 175 * maximum window. 176 */ 177 PageBoundaryMapLength = 178 ACPI_ROUND_UP (Address, ACPI_DEFAULT_PAGE_SIZE) - Address; 179 if (PageBoundaryMapLength == 0) 180 { 181 PageBoundaryMapLength = ACPI_DEFAULT_PAGE_SIZE; 182 } 183 184 if (MapLength > PageBoundaryMapLength) 185 { 186 MapLength = PageBoundaryMapLength; 187 } 188 189 /* Create a new mapping starting at the address given */ 190 191 MemInfo->MappedLogicalAddress = AcpiOsMapMemory ( 192 (ACPI_PHYSICAL_ADDRESS) Address, MapLength); 193 if (!MemInfo->MappedLogicalAddress) 194 { 195 ACPI_ERROR ((AE_INFO, 196 "Could not map memory at 0x%8.8X%8.8X, size %u", 197 ACPI_FORMAT_NATIVE_UINT (Address), (UINT32) MapLength)); 198 MemInfo->MappedLength = 0; 199 return_ACPI_STATUS (AE_NO_MEMORY); 200 } 201 202 /* Save the physical address and mapping size */ 203 204 MemInfo->MappedPhysicalAddress = Address; 205 MemInfo->MappedLength = MapLength; 206 } 207 208 /* 209 * Generate a logical pointer corresponding to the address we want to 210 * access 211 */ 212 LogicalAddrPtr = MemInfo->MappedLogicalAddress + 213 ((UINT64) Address - (UINT64) MemInfo->MappedPhysicalAddress); 214 215 ACPI_DEBUG_PRINT ((ACPI_DB_INFO, 216 "System-Memory (width %u) R/W %u Address=%8.8X%8.8X\n", 217 BitWidth, Function, ACPI_FORMAT_NATIVE_UINT (Address))); 218 219 /* 220 * Perform the memory read or write 221 * 222 * Note: For machines that do not support non-aligned transfers, the target 223 * address was checked for alignment above. We do not attempt to break the 224 * transfer up into smaller (byte-size) chunks because the AML specifically 225 * asked for a transfer width that the hardware may require. 226 */ 227 switch (Function) 228 { 229 case ACPI_READ: 230 231 *Value = 0; 232 switch (BitWidth) 233 { 234 case 8: 235 *Value = (UINT64) ACPI_GET8 (LogicalAddrPtr); 236 break; 237 238 case 16: 239 *Value = (UINT64) ACPI_GET16 (LogicalAddrPtr); 240 break; 241 242 case 32: 243 *Value = (UINT64) ACPI_GET32 (LogicalAddrPtr); 244 break; 245 246 case 64: 247 *Value = (UINT64) ACPI_GET64 (LogicalAddrPtr); 248 break; 249 250 default: 251 /* BitWidth was already validated */ 252 break; 253 } 254 break; 255 256 case ACPI_WRITE: 257 258 switch (BitWidth) 259 { 260 case 8: 261 ACPI_SET8 (LogicalAddrPtr) = (UINT8) *Value; 262 break; 263 264 case 16: 265 ACPI_SET16 (LogicalAddrPtr) = (UINT16) *Value; 266 break; 267 268 case 32: 269 ACPI_SET32 ( LogicalAddrPtr) = (UINT32) *Value; 270 break; 271 272 case 64: 273 ACPI_SET64 (LogicalAddrPtr) = (UINT64) *Value; 274 break; 275 276 default: 277 /* BitWidth was already validated */ 278 break; 279 } 280 break; 281 282 default: 283 Status = AE_BAD_PARAMETER; 284 break; 285 } 286 287 return_ACPI_STATUS (Status); 288 } 289 290 291 /******************************************************************************* 292 * 293 * FUNCTION: AcpiExSystemIoSpaceHandler 294 * 295 * PARAMETERS: Function - Read or Write operation 296 * Address - Where in the space to read or write 297 * BitWidth - Field width in bits (8, 16, or 32) 298 * Value - Pointer to in or out value 299 * HandlerContext - Pointer to Handler's context 300 * RegionContext - Pointer to context specific to the 301 * accessed region 302 * 303 * RETURN: Status 304 * 305 * DESCRIPTION: Handler for the System IO address space (Op Region) 306 * 307 ******************************************************************************/ 308 309 ACPI_STATUS 310 AcpiExSystemIoSpaceHandler ( 311 UINT32 Function, 312 ACPI_PHYSICAL_ADDRESS Address, 313 UINT32 BitWidth, 314 UINT64 *Value, 315 void *HandlerContext, 316 void *RegionContext) 317 { 318 ACPI_STATUS Status = AE_OK; 319 UINT32 Value32; 320 321 322 ACPI_FUNCTION_TRACE (ExSystemIoSpaceHandler); 323 324 325 ACPI_DEBUG_PRINT ((ACPI_DB_INFO, 326 "System-IO (width %u) R/W %u Address=%8.8X%8.8X\n", 327 BitWidth, Function, ACPI_FORMAT_NATIVE_UINT (Address))); 328 329 /* Decode the function parameter */ 330 331 switch (Function) 332 { 333 case ACPI_READ: 334 335 Status = AcpiHwReadPort ((ACPI_IO_ADDRESS) Address, 336 &Value32, BitWidth); 337 *Value = Value32; 338 break; 339 340 case ACPI_WRITE: 341 342 Status = AcpiHwWritePort ((ACPI_IO_ADDRESS) Address, 343 (UINT32) *Value, BitWidth); 344 break; 345 346 default: 347 Status = AE_BAD_PARAMETER; 348 break; 349 } 350 351 return_ACPI_STATUS (Status); 352 } 353 354 355 /******************************************************************************* 356 * 357 * FUNCTION: AcpiExPciConfigSpaceHandler 358 * 359 * PARAMETERS: Function - Read or Write operation 360 * Address - Where in the space to read or write 361 * BitWidth - Field width in bits (8, 16, or 32) 362 * Value - Pointer to in or out value 363 * HandlerContext - Pointer to Handler's context 364 * RegionContext - Pointer to context specific to the 365 * accessed region 366 * 367 * RETURN: Status 368 * 369 * DESCRIPTION: Handler for the PCI Config address space (Op Region) 370 * 371 ******************************************************************************/ 372 373 ACPI_STATUS 374 AcpiExPciConfigSpaceHandler ( 375 UINT32 Function, 376 ACPI_PHYSICAL_ADDRESS Address, 377 UINT32 BitWidth, 378 UINT64 *Value, 379 void *HandlerContext, 380 void *RegionContext) 381 { 382 ACPI_STATUS Status = AE_OK; 383 ACPI_PCI_ID *PciId; 384 UINT16 PciRegister; 385 386 387 ACPI_FUNCTION_TRACE (ExPciConfigSpaceHandler); 388 389 390 /* 391 * The arguments to AcpiOs(Read|Write)PciConfiguration are: 392 * 393 * PciSegment is the PCI bus segment range 0-31 394 * PciBus is the PCI bus number range 0-255 395 * PciDevice is the PCI device number range 0-31 396 * PciFunction is the PCI device function number 397 * PciRegister is the Config space register range 0-255 bytes 398 * 399 * Value - input value for write, output address for read 400 * 401 */ 402 PciId = (ACPI_PCI_ID *) RegionContext; 403 PciRegister = (UINT16) (UINT32) Address; 404 405 ACPI_DEBUG_PRINT ((ACPI_DB_INFO, 406 "Pci-Config %u (%u) Seg(%04x) Bus(%04x) Dev(%04x) Func(%04x) Reg(%04x)\n", 407 Function, BitWidth, PciId->Segment, PciId->Bus, PciId->Device, 408 PciId->Function, PciRegister)); 409 410 switch (Function) 411 { 412 case ACPI_READ: 413 414 *Value = 0; 415 Status = AcpiOsReadPciConfiguration (PciId, PciRegister, 416 Value, BitWidth); 417 break; 418 419 case ACPI_WRITE: 420 421 Status = AcpiOsWritePciConfiguration (PciId, PciRegister, 422 *Value, BitWidth); 423 break; 424 425 default: 426 427 Status = AE_BAD_PARAMETER; 428 break; 429 } 430 431 return_ACPI_STATUS (Status); 432 } 433 434 435 /******************************************************************************* 436 * 437 * FUNCTION: AcpiExCmosSpaceHandler 438 * 439 * PARAMETERS: Function - Read or Write operation 440 * Address - Where in the space to read or write 441 * BitWidth - Field width in bits (8, 16, or 32) 442 * Value - Pointer to in or out value 443 * HandlerContext - Pointer to Handler's context 444 * RegionContext - Pointer to context specific to the 445 * accessed region 446 * 447 * RETURN: Status 448 * 449 * DESCRIPTION: Handler for the CMOS address space (Op Region) 450 * 451 ******************************************************************************/ 452 453 ACPI_STATUS 454 AcpiExCmosSpaceHandler ( 455 UINT32 Function, 456 ACPI_PHYSICAL_ADDRESS Address, 457 UINT32 BitWidth, 458 UINT64 *Value, 459 void *HandlerContext, 460 void *RegionContext) 461 { 462 ACPI_STATUS Status = AE_OK; 463 464 465 ACPI_FUNCTION_TRACE (ExCmosSpaceHandler); 466 467 468 return_ACPI_STATUS (Status); 469 } 470 471 472 /******************************************************************************* 473 * 474 * FUNCTION: AcpiExPciBarSpaceHandler 475 * 476 * PARAMETERS: Function - Read or Write operation 477 * Address - Where in the space to read or write 478 * BitWidth - Field width in bits (8, 16, or 32) 479 * Value - Pointer to in or out value 480 * HandlerContext - Pointer to Handler's context 481 * RegionContext - Pointer to context specific to the 482 * accessed region 483 * 484 * RETURN: Status 485 * 486 * DESCRIPTION: Handler for the PCI BarTarget address space (Op Region) 487 * 488 ******************************************************************************/ 489 490 ACPI_STATUS 491 AcpiExPciBarSpaceHandler ( 492 UINT32 Function, 493 ACPI_PHYSICAL_ADDRESS Address, 494 UINT32 BitWidth, 495 UINT64 *Value, 496 void *HandlerContext, 497 void *RegionContext) 498 { 499 ACPI_STATUS Status = AE_OK; 500 501 502 ACPI_FUNCTION_TRACE (ExPciBarSpaceHandler); 503 504 505 return_ACPI_STATUS (Status); 506 } 507 508 509 /******************************************************************************* 510 * 511 * FUNCTION: AcpiExDataTableSpaceHandler 512 * 513 * PARAMETERS: Function - Read or Write operation 514 * Address - Where in the space to read or write 515 * BitWidth - Field width in bits (8, 16, or 32) 516 * Value - Pointer to in or out value 517 * HandlerContext - Pointer to Handler's context 518 * RegionContext - Pointer to context specific to the 519 * accessed region 520 * 521 * RETURN: Status 522 * 523 * DESCRIPTION: Handler for the Data Table address space (Op Region) 524 * 525 ******************************************************************************/ 526 527 ACPI_STATUS 528 AcpiExDataTableSpaceHandler ( 529 UINT32 Function, 530 ACPI_PHYSICAL_ADDRESS Address, 531 UINT32 BitWidth, 532 UINT64 *Value, 533 void *HandlerContext, 534 void *RegionContext) 535 { 536 ACPI_FUNCTION_TRACE (ExDataTableSpaceHandler); 537 538 539 /* 540 * Perform the memory read or write. The BitWidth was already 541 * validated. 542 */ 543 switch (Function) 544 { 545 case ACPI_READ: 546 547 ACPI_MEMCPY (ACPI_CAST_PTR (char, Value), ACPI_PHYSADDR_TO_PTR (Address), 548 ACPI_DIV_8 (BitWidth)); 549 break; 550 551 case ACPI_WRITE: 552 553 ACPI_MEMCPY (ACPI_PHYSADDR_TO_PTR (Address), ACPI_CAST_PTR (char, Value), 554 ACPI_DIV_8 (BitWidth)); 555 break; 556 557 default: 558 559 return_ACPI_STATUS (AE_BAD_PARAMETER); 560 } 561 562 return_ACPI_STATUS (AE_OK); 563 } 564 565 566