drivers/acpi/acpica/exregion.c

   1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
   2 /******************************************************************************
   3  *
   4  * Module Name: exregion - ACPI default op_region (address space) handlers
   5  *
   6  * Copyright (C) 2000 - 2020, Intel Corp.
   7  *
   8  *****************************************************************************/
   9
  10 #include <acpi/acpi.h>
  11 #include "accommon.h"
  12 #include "acinterp.h"
  13
  14 #define _COMPONENT          ACPI_EXECUTER
  15 ACPI_MODULE_NAME("exregion")
  16
  17 /*******************************************************************************
  18  *
  19  * FUNCTION:    acpi_ex_system_memory_space_handler
  20  *
  21  * PARAMETERS:  function            - Read or Write operation
  22  *              address             - Where in the space to read or write
  23  *              bit_width           - Field width in bits (8, 16, or 32)
  24  *              value               - Pointer to in or out value
  25  *              handler_context     - Pointer to Handler's context
  26  *              region_context      - Pointer to context specific to the
  27  *                                    accessed region
  28  *
  29  * RETURN:      Status
  30  *
  31  * DESCRIPTION: Handler for the System Memory address space (Op Region)
  32  *
  33  ******************************************************************************/
  34 acpi_status
  35 acpi_ex_system_memory_space_handler(u32 function,
  36                                     acpi_physical_address address,
  37                                     u32 bit_width,
  38                                     u64 *value,
  39                                     void *handler_context, void *region_context)
  40 {
  41         acpi_status status = AE_OK;
  42         void *logical_addr_ptr = NULL;
  43         struct acpi_mem_space_context *mem_info = region_context;
  44         struct acpi_mem_mapping *mm = mem_info->cur_mm;
  45         u32 length;
  46         acpi_size map_length;
  47         acpi_size page_boundary_map_length;
  48 #ifdef ACPI_MISALIGNMENT_NOT_SUPPORTED
  49         u32 remainder;
  50 #endif
  51
  52         ACPI_FUNCTION_TRACE(ex_system_memory_space_handler);
  53
  54         /* Validate and translate the bit width */
  55
  56         switch (bit_width) {
  57         case 8:
  58
  59                 length = 1;
  60                 break;
  61
  62         case 16:
  63
  64                 length = 2;
  65                 break;
  66
  67         case 32:
  68
  69                 length = 4;
  70                 break;
  71
  72         case 64:
  73
  74                 length = 8;
  75                 break;
  76
  77         default:
  78
  79                 ACPI_ERROR((AE_INFO, "Invalid SystemMemory width %u",
  80                             bit_width));
  81                 return_ACPI_STATUS(AE_AML_OPERAND_VALUE);
  82         }
  83
  84 #ifdef ACPI_MISALIGNMENT_NOT_SUPPORTED
  85         /*
  86          * Hardware does not support non-aligned data transfers, we must verify
  87          * the request.
  88          */
  89         (void)acpi_ut_short_divide((u64) address, length, NULL, &remainder);
  90         if (remainder != 0) {
  91                 return_ACPI_STATUS(AE_AML_ALIGNMENT);
  92         }
  93 #endif
  94
  95         /*
  96          * Does the request fit into the cached memory mapping?
  97          * Is 1) Address below the current mapping? OR
  98          *    2) Address beyond the current mapping?
  99          */
 100         if (!mm || (address < mm->physical_address) ||
 101             ((u64) address + length > (u64) mm->physical_address + mm->length)) {
 102                 /*
 103                  * The request cannot be resolved by the current memory mapping.
 104                  *
 105                  * Look for an existing saved mapping covering the address range
 106                  * at hand.  If found, save it as the current one and carry out
 107                  * the access.
 108                  */
 109                 for (mm = mem_info->first_mm; mm; mm = mm->next_mm) {
 110                         if (mm == mem_info->cur_mm)
 111                                 continue;
 112
 113                         if (address < mm->physical_address)
 114                                 continue;
 115
 116                         if ((u64) address + length >
 117                                         (u64) mm->physical_address + mm->length)
 118                                 continue;
 119
 120                         mem_info->cur_mm = mm;
 121                         goto access;
 122                 }
 123
 124                 /* Create a new mappings list entry */
 125                 mm = ACPI_ALLOCATE_ZEROED(sizeof(*mm));
 126                 if (!mm) {
 127                         ACPI_ERROR((AE_INFO,
 128                                     "Unable to save memory mapping at 0x%8.8X%8.8X, size %u",
 129                                     ACPI_FORMAT_UINT64(address), length));
 130                         return_ACPI_STATUS(AE_NO_MEMORY);
 131                 }
 132
 133                 /*
 134                  * October 2009: Attempt to map from the requested address to the
 135                  * end of the region. However, we will never map more than one
 136                  * page, nor will we cross a page boundary.
 137                  */
 138                 map_length = (acpi_size)
 139                     ((mem_info->address + mem_info->length) - address);
 140
 141                 /*
 142                  * If mapping the entire remaining portion of the region will cross
 143                  * a page boundary, just map up to the page boundary, do not cross.
 144                  * On some systems, crossing a page boundary while mapping regions
 145                  * can cause warnings if the pages have different attributes
 146                  * due to resource management.
 147                  *
 148                  * This has the added benefit of constraining a single mapping to
 149                  * one page, which is similar to the original code that used a 4k
 150                  * maximum window.
 151                  */
 152                 page_boundary_map_length = (acpi_size)
 153                     (ACPI_ROUND_UP(address, ACPI_DEFAULT_PAGE_SIZE) - address);
 154                 if (page_boundary_map_length == 0) {
 155                         page_boundary_map_length = ACPI_DEFAULT_PAGE_SIZE;
 156                 }
 157
 158                 if (map_length > page_boundary_map_length) {
 159                         map_length = page_boundary_map_length;
 160                 }
 161
 162                 /* Create a new mapping starting at the address given */
 163
 164                 logical_addr_ptr = acpi_os_map_memory(address, map_length);
 165                 if (!logical_addr_ptr) {
 166                         ACPI_ERROR((AE_INFO,
 167                                     "Could not map memory at 0x%8.8X%8.8X, size %u",
 168                                     ACPI_FORMAT_UINT64(address),
 169                                     (u32)map_length));
 170                         ACPI_FREE(mm);
 171                         return_ACPI_STATUS(AE_NO_MEMORY);
 172                 }
 173
 174                 /* Save the physical address and mapping size */
 175
 176                 mm->logical_address = logical_addr_ptr;
 177                 mm->physical_address = address;
 178                 mm->length = map_length;
 179
 180                 /*
 181                  * Add the new entry to the mappigs list and save it as the
 182                  * current mapping.
 183                  */
 184                 mm->next_mm = mem_info->first_mm;
 185                 mem_info->first_mm = mm;
 186
 187                 mem_info->cur_mm = mm;
 188         }
 189
 190 access:
 191         /*
 192          * Generate a logical pointer corresponding to the address we want to
 193          * access
 194          */
 195         logical_addr_ptr = mm->logical_address +
 196                 ((u64) address - (u64) mm->physical_address);
 197
 198         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 199                           "System-Memory (width %u) R/W %u Address=%8.8X%8.8X\n",
 200                           bit_width, function, ACPI_FORMAT_UINT64(address)));
 201
 202         /*
 203          * Perform the memory read or write
 204          *
 205          * Note: For machines that do not support non-aligned transfers, the target
 206          * address was checked for alignment above. We do not attempt to break the
 207          * transfer up into smaller (byte-size) chunks because the AML specifically
 208          * asked for a transfer width that the hardware may require.
 209          */
 210         switch (function) {
 211         case ACPI_READ:
 212
 213                 *value = 0;
 214                 switch (bit_width) {
 215                 case 8:
 216
 217                         *value = (u64)ACPI_GET8(logical_addr_ptr);
 218                         break;
 219
 220                 case 16:
 221
 222                         *value = (u64)ACPI_GET16(logical_addr_ptr);
 223                         break;
 224
 225                 case 32:
 226
 227                         *value = (u64)ACPI_GET32(logical_addr_ptr);
 228                         break;
 229
 230                 case 64:
 231
 232                         *value = (u64)ACPI_GET64(logical_addr_ptr);
 233                         break;
 234
 235                 default:
 236
 237                         /* bit_width was already validated */
 238
 239                         break;
 240                 }
 241                 break;
 242
 243         case ACPI_WRITE:
 244
 245                 switch (bit_width) {
 246                 case 8:
 247
 248                         ACPI_SET8(logical_addr_ptr, *value);
 249                         break;
 250
 251                 case 16:
 252
 253                         ACPI_SET16(logical_addr_ptr, *value);
 254                         break;
 255
 256                 case 32:
 257
 258                         ACPI_SET32(logical_addr_ptr, *value);
 259                         break;
 260
 261                 case 64:
 262
 263                         ACPI_SET64(logical_addr_ptr, *value);
 264                         break;
 265
 266                 default:
 267
 268                         /* bit_width was already validated */
 269
 270                         break;
 271                 }
 272                 break;
 273
 274         default:
 275
 276                 status = AE_BAD_PARAMETER;
 277                 break;
 278         }
 279
 280         return_ACPI_STATUS(status);
 281 }
 282
 283 /*******************************************************************************
 284  *
 285  * FUNCTION:    acpi_ex_system_io_space_handler
 286  *
 287  * PARAMETERS:  function            - Read or Write operation
 288  *              address             - Where in the space to read or write
 289  *              bit_width           - Field width in bits (8, 16, or 32)
 290  *              value               - Pointer to in or out value
 291  *              handler_context     - Pointer to Handler's context
 292  *              region_context      - Pointer to context specific to the
 293  *                                    accessed region
 294  *
 295  * RETURN:      Status
 296  *
 297  * DESCRIPTION: Handler for the System IO address space (Op Region)
 298  *
 299  ******************************************************************************/
 300
 301 acpi_status
 302 acpi_ex_system_io_space_handler(u32 function,
 303                                 acpi_physical_address address,
 304                                 u32 bit_width,
 305                                 u64 *value,
 306                                 void *handler_context, void *region_context)
 307 {
 308         acpi_status status = AE_OK;
 309         u32 value32;
 310
 311         ACPI_FUNCTION_TRACE(ex_system_io_space_handler);
 312
 313         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 314                           "System-IO (width %u) R/W %u Address=%8.8X%8.8X\n",
 315                           bit_width, function, ACPI_FORMAT_UINT64(address)));
 316
 317         /* Decode the function parameter */
 318
 319         switch (function) {
 320         case ACPI_READ:
 321
 322                 status = acpi_hw_read_port((acpi_io_address)address,
 323                                            &value32, bit_width);
 324                 *value = value32;
 325                 break;
 326
 327         case ACPI_WRITE:
 328
 329                 status = acpi_hw_write_port((acpi_io_address)address,
 330                                             (u32)*value, bit_width);
 331                 break;
 332
 333         default:
 334
 335                 status = AE_BAD_PARAMETER;
 336                 break;
 337         }
 338
 339         return_ACPI_STATUS(status);
 340 }
 341
 342 #ifdef ACPI_PCI_CONFIGURED
 343 /*******************************************************************************
 344  *
 345  * FUNCTION:    acpi_ex_pci_config_space_handler
 346  *
 347  * PARAMETERS:  function            - Read or Write operation
 348  *              address             - Where in the space to read or write
 349  *              bit_width           - Field width in bits (8, 16, or 32)
 350  *              value               - Pointer to in or out value
 351  *              handler_context     - Pointer to Handler's context
 352  *              region_context      - Pointer to context specific to the
 353  *                                    accessed region
 354  *
 355  * RETURN:      Status
 356  *
 357  * DESCRIPTION: Handler for the PCI Config address space (Op Region)
 358  *
 359  ******************************************************************************/
 360
 361 acpi_status
 362 acpi_ex_pci_config_space_handler(u32 function,
 363                                  acpi_physical_address address,
 364                                  u32 bit_width,
 365                                  u64 *value,
 366                                  void *handler_context, void *region_context)
 367 {
 368         acpi_status status = AE_OK;
 369         struct acpi_pci_id *pci_id;
 370         u16 pci_register;
 371
 372         ACPI_FUNCTION_TRACE(ex_pci_config_space_handler);
 373
 374         /*
 375          *  The arguments to acpi_os(Read|Write)pci_configuration are:
 376          *
 377          *  pci_segment is the PCI bus segment range 0-31
 378          *  pci_bus     is the PCI bus number range 0-255
 379          *  pci_device  is the PCI device number range 0-31
 380          *  pci_function is the PCI device function number
 381          *  pci_register is the Config space register range 0-255 bytes
 382          *
 383          *  value - input value for write, output address for read
 384          *
 385          */
 386         pci_id = (struct acpi_pci_id *)region_context;
 387         pci_register = (u16) (u32) address;
 388
 389         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 390                           "Pci-Config %u (%u) Seg(%04x) Bus(%04x) "
 391                           "Dev(%04x) Func(%04x) Reg(%04x)\n",
 392                           function, bit_width, pci_id->segment, pci_id->bus,
 393                           pci_id->device, pci_id->function, pci_register));
 394
 395         switch (function) {
 396         case ACPI_READ:
 397
 398                 *value = 0;
 399                 status =
 400                     acpi_os_read_pci_configuration(pci_id, pci_register, value,
 401                                                    bit_width);
 402                 break;
 403
 404         case ACPI_WRITE:
 405
 406                 status =
 407                     acpi_os_write_pci_configuration(pci_id, pci_register,
 408                                                     *value, bit_width);
 409                 break;
 410
 411         default:
 412
 413                 status = AE_BAD_PARAMETER;
 414                 break;
 415         }
 416
 417         return_ACPI_STATUS(status);
 418 }
 419 #endif
 420
 421 /*******************************************************************************
 422  *
 423  * FUNCTION:    acpi_ex_cmos_space_handler
 424  *
 425  * PARAMETERS:  function            - Read or Write operation
 426  *              address             - Where in the space to read or write
 427  *              bit_width           - Field width in bits (8, 16, or 32)
 428  *              value               - Pointer to in or out value
 429  *              handler_context     - Pointer to Handler's context
 430  *              region_context      - Pointer to context specific to the
 431  *                                    accessed region
 432  *
 433  * RETURN:      Status
 434  *
 435  * DESCRIPTION: Handler for the CMOS address space (Op Region)
 436  *
 437  ******************************************************************************/
 438
 439 acpi_status
 440 acpi_ex_cmos_space_handler(u32 function,
 441                            acpi_physical_address address,
 442                            u32 bit_width,
 443                            u64 *value,
 444                            void *handler_context, void *region_context)
 445 {
 446         acpi_status status = AE_OK;
 447
 448         ACPI_FUNCTION_TRACE(ex_cmos_space_handler);
 449
 450         return_ACPI_STATUS(status);
 451 }
 452
 453 #ifdef ACPI_PCI_CONFIGURED
 454 /*******************************************************************************
 455  *
 456  * FUNCTION:    acpi_ex_pci_bar_space_handler
 457  *
 458  * PARAMETERS:  function            - Read or Write operation
 459  *              address             - Where in the space to read or write
 460  *              bit_width           - Field width in bits (8, 16, or 32)
 461  *              value               - Pointer to in or out value
 462  *              handler_context     - Pointer to Handler's context
 463  *              region_context      - Pointer to context specific to the
 464  *                                    accessed region
 465  *
 466  * RETURN:      Status
 467  *
 468  * DESCRIPTION: Handler for the PCI bar_target address space (Op Region)
 469  *
 470  ******************************************************************************/
 471
 472 acpi_status
 473 acpi_ex_pci_bar_space_handler(u32 function,
 474                               acpi_physical_address address,
 475                               u32 bit_width,
 476                               u64 *value,
 477                               void *handler_context, void *region_context)
 478 {
 479         acpi_status status = AE_OK;
 480
 481         ACPI_FUNCTION_TRACE(ex_pci_bar_space_handler);
 482
 483         return_ACPI_STATUS(status);
 484 }
 485 #endif
 486
 487 /*******************************************************************************
 488  *
 489  * FUNCTION:    acpi_ex_data_table_space_handler
 490  *
 491  * PARAMETERS:  function            - Read or Write operation
 492  *              address             - Where in the space to read or write
 493  *              bit_width           - Field width in bits (8, 16, or 32)
 494  *              value               - Pointer to in or out value
 495  *              handler_context     - Pointer to Handler's context
 496  *              region_context      - Pointer to context specific to the
 497  *                                    accessed region
 498  *
 499  * RETURN:      Status
 500  *
 501  * DESCRIPTION: Handler for the Data Table address space (Op Region)
 502  *
 503  ******************************************************************************/
 504
 505 acpi_status
 506 acpi_ex_data_table_space_handler(u32 function,
 507                                  acpi_physical_address address,
 508                                  u32 bit_width,
 509                                  u64 *value,
 510                                  void *handler_context, void *region_context)
 511 {
 512         ACPI_FUNCTION_TRACE(ex_data_table_space_handler);
 513
 514         /*
 515          * Perform the memory read or write. The bit_width was already
 516          * validated.
 517          */
 518         switch (function) {
 519         case ACPI_READ:
 520
 521                 memcpy(ACPI_CAST_PTR(char, value),
 522                        ACPI_PHYSADDR_TO_PTR(address), ACPI_DIV_8(bit_width));
 523                 break;
 524
 525         case ACPI_WRITE:
 526
 527                 memcpy(ACPI_PHYSADDR_TO_PTR(address),
 528                        ACPI_CAST_PTR(char, value), ACPI_DIV_8(bit_width));
 529                 break;
 530
 531         default:
 532
 533                 return_ACPI_STATUS(AE_BAD_PARAMETER);
 534         }
 535
 536         return_ACPI_STATUS(AE_OK);
 537 }