drivers/acpi/namespace/nsxfname.c

   1 /******************************************************************************
   2  *
   3  * Module Name: nsxfname - Public interfaces to the ACPI subsystem
   4  *                         ACPI Namespace oriented interfaces
   5  *              $Revision: 73 $
   6  *
   7  *****************************************************************************/
   8
   9 /*
  10  *  Copyright (C) 2000 R. Byron Moore
  11  *
  12  *  This program is free software; you can redistribute it and/or modify
  13  *  it under the terms of the GNU General Public License as published by
  14  *  the Free Software Foundation; either version 2 of the License, or
  15  *  (at your option) any later version.
  16  *
  17  *  This program is distributed in the hope that it will be useful,
  18  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  *  GNU General Public License for more details.
  21  *
  22  *  You should have received a copy of the GNU General Public License
  23  *  along with this program; if not, write to the Free Software
  24  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  25  */
  26
  27
  28 #include "acpi.h"
  29 #include "acinterp.h"
  30 #include "acnamesp.h"
  31 #include "amlcode.h"
  32 #include "acparser.h"
  33 #include "acdispat.h"
  34 #include "acevents.h"
  35
  36
  37 #define _COMPONENT          NAMESPACE
  38          MODULE_NAME         ("nsxfname")
  39
  40
  41 /****************************************************************************
  42  *
  43  * FUNCTION:    Acpi_get_handle
  44  *
  45  * PARAMETERS:  Parent          - Object to search under (search scope).
  46  *              Path_name       - Pointer to an asciiz string containing the
  47  *                                  name
  48  *              Ret_handle      - Where the return handle is placed
  49  *
  50  * RETURN:      Status
  51  *
  52  * DESCRIPTION: This routine will search for a caller specified name in the
  53  *              name space.  The caller can restrict the search region by
  54  *              specifying a non NULL parent.  The parent value is itself a
  55  *              namespace handle.
  56  *
  57  ******************************************************************************/
  58
  59 ACPI_STATUS
  60 acpi_get_handle (
  61         ACPI_HANDLE             parent,
  62         ACPI_STRING             pathname,
  63         ACPI_HANDLE             *ret_handle)
  64 {
  65         ACPI_STATUS             status;
  66         ACPI_NAMESPACE_NODE     *node = NULL;
  67         ACPI_NAMESPACE_NODE     *prefix_node = NULL;
  68
  69
  70         if (!ret_handle || !pathname) {
  71                 return (AE_BAD_PARAMETER);
  72         }
  73
  74         /* Convert a parent handle to a prefix node */
  75
  76         if (parent) {
  77                 acpi_cm_acquire_mutex (ACPI_MTX_NAMESPACE);
  78
  79                 prefix_node = acpi_ns_convert_handle_to_entry (parent);
  80                 if (!prefix_node) {
  81                         acpi_cm_release_mutex (ACPI_MTX_NAMESPACE);
  82                         return (AE_BAD_PARAMETER);
  83                 }
  84
  85                 acpi_cm_release_mutex (ACPI_MTX_NAMESPACE);
  86         }
  87
  88         /* Special case for root, since we can't search for it */
  89
  90         if (STRCMP (pathname, NS_ROOT_PATH) == 0) {
  91                 *ret_handle = acpi_ns_convert_entry_to_handle (acpi_gbl_root_node);
  92                 return (AE_OK);
  93         }
  94
  95         /*
  96          *  Find the Node and convert to a handle
  97          */
  98         status = acpi_ns_get_node (pathname, prefix_node, &node);
  99
 100         *ret_handle = NULL;
 101         if (ACPI_SUCCESS (status)) {
 102                 *ret_handle = acpi_ns_convert_entry_to_handle (node);
 103         }
 104
 105         return (status);
 106 }
 107
 108
 109 /****************************************************************************
 110  *
 111  * FUNCTION:    Acpi_get_pathname
 112  *
 113  * PARAMETERS:  Handle          - Handle to be converted to a pathname
 114  *              Name_type       - Full pathname or single segment
 115  *              Ret_path_ptr    - Buffer for returned path
 116  *
 117  * RETURN:      Pointer to a string containing the fully qualified Name.
 118  *
 119  * DESCRIPTION: This routine returns the fully qualified name associated with
 120  *              the Handle parameter.  This and the Acpi_pathname_to_handle are
 121  *              complementary functions.
 122  *
 123  ******************************************************************************/
 124
 125 ACPI_STATUS
 126 acpi_get_name (
 127         ACPI_HANDLE             handle,
 128         u32                     name_type,
 129         ACPI_BUFFER             *ret_path_ptr)
 130 {
 131         ACPI_STATUS             status;
 132         ACPI_NAMESPACE_NODE     *node;
 133
 134
 135         /* Buffer pointer must be valid always */
 136
 137         if (!ret_path_ptr || (name_type > ACPI_NAME_TYPE_MAX)) {
 138                 return (AE_BAD_PARAMETER);
 139         }
 140
 141         /* Allow length to be zero and ignore the pointer */
 142
 143         if ((ret_path_ptr->length) &&
 144            (!ret_path_ptr->pointer))
 145         {
 146                 return (AE_BAD_PARAMETER);
 147         }
 148
 149         if (name_type == ACPI_FULL_PATHNAME) {
 150                 /* Get the full pathname (From the namespace root) */
 151
 152                 status = acpi_ns_handle_to_pathname (handle, &ret_path_ptr->length,
 153                                    ret_path_ptr->pointer);
 154                 return (status);
 155         }
 156
 157         /*
 158          * Wants the single segment ACPI name.
 159          * Validate handle and convert to an Node
 160          */
 161
 162         acpi_cm_acquire_mutex (ACPI_MTX_NAMESPACE);
 163         node = acpi_ns_convert_handle_to_entry (handle);
 164         if (!node) {
 165                 status = AE_BAD_PARAMETER;
 166                 goto unlock_and_exit;
 167         }
 168
 169         /* Check if name will fit in buffer */
 170
 171         if (ret_path_ptr->length < PATH_SEGMENT_LENGTH) {
 172                 ret_path_ptr->length = PATH_SEGMENT_LENGTH;
 173                 status = AE_BUFFER_OVERFLOW;
 174                 goto unlock_and_exit;
 175         }
 176
 177         /* Just copy the ACPI name from the Node and zero terminate it */
 178
 179         STRNCPY (ret_path_ptr->pointer, (NATIVE_CHAR *) &node->name,
 180                          ACPI_NAME_SIZE);
 181         ((NATIVE_CHAR *) ret_path_ptr->pointer) [ACPI_NAME_SIZE] = 0;
 182         status = AE_OK;
 183
 184
 185 unlock_and_exit:
 186
 187         acpi_cm_release_mutex (ACPI_MTX_NAMESPACE);
 188         return (status);
 189 }
 190
 191
 192 /****************************************************************************
 193  *
 194  * FUNCTION:    Acpi_get_object_info
 195  *
 196  * PARAMETERS:  Handle          - Object Handle
 197  *              Info            - Where the info is returned
 198  *
 199  * RETURN:      Status
 200  *
 201  * DESCRIPTION: Returns information about an object as gleaned from the
 202  *              namespace node and possibly by running several standard
 203  *              control methods (Such as in the case of a device.)
 204  *
 205  ******************************************************************************/
 206
 207 ACPI_STATUS
 208 acpi_get_object_info (
 209         ACPI_HANDLE             handle,
 210         ACPI_DEVICE_INFO        *info)
 211 {
 212         DEVICE_ID               hid;
 213         DEVICE_ID               uid;
 214         ACPI_STATUS             status;
 215         u32                     device_status = 0;
 216         ACPI_INTEGER            address = 0;
 217         ACPI_NAMESPACE_NODE     *node;
 218
 219
 220         /* Parameter validation */
 221
 222         if (!handle || !info) {
 223                 return (AE_BAD_PARAMETER);
 224         }
 225
 226         acpi_cm_acquire_mutex (ACPI_MTX_NAMESPACE);
 227
 228         node = acpi_ns_convert_handle_to_entry (handle);
 229         if (!node) {
 230                 acpi_cm_release_mutex (ACPI_MTX_NAMESPACE);
 231                 return (AE_BAD_PARAMETER);
 232         }
 233
 234         info->type      = node->type;
 235         info->name      = node->name;
 236
 237         acpi_cm_release_mutex (ACPI_MTX_NAMESPACE);
 238
 239         /*
 240          * If not a device, we are all done.
 241          */
 242         if (info->type != ACPI_TYPE_DEVICE) {
 243                 return (AE_OK);
 244         }
 245
 246
 247         /*
 248          * Get extra info for ACPI devices only.  Run the
 249          * _HID, _UID, _STA, and _ADR methods.  Note: none
 250          * of these methods are required, so they may or may
 251          * not be present.  The Info->Valid bits are used
 252          * to indicate which methods ran successfully.
 253          */
 254
 255         info->valid = 0;
 256
 257         /* Execute the _HID method and save the result */
 258
 259         status = acpi_cm_execute_HID (node, &hid);
 260         if (ACPI_SUCCESS (status)) {
 261                 STRNCPY (info->hardware_id, hid.buffer, sizeof(info->hardware_id));
 262
 263                 info->valid |= ACPI_VALID_HID;
 264         }
 265
 266         /* Execute the _UID method and save the result */
 267
 268         status = acpi_cm_execute_UID (node, &uid);
 269         if (ACPI_SUCCESS (status)) {
 270                 STRCPY (info->unique_id, uid.buffer);
 271
 272                 info->valid |= ACPI_VALID_UID;
 273         }
 274
 275         /*
 276          * Execute the _STA method and save the result
 277          * _STA is not always present
 278          */
 279
 280         status = acpi_cm_execute_STA (node, &device_status);
 281         if (ACPI_SUCCESS (status)) {
 282                 info->current_status = device_status;
 283                 info->valid |= ACPI_VALID_STA;
 284         }
 285
 286         /*
 287          * Execute the _ADR method and save result if successful
 288          * _ADR is not always present
 289          */
 290
 291         status = acpi_cm_evaluate_numeric_object (METHOD_NAME__ADR,
 292                           node, &address);
 293
 294         if (ACPI_SUCCESS (status)) {
 295                 info->address = address;
 296                 info->valid |= ACPI_VALID_ADR;
 297         }
 298
 299         return (AE_OK);
 300 }
 301