drivers/acpi/acpica/nsxfname.c

   1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
   2 /******************************************************************************
   3  *
   4  * Module Name: nsxfname - Public interfaces to the ACPI subsystem
   5  *                         ACPI Namespace oriented interfaces
   6  *
   7  * Copyright (C) 2000 - 2020, Intel Corp.
   8  *
   9  *****************************************************************************/
  10
  11 #define EXPORT_ACPI_INTERFACES
  12
  13 #include <acpi/acpi.h>
  14 #include "accommon.h"
  15 #include "acnamesp.h"
  16 #include "acparser.h"
  17 #include "amlcode.h"
  18
  19 #define _COMPONENT          ACPI_NAMESPACE
  20 ACPI_MODULE_NAME("nsxfname")
  21
  22 /* Local prototypes */
  23 static char *acpi_ns_copy_device_id(struct acpi_pnp_device_id *dest,
  24                                     struct acpi_pnp_device_id *source,
  25                                     char *string_area);
  26
  27 /******************************************************************************
  28  *
  29  * FUNCTION:    acpi_get_handle
  30  *
  31  * PARAMETERS:  parent          - Object to search under (search scope).
  32  *              pathname        - Pointer to an asciiz string containing the
  33  *                                name
  34  *              ret_handle      - Where the return handle is returned
  35  *
  36  * RETURN:      Status
  37  *
  38  * DESCRIPTION: This routine will search for a caller specified name in the
  39  *              name space. The caller can restrict the search region by
  40  *              specifying a non NULL parent. The parent value is itself a
  41  *              namespace handle.
  42  *
  43  ******************************************************************************/
  44
  45 acpi_status
  46 acpi_get_handle(acpi_handle parent,
  47                 acpi_string pathname, acpi_handle *ret_handle)
  48 {
  49         acpi_status status;
  50         struct acpi_namespace_node *node = NULL;
  51         struct acpi_namespace_node *prefix_node = NULL;
  52
  53         ACPI_FUNCTION_ENTRY();
  54
  55         /* Parameter Validation */
  56
  57         if (!ret_handle || !pathname) {
  58                 return (AE_BAD_PARAMETER);
  59         }
  60
  61         /* Convert a parent handle to a prefix node */
  62
  63         if (parent) {
  64                 prefix_node = acpi_ns_validate_handle(parent);
  65                 if (!prefix_node) {
  66                         return (AE_BAD_PARAMETER);
  67                 }
  68         }
  69
  70         /*
  71          * Valid cases are:
  72          * 1) Fully qualified pathname
  73          * 2) Parent + Relative pathname
  74          *
  75          * Error for <null Parent + relative path>
  76          */
  77         if (ACPI_IS_ROOT_PREFIX(pathname[0])) {
  78
  79                 /* Pathname is fully qualified (starts with '\') */
  80
  81                 /* Special case for root-only, since we can't search for it */
  82
  83                 if (!strcmp(pathname, ACPI_NS_ROOT_PATH)) {
  84                         *ret_handle =
  85                             ACPI_CAST_PTR(acpi_handle, acpi_gbl_root_node);
  86                         return (AE_OK);
  87                 }
  88         } else if (!prefix_node) {
  89
  90                 /* Relative path with null prefix is disallowed */
  91
  92                 return (AE_BAD_PARAMETER);
  93         }
  94
  95         /* Find the Node and convert to a handle */
  96
  97         status =
  98             acpi_ns_get_node(prefix_node, pathname, ACPI_NS_NO_UPSEARCH, &node);
  99         if (ACPI_SUCCESS(status)) {
 100                 *ret_handle = ACPI_CAST_PTR(acpi_handle, node);
 101         }
 102
 103         return (status);
 104 }
 105
 106 ACPI_EXPORT_SYMBOL(acpi_get_handle)
 107
 108 /******************************************************************************
 109  *
 110  * FUNCTION:    acpi_get_name
 111  *
 112  * PARAMETERS:  handle          - Handle to be converted to a pathname
 113  *              name_type       - Full pathname or single segment
 114  *              buffer          - Buffer for returned path
 115  *
 116  * RETURN:      Pointer to a string containing the fully qualified Name.
 117  *
 118  * DESCRIPTION: This routine returns the fully qualified name associated with
 119  *              the Handle parameter. This and the acpi_pathname_to_handle are
 120  *              complementary functions.
 121  *
 122  ******************************************************************************/
 123 acpi_status
 124 acpi_get_name(acpi_handle handle, u32 name_type, struct acpi_buffer *buffer)
 125 {
 126         acpi_status status;
 127
 128         /* Parameter validation */
 129
 130         if (name_type > ACPI_NAME_TYPE_MAX) {
 131                 return (AE_BAD_PARAMETER);
 132         }
 133
 134         status = acpi_ut_validate_buffer(buffer);
 135         if (ACPI_FAILURE(status)) {
 136                 return (status);
 137         }
 138
 139         /*
 140          * Wants the single segment ACPI name.
 141          * Validate handle and convert to a namespace Node
 142          */
 143         status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
 144         if (ACPI_FAILURE(status)) {
 145                 return (status);
 146         }
 147
 148         if (name_type == ACPI_FULL_PATHNAME ||
 149             name_type == ACPI_FULL_PATHNAME_NO_TRAILING) {
 150
 151                 /* Get the full pathname (From the namespace root) */
 152
 153                 status = acpi_ns_handle_to_pathname(handle, buffer,
 154                                                     name_type ==
 155                                                     ACPI_FULL_PATHNAME ? FALSE :
 156                                                     TRUE);
 157         } else {
 158                 /* Get the single name */
 159
 160                 status = acpi_ns_handle_to_name(handle, buffer);
 161         }
 162
 163         (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
 164         return (status);
 165 }
 166
 167 ACPI_EXPORT_SYMBOL(acpi_get_name)
 168
 169 /******************************************************************************
 170  *
 171  * FUNCTION:    acpi_ns_copy_device_id
 172  *
 173  * PARAMETERS:  dest                - Pointer to the destination PNP_DEVICE_ID
 174  *              source              - Pointer to the source PNP_DEVICE_ID
 175  *              string_area         - Pointer to where to copy the dest string
 176  *
 177  * RETURN:      Pointer to the next string area
 178  *
 179  * DESCRIPTION: Copy a single PNP_DEVICE_ID, including the string data.
 180  *
 181  ******************************************************************************/
 182 static char *acpi_ns_copy_device_id(struct acpi_pnp_device_id *dest,
 183                                     struct acpi_pnp_device_id *source,
 184                                     char *string_area)
 185 {
 186         /* Create the destination PNP_DEVICE_ID */
 187
 188         dest->string = string_area;
 189         dest->length = source->length;
 190
 191         /* Copy actual string and return a pointer to the next string area */
 192
 193         memcpy(string_area, source->string, source->length);
 194         return (string_area + source->length);
 195 }
 196
 197 /******************************************************************************
 198  *
 199  * FUNCTION:    acpi_get_object_info
 200  *
 201  * PARAMETERS:  handle              - Object Handle
 202  *              return_buffer       - Where the info is returned
 203  *
 204  * RETURN:      Status
 205  *
 206  * DESCRIPTION: Returns information about an object as gleaned from the
 207  *              namespace node and possibly by running several standard
 208  *              control methods (Such as in the case of a device.)
 209  *
 210  * For Device and Processor objects, run the Device _HID, _UID, _CID,
 211  * _CLS, _ADR, _sx_w, and _sx_d methods.
 212  *
 213  * Note: Allocates the return buffer, must be freed by the caller.
 214  *
 215  * Note: This interface is intended to be used during the initial device
 216  * discovery namespace traversal. Therefore, no complex methods can be
 217  * executed, especially those that access operation regions. Therefore, do
 218  * not add any additional methods that could cause problems in this area.
 219  * Because of this reason support for the following methods has been removed:
 220  * 1) _SUB method was removed (11/2015)
 221  * 2) _STA method was removed (02/2018)
 222  *
 223  ******************************************************************************/
 224
 225 acpi_status
 226 acpi_get_object_info(acpi_handle handle,
 227                      struct acpi_device_info **return_buffer)
 228 {
 229         struct acpi_namespace_node *node;
 230         struct acpi_device_info *info;
 231         struct acpi_pnp_device_id_list *cid_list = NULL;
 232         struct acpi_pnp_device_id *hid = NULL;
 233         struct acpi_pnp_device_id *uid = NULL;
 234         struct acpi_pnp_device_id *cls = NULL;
 235         char *next_id_string;
 236         acpi_object_type type;
 237         acpi_name name;
 238         u8 param_count = 0;
 239         u16 valid = 0;
 240         u32 info_size;
 241         u32 i;
 242         acpi_status status;
 243
 244         /* Parameter validation */
 245
 246         if (!handle || !return_buffer) {
 247                 return (AE_BAD_PARAMETER);
 248         }
 249
 250         status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
 251         if (ACPI_FAILURE(status)) {
 252                 return (status);
 253         }
 254
 255         node = acpi_ns_validate_handle(handle);
 256         if (!node) {
 257                 (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
 258                 return (AE_BAD_PARAMETER);
 259         }
 260
 261         /* Get the namespace node data while the namespace is locked */
 262
 263         info_size = sizeof(struct acpi_device_info);
 264         type = node->type;
 265         name = node->name.integer;
 266
 267         if (node->type == ACPI_TYPE_METHOD) {
 268                 param_count = node->object->method.param_count;
 269         }
 270
 271         status = acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
 272         if (ACPI_FAILURE(status)) {
 273                 return (status);
 274         }
 275
 276         if ((type == ACPI_TYPE_DEVICE) || (type == ACPI_TYPE_PROCESSOR)) {
 277                 /*
 278                  * Get extra info for ACPI Device/Processor objects only:
 279                  * Run the Device _HID, _UID, _CLS, and _CID methods.
 280                  *
 281                  * Note: none of these methods are required, so they may or may
 282                  * not be present for this device. The Info->Valid bitfield is used
 283                  * to indicate which methods were found and run successfully.
 284                  */
 285
 286                 /* Execute the Device._HID method */
 287
 288                 status = acpi_ut_execute_HID(node, &hid);
 289                 if (ACPI_SUCCESS(status)) {
 290                         info_size += hid->length;
 291                         valid |= ACPI_VALID_HID;
 292                 }
 293
 294                 /* Execute the Device._UID method */
 295
 296                 status = acpi_ut_execute_UID(node, &uid);
 297                 if (ACPI_SUCCESS(status)) {
 298                         info_size += uid->length;
 299                         valid |= ACPI_VALID_UID;
 300                 }
 301
 302                 /* Execute the Device._CID method */
 303
 304                 status = acpi_ut_execute_CID(node, &cid_list);
 305                 if (ACPI_SUCCESS(status)) {
 306
 307                         /* Add size of CID strings and CID pointer array */
 308
 309                         info_size +=
 310                             (cid_list->list_size -
 311                              sizeof(struct acpi_pnp_device_id_list));
 312                         valid |= ACPI_VALID_CID;
 313                 }
 314
 315                 /* Execute the Device._CLS method */
 316
 317                 status = acpi_ut_execute_CLS(node, &cls);
 318                 if (ACPI_SUCCESS(status)) {
 319                         info_size += cls->length;
 320                         valid |= ACPI_VALID_CLS;
 321                 }
 322         }
 323
 324         /*
 325          * Now that we have the variable-length data, we can allocate the
 326          * return buffer
 327          */
 328         info = ACPI_ALLOCATE_ZEROED(info_size);
 329         if (!info) {
 330                 status = AE_NO_MEMORY;
 331                 goto cleanup;
 332         }
 333
 334         /* Get the fixed-length data */
 335
 336         if ((type == ACPI_TYPE_DEVICE) || (type == ACPI_TYPE_PROCESSOR)) {
 337                 /*
 338                  * Get extra info for ACPI Device/Processor objects only:
 339                  * Run the _ADR and, sx_w, and _sx_d methods.
 340                  *
 341                  * Notes: none of these methods are required, so they may or may
 342                  * not be present for this device. The Info->Valid bitfield is used
 343                  * to indicate which methods were found and run successfully.
 344                  */
 345
 346                 /* Execute the Device._ADR method */
 347
 348                 status = acpi_ut_evaluate_numeric_object(METHOD_NAME__ADR, node,
 349                                                          &info->address);
 350                 if (ACPI_SUCCESS(status)) {
 351                         valid |= ACPI_VALID_ADR;
 352                 }
 353
 354                 /* Execute the Device._sx_w methods */
 355
 356                 status = acpi_ut_execute_power_methods(node,
 357                                                        acpi_gbl_lowest_dstate_names,
 358                                                        ACPI_NUM_sx_w_METHODS,
 359                                                        info->lowest_dstates);
 360                 if (ACPI_SUCCESS(status)) {
 361                         valid |= ACPI_VALID_SXWS;
 362                 }
 363
 364                 /* Execute the Device._sx_d methods */
 365
 366                 status = acpi_ut_execute_power_methods(node,
 367                                                        acpi_gbl_highest_dstate_names,
 368                                                        ACPI_NUM_sx_d_METHODS,
 369                                                        info->highest_dstates);
 370                 if (ACPI_SUCCESS(status)) {
 371                         valid |= ACPI_VALID_SXDS;
 372                 }
 373         }
 374
 375         /*
 376          * Create a pointer to the string area of the return buffer.
 377          * Point to the end of the base struct acpi_device_info structure.
 378          */
 379         next_id_string = ACPI_CAST_PTR(char, info->compatible_id_list.ids);
 380         if (cid_list) {
 381
 382                 /* Point past the CID PNP_DEVICE_ID array */
 383
 384                 next_id_string +=
 385                     ((acpi_size)cid_list->count *
 386                      sizeof(struct acpi_pnp_device_id));
 387         }
 388
 389         /*
 390          * Copy the HID, UID, and CIDs to the return buffer. The variable-length
 391          * strings are copied to the reserved area at the end of the buffer.
 392          *
 393          * For HID and CID, check if the ID is a PCI Root Bridge.
 394          */
 395         if (hid) {
 396                 next_id_string = acpi_ns_copy_device_id(&info->hardware_id,
 397                                                         hid, next_id_string);
 398
 399                 if (acpi_ut_is_pci_root_bridge(hid->string)) {
 400                         info->flags |= ACPI_PCI_ROOT_BRIDGE;
 401                 }
 402         }
 403
 404         if (uid) {
 405                 next_id_string = acpi_ns_copy_device_id(&info->unique_id,
 406                                                         uid, next_id_string);
 407         }
 408
 409         if (cid_list) {
 410                 info->compatible_id_list.count = cid_list->count;
 411                 info->compatible_id_list.list_size = cid_list->list_size;
 412
 413                 /* Copy each CID */
 414
 415                 for (i = 0; i < cid_list->count; i++) {
 416                         next_id_string =
 417                             acpi_ns_copy_device_id(&info->compatible_id_list.
 418                                                    ids[i], &cid_list->ids[i],
 419                                                    next_id_string);
 420
 421                         if (acpi_ut_is_pci_root_bridge(cid_list->ids[i].string)) {
 422                                 info->flags |= ACPI_PCI_ROOT_BRIDGE;
 423                         }
 424                 }
 425         }
 426
 427         if (cls) {
 428                 (void)acpi_ns_copy_device_id(&info->class_code,
 429                                              cls, next_id_string);
 430         }
 431
 432         /* Copy the fixed-length data */
 433
 434         info->info_size = info_size;
 435         info->type = type;
 436         info->name = name;
 437         info->param_count = param_count;
 438         info->valid = valid;
 439
 440         *return_buffer = info;
 441         status = AE_OK;
 442
 443 cleanup:
 444         if (hid) {
 445                 ACPI_FREE(hid);
 446         }
 447         if (uid) {
 448                 ACPI_FREE(uid);
 449         }
 450         if (cid_list) {
 451                 ACPI_FREE(cid_list);
 452         }
 453         if (cls) {
 454                 ACPI_FREE(cls);
 455         }
 456         return (status);
 457 }
 458
 459 ACPI_EXPORT_SYMBOL(acpi_get_object_info)
 460
 461 /******************************************************************************
 462  *
 463  * FUNCTION:    acpi_install_method
 464  *
 465  * PARAMETERS:  buffer         - An ACPI table containing one control method
 466  *
 467  * RETURN:      Status
 468  *
 469  * DESCRIPTION: Install a control method into the namespace. If the method
 470  *              name already exists in the namespace, it is overwritten. The
 471  *              input buffer must contain a valid DSDT or SSDT containing a
 472  *              single control method.
 473  *
 474  ******************************************************************************/
 475 acpi_status acpi_install_method(u8 *buffer)
 476 {
 477         struct acpi_table_header *table =
 478             ACPI_CAST_PTR(struct acpi_table_header, buffer);
 479         u8 *aml_buffer;
 480         u8 *aml_start;
 481         char *path;
 482         struct acpi_namespace_node *node;
 483         union acpi_operand_object *method_obj;
 484         struct acpi_parse_state parser_state;
 485         u32 aml_length;
 486         u16 opcode;
 487         u8 method_flags;
 488         acpi_status status;
 489
 490         /* Parameter validation */
 491
 492         if (!buffer) {
 493                 return (AE_BAD_PARAMETER);
 494         }
 495
 496         /* Table must be a DSDT or SSDT */
 497
 498         if (!ACPI_COMPARE_NAMESEG(table->signature, ACPI_SIG_DSDT) &&
 499             !ACPI_COMPARE_NAMESEG(table->signature, ACPI_SIG_SSDT)) {
 500                 return (AE_BAD_HEADER);
 501         }
 502
 503         /* First AML opcode in the table must be a control method */
 504
 505         parser_state.aml = buffer + sizeof(struct acpi_table_header);
 506         opcode = acpi_ps_peek_opcode(&parser_state);
 507         if (opcode != AML_METHOD_OP) {
 508                 return (AE_BAD_PARAMETER);
 509         }
 510
 511         /* Extract method information from the raw AML */
 512
 513         parser_state.aml += acpi_ps_get_opcode_size(opcode);
 514         parser_state.pkg_end = acpi_ps_get_next_package_end(&parser_state);
 515         path = acpi_ps_get_next_namestring(&parser_state);
 516
 517         method_flags = *parser_state.aml++;
 518         aml_start = parser_state.aml;
 519         aml_length = ACPI_PTR_DIFF(parser_state.pkg_end, aml_start);
 520
 521         /*
 522          * Allocate resources up-front. We don't want to have to delete a new
 523          * node from the namespace if we cannot allocate memory.
 524          */
 525         aml_buffer = ACPI_ALLOCATE(aml_length);
 526         if (!aml_buffer) {
 527                 return (AE_NO_MEMORY);
 528         }
 529
 530         method_obj = acpi_ut_create_internal_object(ACPI_TYPE_METHOD);
 531         if (!method_obj) {
 532                 ACPI_FREE(aml_buffer);
 533                 return (AE_NO_MEMORY);
 534         }
 535
 536         /* Lock namespace for acpi_ns_lookup, we may be creating a new node */
 537
 538         status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
 539         if (ACPI_FAILURE(status)) {
 540                 goto error_exit;
 541         }
 542
 543         /* The lookup either returns an existing node or creates a new one */
 544
 545         status =
 546             acpi_ns_lookup(NULL, path, ACPI_TYPE_METHOD, ACPI_IMODE_LOAD_PASS1,
 547                            ACPI_NS_DONT_OPEN_SCOPE | ACPI_NS_ERROR_IF_FOUND,
 548                            NULL, &node);
 549
 550         (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
 551
 552         if (ACPI_FAILURE(status)) {     /* ns_lookup */
 553                 if (status != AE_ALREADY_EXISTS) {
 554                         goto error_exit;
 555                 }
 556
 557                 /* Node existed previously, make sure it is a method node */
 558
 559                 if (node->type != ACPI_TYPE_METHOD) {
 560                         status = AE_TYPE;
 561                         goto error_exit;
 562                 }
 563         }
 564
 565         /* Copy the method AML to the local buffer */
 566
 567         memcpy(aml_buffer, aml_start, aml_length);
 568
 569         /* Initialize the method object with the new method's information */
 570
 571         method_obj->method.aml_start = aml_buffer;
 572         method_obj->method.aml_length = aml_length;
 573
 574         method_obj->method.param_count = (u8)
 575             (method_flags & AML_METHOD_ARG_COUNT);
 576
 577         if (method_flags & AML_METHOD_SERIALIZED) {
 578                 method_obj->method.info_flags = ACPI_METHOD_SERIALIZED;
 579
 580                 method_obj->method.sync_level = (u8)
 581                     ((method_flags & AML_METHOD_SYNC_LEVEL) >> 4);
 582         }
 583
 584         /*
 585          * Now that it is complete, we can attach the new method object to
 586          * the method Node (detaches/deletes any existing object)
 587          */
 588         status = acpi_ns_attach_object(node, method_obj, ACPI_TYPE_METHOD);
 589
 590         /*
 591          * Flag indicates AML buffer is dynamic, must be deleted later.
 592          * Must be set only after attach above.
 593          */
 594         node->flags |= ANOBJ_ALLOCATED_BUFFER;
 595
 596         /* Remove local reference to the method object */
 597
 598         acpi_ut_remove_reference(method_obj);
 599         return (status);
 600
 601 error_exit:
 602
 603         ACPI_FREE(aml_buffer);
 604         ACPI_FREE(method_obj);
 605         return (status);
 606 }
 607 ACPI_EXPORT_SYMBOL(acpi_install_method)