drivers/acpi/common/cmeval.c

   1 /******************************************************************************
   2  *
   3  * Module Name: cmeval - Object evaluation
   4  *              $Revision: 19 $
   5  *
   6  *****************************************************************************/
   7
   8 /*
   9  *  Copyright (C) 2000 R. Byron Moore
  10  *
  11  *  This program is free software; you can redistribute it and/or modify
  12  *  it under the terms of the GNU General Public License as published by
  13  *  the Free Software Foundation; either version 2 of the License, or
  14  *  (at your option) any later version.
  15  *
  16  *  This program is distributed in the hope that it will be useful,
  17  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  *  GNU General Public License for more details.
  20  *
  21  *  You should have received a copy of the GNU General Public License
  22  *  along with this program; if not, write to the Free Software
  23  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  24  */
  25
  26
  27 #include "acpi.h"
  28 #include "acnamesp.h"
  29 #include "acinterp.h"
  30
  31
  32 #define _COMPONENT          MISCELLANEOUS
  33          MODULE_NAME         ("cmeval")
  34
  35
  36 /****************************************************************************
  37  *
  38  * FUNCTION:    Acpi_cm_evaluate_numeric_object
  39  *
  40  * PARAMETERS:  *Object_name        - Object name to be evaluated
  41  *              Device_node         - Node for the device
  42  *              *Address            - Where the value is returned
  43  *
  44  * RETURN:      Status
  45  *
  46  * DESCRIPTION: evaluates a numeric namespace object for a selected device
  47  *              and stores results in *Address.
  48  *
  49  *              NOTE: Internal function, no parameter validation
  50  *
  51  ***************************************************************************/
  52
  53 ACPI_STATUS
  54 acpi_cm_evaluate_numeric_object (
  55         NATIVE_CHAR             *object_name,
  56         ACPI_NAMESPACE_NODE     *device_node,
  57         ACPI_INTEGER            *address)
  58 {
  59         ACPI_OPERAND_OBJECT     *obj_desc;
  60         ACPI_STATUS             status;
  61
  62
  63         /* Execute the method */
  64
  65         status = acpi_ns_evaluate_relative (device_node, object_name, NULL, &obj_desc);
  66         if (ACPI_FAILURE (status)) {
  67
  68                 return (status);
  69         }
  70
  71
  72         /* Did we get a return object? */
  73
  74         if (!obj_desc) {
  75                 return (AE_TYPE);
  76         }
  77
  78         /* Is the return object of the correct type? */
  79
  80         if (obj_desc->common.type != ACPI_TYPE_NUMBER) {
  81                 status = AE_TYPE;
  82         }
  83         else {
  84                 /*
  85                  * Since the structure is a union, setting any field will set all
  86                  * of the variables in the union
  87                  */
  88                 *address = obj_desc->number.value;
  89         }
  90
  91         /* On exit, we must delete the return object */
  92
  93         acpi_cm_remove_reference (obj_desc);
  94
  95         return (status);
  96 }
  97
  98
  99 /****************************************************************************
 100  *
 101  * FUNCTION:    Acpi_cm_execute_HID
 102  *
 103  * PARAMETERS:  Device_node         - Node for the device
 104  *              *Hid                - Where the HID is returned
 105  *
 106  * RETURN:      Status
 107  *
 108  * DESCRIPTION: Executes the _HID control method that returns the hardware
 109  *              ID of the device.
 110  *
 111  *              NOTE: Internal function, no parameter validation
 112  *
 113  ***************************************************************************/
 114
 115 ACPI_STATUS
 116 acpi_cm_execute_HID (
 117         ACPI_NAMESPACE_NODE     *device_node,
 118         DEVICE_ID               *hid)
 119 {
 120         ACPI_OPERAND_OBJECT     *obj_desc;
 121         ACPI_STATUS             status;
 122
 123
 124         /* Execute the method */
 125
 126         status = acpi_ns_evaluate_relative (device_node,
 127                          METHOD_NAME__HID, NULL, &obj_desc);
 128         if (ACPI_FAILURE (status)) {
 129
 130
 131                 return (status);
 132         }
 133
 134         /* Did we get a return object? */
 135
 136         if (!obj_desc) {
 137                 return (AE_TYPE);
 138         }
 139
 140         /*
 141          *  A _HID can return either a Number (32 bit compressed EISA ID) or
 142          *  a string
 143          */
 144
 145         if ((obj_desc->common.type != ACPI_TYPE_NUMBER) &&
 146                 (obj_desc->common.type != ACPI_TYPE_STRING))
 147         {
 148                 status = AE_TYPE;
 149         }
 150
 151         else {
 152                 if (obj_desc->common.type == ACPI_TYPE_NUMBER) {
 153                         /* Convert the Numeric HID to string */
 154
 155                         acpi_aml_eisa_id_to_string ((u32) obj_desc->number.value, hid->buffer);
 156                 }
 157
 158                 else {
 159                         /* Copy the String HID from the returned object */
 160
 161                         STRNCPY(hid->buffer, obj_desc->string.pointer, sizeof(hid->buffer));
 162                 }
 163         }
 164
 165
 166         /* On exit, we must delete the return object */
 167
 168         acpi_cm_remove_reference (obj_desc);
 169
 170         return (status);
 171 }
 172
 173
 174 /****************************************************************************
 175  *
 176  * FUNCTION:    Acpi_cm_execute_UID
 177  *
 178  * PARAMETERS:  Device_node         - Node for the device
 179  *              *Uid                - Where the UID is returned
 180  *
 181  * RETURN:      Status
 182  *
 183  * DESCRIPTION: Executes the _UID control method that returns the hardware
 184  *              ID of the device.
 185  *
 186  *              NOTE: Internal function, no parameter validation
 187  *
 188  ***************************************************************************/
 189
 190 ACPI_STATUS
 191 acpi_cm_execute_UID (
 192         ACPI_NAMESPACE_NODE     *device_node,
 193         DEVICE_ID               *uid)
 194 {
 195         ACPI_OPERAND_OBJECT     *obj_desc;
 196         ACPI_STATUS             status;
 197
 198
 199         /* Execute the method */
 200
 201         status = acpi_ns_evaluate_relative (device_node,
 202                          METHOD_NAME__UID, NULL, &obj_desc);
 203         if (ACPI_FAILURE (status)) {
 204
 205
 206                 return (status);
 207         }
 208
 209         /* Did we get a return object? */
 210
 211         if (!obj_desc) {
 212                 return (AE_TYPE);
 213         }
 214
 215         /*
 216          *  A _UID can return either a Number (32 bit compressed EISA ID) or
 217          *  a string
 218          */
 219
 220         if ((obj_desc->common.type != ACPI_TYPE_NUMBER) &&
 221                 (obj_desc->common.type != ACPI_TYPE_STRING))
 222         {
 223                 status = AE_TYPE;
 224         }
 225
 226         else {
 227                 if (obj_desc->common.type == ACPI_TYPE_NUMBER) {
 228                         /* Convert the Numeric UID to string */
 229
 230                         acpi_aml_unsigned_integer_to_string (obj_desc->number.value, uid->buffer);
 231                 }
 232
 233                 else {
 234                         /* Copy the String UID from the returned object */
 235
 236                         STRNCPY(uid->buffer, obj_desc->string.pointer, sizeof(uid->buffer));
 237                 }
 238         }
 239
 240
 241         /* On exit, we must delete the return object */
 242
 243         acpi_cm_remove_reference (obj_desc);
 244
 245         return (status);
 246 }
 247
 248 /****************************************************************************
 249  *
 250  * FUNCTION:    Acpi_cm_execute_STA
 251  *
 252  * PARAMETERS:  Device_node         - Node for the device
 253  *              *Flags              - Where the status flags are returned
 254  *
 255  * RETURN:      Status
 256  *
 257  * DESCRIPTION: Executes _STA for selected device and stores results in
 258  *              *Flags.
 259  *
 260  *              NOTE: Internal function, no parameter validation
 261  *
 262  ***************************************************************************/
 263
 264 ACPI_STATUS
 265 acpi_cm_execute_STA (
 266         ACPI_NAMESPACE_NODE     *device_node,
 267         u32                     *flags)
 268 {
 269         ACPI_OPERAND_OBJECT     *obj_desc;
 270         ACPI_STATUS             status;
 271
 272
 273         /* Execute the method */
 274
 275         status = acpi_ns_evaluate_relative (device_node,
 276                          METHOD_NAME__STA, NULL, &obj_desc);
 277         if (AE_NOT_FOUND == status) {
 278                 *flags = 0x0F;
 279                 status = AE_OK;
 280         }
 281
 282
 283         else /* success */ {
 284                 /* Did we get a return object? */
 285
 286                 if (!obj_desc) {
 287                         return (AE_TYPE);
 288                 }
 289
 290                 /* Is the return object of the correct type? */
 291
 292                 if (obj_desc->common.type != ACPI_TYPE_NUMBER) {
 293                         status = AE_TYPE;
 294                 }
 295
 296                 else {
 297                         /* Extract the status flags */
 298
 299                         *flags = (u32) obj_desc->number.value;
 300                 }
 301
 302                 /* On exit, we must delete the return object */
 303
 304                 acpi_cm_remove_reference (obj_desc);
 305         }
 306
 307         return (status);
 308 }