ACPICA: Major update for acpi_get_object_info external interface
Bob Moore [Mon, 29 Jun 2009 05:39:29 +0000 (13:39 +0800)]
Completed a major update for the acpi_get_object_info external interface.
Changes include:
 - Support for variable, unlimited length HID, UID, and CID strings
 - Support Processor objects the same as Devices (HID,UID,CID,ADR,STA, etc.)
 - Call the _SxW power methods on behalf of a device object
 - Determine if a device is a PCI root bridge
 - Change the ACPI_BUFFER parameter to ACPI_DEVICE_INFO.
These changes will require an update to all callers of this interface.
See the ACPICA Programmer Reference for details.

Also, update all invocations of acpi_get_object_info interface

Signed-off-by: Bob Moore <robert.moore@intel.com>
Signed-off-by: Lin Ming <ming.m.lin@intel.com>
Signed-off-by: Len Brown <len.brown@intel.com>

28 files changed:
arch/ia64/hp/common/sba_iommu.c
drivers/acpi/acpi_memhotplug.c
drivers/acpi/acpica/Makefile
drivers/acpi/acpica/acconfig.h
drivers/acpi/acpica/acglobal.h
drivers/acpi/acpica/acinterp.h
drivers/acpi/acpica/acutils.h
drivers/acpi/acpica/evrgnini.c
drivers/acpi/acpica/exutils.c
drivers/acpi/acpica/nsdumpdv.c
drivers/acpi/acpica/nsxfeval.c
drivers/acpi/acpica/nsxfname.c
drivers/acpi/acpica/uteval.c
drivers/acpi/acpica/utglobal.c
drivers/acpi/acpica/utids.c [new file with mode: 0644]
drivers/acpi/acpica/utmisc.c
drivers/acpi/container.c
drivers/acpi/dock.c
drivers/acpi/glue.c
drivers/acpi/scan.c
drivers/char/agp/hp-agp.c
drivers/ide/ide-acpi.c
drivers/pci/hotplug/acpiphp_ibm.c
drivers/platform/x86/sony-laptop.c
drivers/pnp/pnpacpi/core.c
include/acpi/acpi_bus.h
include/acpi/acpixf.h
include/acpi/actypes.h

index 8cfb001..674a837 100644 (file)
@@ -2026,24 +2026,21 @@ acpi_sba_ioc_add(struct acpi_device *device)
        struct ioc *ioc;
        acpi_status status;
        u64 hpa, length;
-       struct acpi_buffer buffer;
        struct acpi_device_info *dev_info;
 
        status = hp_acpi_csr_space(device->handle, &hpa, &length);
        if (ACPI_FAILURE(status))
                return 1;
 
-       buffer.length = ACPI_ALLOCATE_LOCAL_BUFFER;
-       status = acpi_get_object_info(device->handle, &buffer);
+       status = acpi_get_object_info(device->handle, &dev_info);
        if (ACPI_FAILURE(status))
                return 1;
-       dev_info = buffer.pointer;
 
        /*
         * For HWP0001, only SBA appears in ACPI namespace.  It encloses the PCI
         * root bridges, and its CSR space includes the IOC function.
         */
-       if (strncmp("HWP0001", dev_info->hardware_id.value, 7) == 0) {
+       if (strncmp("HWP0001", dev_info->hardware_id.string, 7) == 0) {
                hpa += ZX1_IOC_OFFSET;
                /* zx1 based systems default to kernel page size iommu pages */
                if (!iovp_shift)
index 9a62224..80eacbe 100644 (file)
@@ -481,26 +481,23 @@ static acpi_status is_memory_device(acpi_handle handle)
 {
        char *hardware_id;
        acpi_status status;
-       struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
        struct acpi_device_info *info;
 
-
-       status = acpi_get_object_info(handle, &buffer);
+       status = acpi_get_object_info(handle, &info);
        if (ACPI_FAILURE(status))
                return status;
 
-       info = buffer.pointer;
        if (!(info->valid & ACPI_VALID_HID)) {
-               kfree(buffer.pointer);
+               kfree(info);
                return AE_ERROR;
        }
 
-       hardware_id = info->hardware_id.value;
+       hardware_id = info->hardware_id.string;
        if ((hardware_id == NULL) ||
            (strcmp(hardware_id, ACPI_MEMORY_DEVICE_HID)))
                status = AE_ERROR;
 
-       kfree(buffer.pointer);
+       kfree(info);
        return status;
 }
 
index 72ac28d..0e7d561 100644 (file)
@@ -44,4 +44,4 @@ acpi-y += tbxface.o tbinstal.o tbutils.o tbfind.o tbfadt.o tbxfroot.o
 
 acpi-y += utalloc.o utdebug.o uteval.o utinit.o utmisc.o utxface.o \
                utcopy.o utdelete.o utglobal.o utmath.o utobject.o \
-               utstate.o utmutex.o utobject.o utresrc.o utlock.o
+               utstate.o utmutex.o utobject.o utresrc.o utlock.o utids.o
index e6777fb..6c1fb2d 100644 (file)
 
 #define ACPI_SMBUS_BUFFER_SIZE          34
 
+/* _sx_d and _sx_w control methods */
+
+#define ACPI_NUM_sx_d_METHODS           4
+#define ACPI_NUM_sx_w_METHODS           5
+
 /******************************************************************************
  *
  * ACPI AML Debugger
index 0b73b31..6389f7c 100644 (file)
@@ -265,7 +265,8 @@ ACPI_EXTERN u8 acpi_gbl_osi_data;
 extern u8 acpi_gbl_shutdown;
 extern u32 acpi_gbl_startup_flags;
 extern const char *acpi_gbl_sleep_state_names[ACPI_S_STATE_COUNT];
-extern const char *acpi_gbl_highest_dstate_names[4];
+extern const char *acpi_gbl_lowest_dstate_names[ACPI_NUM_sx_w_METHODS];
+extern const char *acpi_gbl_highest_dstate_names[ACPI_NUM_sx_d_METHODS];
 extern const struct acpi_opcode_info acpi_gbl_aml_op_info[AML_NUM_OPCODES];
 extern const char *acpi_gbl_region_types[ACPI_NUM_PREDEFINED_REGIONS];
 
index e8db7a3..5db9f29 100644 (file)
@@ -461,9 +461,9 @@ void acpi_ex_acquire_global_lock(u32 rule);
 
 void acpi_ex_release_global_lock(u32 rule);
 
-void acpi_ex_eisa_id_to_string(u32 numeric_id, char *out_string);
+void acpi_ex_eisa_id_to_string(char *dest, acpi_integer compressed_id);
 
-void acpi_ex_unsigned_integer_to_string(acpi_integer value, char *out_string);
+void acpi_ex_integer_to_string(char *dest, acpi_integer value);
 
 /*
  * exregion - default op_region handlers
index 897810b..b0add85 100644 (file)
@@ -324,26 +324,30 @@ acpi_ut_evaluate_object(struct acpi_namespace_node *prefix_node,
 acpi_status
 acpi_ut_evaluate_numeric_object(char *object_name,
                                struct acpi_namespace_node *device_node,
-                               acpi_integer * address);
+                               acpi_integer *value);
 
 acpi_status
-acpi_ut_execute_HID(struct acpi_namespace_node *device_node,
-                   struct acpica_device_id *hid);
+acpi_ut_execute_STA(struct acpi_namespace_node *device_node, u32 *status_flags);
 
 acpi_status
-acpi_ut_execute_CID(struct acpi_namespace_node *device_node,
-                   struct acpi_compatible_id_list **return_cid_list);
+acpi_ut_execute_power_methods(struct acpi_namespace_node *device_node,
+                             const char **method_names,
+                             u8 method_count, u8 *out_values);
 
+/*
+ * utids - device ID support
+ */
 acpi_status
-acpi_ut_execute_STA(struct acpi_namespace_node *device_node,
-                   u32 * status_flags);
+acpi_ut_execute_HID(struct acpi_namespace_node *device_node,
+                   struct acpica_device_id **return_id);
 
 acpi_status
 acpi_ut_execute_UID(struct acpi_namespace_node *device_node,
-                   struct acpica_device_id *uid);
+                   struct acpica_device_id **return_id);
 
 acpi_status
-acpi_ut_execute_sxds(struct acpi_namespace_node *device_node, u8 * highest);
+acpi_ut_execute_CID(struct acpi_namespace_node *device_node,
+                   struct acpica_device_id_list **return_cid_list);
 
 /*
  * utlock - reader/writer locks
@@ -445,6 +449,8 @@ acpi_ut_short_divide(acpi_integer in_dividend,
  */
 const char *acpi_ut_validate_exception(acpi_status status);
 
+u8 acpi_ut_is_pci_root_bridge(char *id);
+
 u8 acpi_ut_is_aml_table(struct acpi_table_header *table);
 
 acpi_status acpi_ut_allocate_owner_id(acpi_owner_id * owner_id);
index 284a7be..cf29c49 100644 (file)
@@ -50,8 +50,6 @@
 ACPI_MODULE_NAME("evrgnini")
 
 /* Local prototypes */
-static u8 acpi_ev_match_pci_root_bridge(char *id);
-
 static u8 acpi_ev_is_pci_root_bridge(struct acpi_namespace_node *node);
 
 /*******************************************************************************
@@ -332,37 +330,6 @@ acpi_ev_pci_config_region_setup(acpi_handle handle,
 
 /*******************************************************************************
  *
- * FUNCTION:    acpi_ev_match_pci_root_bridge
- *
- * PARAMETERS:  Id              - The HID/CID in string format
- *
- * RETURN:      TRUE if the Id is a match for a PCI/PCI-Express Root Bridge
- *
- * DESCRIPTION: Determine if the input ID is a PCI Root Bridge ID.
- *
- ******************************************************************************/
-
-static u8 acpi_ev_match_pci_root_bridge(char *id)
-{
-
-       /*
-        * Check if this is a PCI root.
-        * ACPI 3.0+: check for a PCI Express root also.
-        */
-       if (!(ACPI_STRNCMP(id,
-                          PCI_ROOT_HID_STRING,
-                          sizeof(PCI_ROOT_HID_STRING))) ||
-           !(ACPI_STRNCMP(id,
-                          PCI_EXPRESS_ROOT_HID_STRING,
-                          sizeof(PCI_EXPRESS_ROOT_HID_STRING)))) {
-               return (TRUE);
-       }
-
-       return (FALSE);
-}
-
-/*******************************************************************************
- *
  * FUNCTION:    acpi_ev_is_pci_root_bridge
  *
  * PARAMETERS:  Node            - Device node being examined
@@ -377,9 +344,10 @@ static u8 acpi_ev_match_pci_root_bridge(char *id)
 static u8 acpi_ev_is_pci_root_bridge(struct acpi_namespace_node *node)
 {
        acpi_status status;
-       struct acpica_device_id hid;
-       struct acpi_compatible_id_list *cid;
+       struct acpica_device_id *hid;
+       struct acpica_device_id_list *cid;
        u32 i;
+       u8 match;
 
        /* Get the _HID and check for a PCI Root Bridge */
 
@@ -388,7 +356,10 @@ static u8 acpi_ev_is_pci_root_bridge(struct acpi_namespace_node *node)
                return (FALSE);
        }
 
-       if (acpi_ev_match_pci_root_bridge(hid.value)) {
+       match = acpi_ut_is_pci_root_bridge(hid->string);
+       ACPI_FREE(hid);
+
+       if (match) {
                return (TRUE);
        }
 
@@ -402,7 +373,7 @@ static u8 acpi_ev_is_pci_root_bridge(struct acpi_namespace_node *node)
        /* Check all _CIDs in the returned list */
 
        for (i = 0; i < cid->count; i++) {
-               if (acpi_ev_match_pci_root_bridge(cid->id[i].value)) {
+               if (acpi_ut_is_pci_root_bridge(cid->ids[i].string)) {
                        ACPI_FREE(cid);
                        return (TRUE);
                }
index 87730e9..7d41f99 100644 (file)
@@ -358,50 +358,67 @@ static u32 acpi_ex_digits_needed(acpi_integer value, u32 base)
  *
  * FUNCTION:    acpi_ex_eisa_id_to_string
  *
- * PARAMETERS:  numeric_id      - EISA ID to be converted
+ * PARAMETERS:  compressed_id   - EISAID to be converted
  *              out_string      - Where to put the converted string (8 bytes)
  *
  * RETURN:      None
  *
- * DESCRIPTION: Convert a numeric EISA ID to string representation
+ * DESCRIPTION: Convert a numeric EISAID to string representation. Return
+ *              buffer must be large enough to hold the string. The string
+ *              returned is always exactly of length ACPI_EISAID_STRING_SIZE
+ *              (includes null terminator). The EISAID is always 32 bits.
  *
  ******************************************************************************/
 
-void acpi_ex_eisa_id_to_string(u32 numeric_id, char *out_string)
+void acpi_ex_eisa_id_to_string(char *out_string, acpi_integer compressed_id)
 {
-       u32 eisa_id;
+       u32 swapped_id;
 
        ACPI_FUNCTION_ENTRY();
 
+       /* The EISAID should be a 32-bit integer */
+
+       if (compressed_id > ACPI_UINT32_MAX) {
+               ACPI_WARNING((AE_INFO,
+                             "Expected EISAID is larger than 32 bits: 0x%8.8X%8.8X, truncating",
+                             ACPI_FORMAT_UINT64(compressed_id)));
+       }
+
        /* Swap ID to big-endian to get contiguous bits */
 
-       eisa_id = acpi_ut_dword_byte_swap(numeric_id);
+       swapped_id = acpi_ut_dword_byte_swap((u32)compressed_id);
 
-       out_string[0] = (char)('@' + (((unsigned long)eisa_id >> 26) & 0x1f));
-       out_string[1] = (char)('@' + ((eisa_id >> 21) & 0x1f));
-       out_string[2] = (char)('@' + ((eisa_id >> 16) & 0x1f));
-       out_string[3] = acpi_ut_hex_to_ascii_char((acpi_integer) eisa_id, 12);
-       out_string[4] = acpi_ut_hex_to_ascii_char((acpi_integer) eisa_id, 8);
-       out_string[5] = acpi_ut_hex_to_ascii_char((acpi_integer) eisa_id, 4);
-       out_string[6] = acpi_ut_hex_to_ascii_char((acpi_integer) eisa_id, 0);
+       /* First 3 bytes are uppercase letters. Next 4 bytes are hexadecimal */
+
+       out_string[0] =
+           (char)(0x40 + (((unsigned long)swapped_id >> 26) & 0x1F));
+       out_string[1] = (char)(0x40 + ((swapped_id >> 21) & 0x1F));
+       out_string[2] = (char)(0x40 + ((swapped_id >> 16) & 0x1F));
+       out_string[3] = acpi_ut_hex_to_ascii_char((acpi_integer)swapped_id, 12);
+       out_string[4] = acpi_ut_hex_to_ascii_char((acpi_integer)swapped_id, 8);
+       out_string[5] = acpi_ut_hex_to_ascii_char((acpi_integer)swapped_id, 4);
+       out_string[6] = acpi_ut_hex_to_ascii_char((acpi_integer)swapped_id, 0);
        out_string[7] = 0;
 }
 
 /*******************************************************************************
  *
- * FUNCTION:    acpi_ex_unsigned_integer_to_string
+ * FUNCTION:    acpi_ex_integer_to_string
  *
- * PARAMETERS:  Value           - Value to be converted
- *              out_string      - Where to put the converted string (8 bytes)
+ * PARAMETERS:  out_string      - Where to put the converted string. At least
+ *                                21 bytes are needed to hold the largest
+ *                                possible 64-bit integer.
+ *              Value           - Value to be converted
  *
  * RETURN:      None, string
  *
- * DESCRIPTION: Convert a number to string representation. Assumes string
- *              buffer is large enough to hold the string.
+ * DESCRIPTION: Convert a 64-bit integer to decimal string representation.
+ *              Assumes string buffer is large enough to hold the string. The
+ *              largest string is (ACPI_MAX64_DECIMAL_DIGITS + 1).
  *
  ******************************************************************************/
 
-void acpi_ex_unsigned_integer_to_string(acpi_integer value, char *out_string)
+void acpi_ex_integer_to_string(char *out_string, acpi_integer value)
 {
        u32 count;
        u32 digits_needed;
index 41994fe..0fe87f1 100644 (file)
@@ -70,7 +70,6 @@ static acpi_status
 acpi_ns_dump_one_device(acpi_handle obj_handle,
                        u32 level, void *context, void **return_value)
 {
-       struct acpi_buffer buffer;
        struct acpi_device_info *info;
        acpi_status status;
        u32 i;
@@ -80,17 +79,15 @@ acpi_ns_dump_one_device(acpi_handle obj_handle,
        status =
            acpi_ns_dump_one_object(obj_handle, level, context, return_value);
 
-       buffer.length = ACPI_ALLOCATE_LOCAL_BUFFER;
-       status = acpi_get_object_info(obj_handle, &buffer);
+       status = acpi_get_object_info(obj_handle, &info);
        if (ACPI_SUCCESS(status)) {
-               info = buffer.pointer;
                for (i = 0; i < level; i++) {
                        ACPI_DEBUG_PRINT_RAW((ACPI_DB_TABLES, " "));
                }
 
                ACPI_DEBUG_PRINT_RAW((ACPI_DB_TABLES,
                                      "    HID: %s, ADR: %8.8X%8.8X, Status: %X\n",
-                                     info->hardware_id.value,
+                                     info->hardware_id.string,
                                      ACPI_FORMAT_UINT64(info->address),
                                      info->current_status));
                ACPI_FREE(info);
index daf4ad3..4929dbd 100644 (file)
@@ -535,10 +535,11 @@ acpi_ns_get_device_callback(acpi_handle obj_handle,
        acpi_status status;
        struct acpi_namespace_node *node;
        u32 flags;
-       struct acpica_device_id hid;
-       struct acpi_compatible_id_list *cid;
+       struct acpica_device_id *hid;
+       struct acpica_device_id_list *cid;
        u32 i;
-       int found;
+       u8 found;
+       int no_match;
 
        status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
        if (ACPI_FAILURE(status)) {
@@ -582,10 +583,14 @@ acpi_ns_get_device_callback(acpi_handle obj_handle,
                        return (AE_CTRL_DEPTH);
                }
 
-               if (ACPI_STRNCMP(hid.value, info->hid, sizeof(hid.value)) != 0) {
-
-                       /* Get the list of Compatible IDs */
+               no_match = ACPI_STRCMP(hid->string, info->hid);
+               ACPI_FREE(hid);
 
+               if (no_match) {
+                       /*
+                        * HID does not match, attempt match within the
+                        * list of Compatible IDs (CIDs)
+                        */
                        status = acpi_ut_execute_CID(node, &cid);
                        if (status == AE_NOT_FOUND) {
                                return (AE_OK);
@@ -597,10 +602,8 @@ acpi_ns_get_device_callback(acpi_handle obj_handle,
 
                        found = 0;
                        for (i = 0; i < cid->count; i++) {
-                               if (ACPI_STRNCMP(cid->id[i].value, info->hid,
-                                                sizeof(struct
-                                                       acpi_compatible_id)) ==
-                                   0) {
+                               if (ACPI_STRCMP(cid->ids[i].string, info->hid)
+                                   == 0) {
                                        found = 1;
                                        break;
                                }
index f23593d..ddc84af 100644 (file)
 #define _COMPONENT          ACPI_NAMESPACE
 ACPI_MODULE_NAME("nsxfname")
 
+/* Local prototypes */
+static char *acpi_ns_copy_device_id(struct acpica_device_id *dest,
+                                   struct acpica_device_id *source,
+                                   char *string_area);
+
 /******************************************************************************
  *
  * FUNCTION:    acpi_get_handle
@@ -68,6 +73,7 @@ ACPI_MODULE_NAME("nsxfname")
  *              namespace handle.
  *
  ******************************************************************************/
+
 acpi_status
 acpi_get_handle(acpi_handle parent,
                acpi_string pathname, acpi_handle * ret_handle)
@@ -210,10 +216,38 @@ ACPI_EXPORT_SYMBOL(acpi_get_name)
 
 /******************************************************************************
  *
+ * FUNCTION:    acpi_ns_copy_device_id
+ *
+ * PARAMETERS:  Dest                - Pointer to the destination DEVICE_ID
+ *              Source              - Pointer to the source DEVICE_ID
+ *              string_area         - Pointer to where to copy the dest string
+ *
+ * RETURN:      Pointer to the next string area
+ *
+ * DESCRIPTION: Copy a single DEVICE_ID, including the string data.
+ *
+ ******************************************************************************/
+static char *acpi_ns_copy_device_id(struct acpica_device_id *dest,
+                                   struct acpica_device_id *source,
+                                   char *string_area)
+{
+       /* Create the destination DEVICE_ID */
+
+       dest->string = string_area;
+       dest->length = source->length;
+
+       /* Copy actual string and return a pointer to the next string area */
+
+       ACPI_MEMCPY(string_area, source->string, source->length);
+       return (string_area + source->length);
+}
+
+/******************************************************************************
+ *
  * FUNCTION:    acpi_get_object_info
  *
- * PARAMETERS:  Handle          - Object Handle
- *              Buffer          - Where the info is returned
+ * PARAMETERS:  Handle              - Object Handle
+ *              return_buffer       - Where the info is returned
  *
  * RETURN:      Status
  *
@@ -221,33 +255,37 @@ ACPI_EXPORT_SYMBOL(acpi_get_name)
  *              namespace node and possibly by running several standard
  *              control methods (Such as in the case of a device.)
  *
+ * For Device and Processor objects, run the Device _HID, _UID, _CID, _STA,
+ * _ADR, _sx_w, and _sx_d methods.
+ *
+ * Note: Allocates the return buffer, must be freed by the caller.
+ *
  ******************************************************************************/
+
 acpi_status
-acpi_get_object_info(acpi_handle handle, struct acpi_buffer * buffer)
+acpi_get_object_info(acpi_handle handle,
+                    struct acpi_device_info **return_buffer)
 {
-       acpi_status status;
        struct acpi_namespace_node *node;
        struct acpi_device_info *info;
-       struct acpi_device_info *return_info;
-       struct acpi_compatible_id_list *cid_list = NULL;
-       acpi_size size;
+       struct acpica_device_id_list *cid_list = NULL;
+       struct acpica_device_id *hid = NULL;
+       struct acpica_device_id *uid = NULL;
+       char *next_id_string;
+       acpi_object_type type;
+       acpi_name name;
+       u8 param_count = 0;
+       u8 valid = 0;
+       u32 info_size;
+       u32 i;
+       acpi_status status;
 
        /* Parameter validation */
 
-       if (!handle || !buffer) {
+       if (!handle || !return_buffer) {
                return (AE_BAD_PARAMETER);
        }
 
-       status = acpi_ut_validate_buffer(buffer);
-       if (ACPI_FAILURE(status)) {
-               return (status);
-       }
-
-       info = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_device_info));
-       if (!info) {
-               return (AE_NO_MEMORY);
-       }
-
        status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
        if (ACPI_FAILURE(status)) {
                goto cleanup;
@@ -256,66 +294,91 @@ acpi_get_object_info(acpi_handle handle, struct acpi_buffer * buffer)
        node = acpi_ns_map_handle_to_node(handle);
        if (!node) {
                (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
-               status = AE_BAD_PARAMETER;
-               goto cleanup;
+               return (AE_BAD_PARAMETER);
        }
 
-       /* Init return structure */
-
-       size = sizeof(struct acpi_device_info);
+       /* Get the namespace node data while the namespace is locked */
 
-       info->type = node->type;
-       info->name = node->name.integer;
-       info->valid = 0;
+       info_size = sizeof(struct acpi_device_info);
+       type = node->type;
+       name = node->name.integer;
 
        if (node->type == ACPI_TYPE_METHOD) {
-               info->param_count = node->object->method.param_count;
+               param_count = node->object->method.param_count;
        }
 
        status = acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
        if (ACPI_FAILURE(status)) {
-               goto cleanup;
+               return (status);
        }
 
-       /* If not a device, we are all done */
-
-       if (info->type == ACPI_TYPE_DEVICE) {
+       if ((type == ACPI_TYPE_DEVICE) || (type == ACPI_TYPE_PROCESSOR)) {
                /*
-                * Get extra info for ACPI Devices objects only:
-                * Run the Device _HID, _UID, _CID, _STA, _ADR and _sx_d methods.
+                * Get extra info for ACPI Device/Processor objects only:
+                * Run the Device _HID, _UID, and _CID methods.
                 *
                 * Note: none of these methods are required, so they may or may
-                * not be present for this device.  The Info->Valid bitfield is used
-                * to indicate which methods were found and ran successfully.
+                * not be present for this device. The Info->Valid bitfield is used
+                * to indicate which methods were found and run successfully.
                 */
 
                /* Execute the Device._HID method */
 
-               status = acpi_ut_execute_HID(node, &info->hardware_id);
+               status = acpi_ut_execute_HID(node, &hid);
                if (ACPI_SUCCESS(status)) {
-                       info->valid |= ACPI_VALID_HID;
+                       info_size += hid->length;
+                       valid |= ACPI_VALID_HID;
                }
 
                /* Execute the Device._UID method */
 
-               status = acpi_ut_execute_UID(node, &info->unique_id);
+               status = acpi_ut_execute_UID(node, &uid);
                if (ACPI_SUCCESS(status)) {
-                       info->valid |= ACPI_VALID_UID;
+                       info_size += uid->length;
+                       valid |= ACPI_VALID_UID;
                }
 
                /* Execute the Device._CID method */
 
                status = acpi_ut_execute_CID(node, &cid_list);
                if (ACPI_SUCCESS(status)) {
-                       size += cid_list->size;
-                       info->valid |= ACPI_VALID_CID;
+
+                       /* Add size of CID strings and CID pointer array */
+
+                       info_size +=
+                           (cid_list->list_size -
+                            sizeof(struct acpica_device_id_list));
+                       valid |= ACPI_VALID_CID;
                }
+       }
+
+       /*
+        * Now that we have the variable-length data, we can allocate the
+        * return buffer
+        */
+       info = ACPI_ALLOCATE_ZEROED(info_size);
+       if (!info) {
+               status = AE_NO_MEMORY;
+               goto cleanup;
+       }
+
+       /* Get the fixed-length data */
+
+       if ((type == ACPI_TYPE_DEVICE) || (type == ACPI_TYPE_PROCESSOR)) {
+               /*
+                * Get extra info for ACPI Device/Processor objects only:
+                * Run the _STA, _ADR and, sx_w, and _sx_d methods.
+                *
+                * Note: none of these methods are required, so they may or may
+                * not be present for this device. The Info->Valid bitfield is used
+                * to indicate which methods were found and run successfully.
+                */
 
                /* Execute the Device._STA method */
 
                status = acpi_ut_execute_STA(node, &info->current_status);
                if (ACPI_SUCCESS(status)) {
-                       info->valid |= ACPI_VALID_STA;
+                       valid |= ACPI_VALID_STA;
                }
 
                /* Execute the Device._ADR method */
@@ -323,36 +386,100 @@ acpi_get_object_info(acpi_handle handle, struct acpi_buffer * buffer)
                status = acpi_ut_evaluate_numeric_object(METHOD_NAME__ADR, node,
                                                         &info->address);
                if (ACPI_SUCCESS(status)) {
-                       info->valid |= ACPI_VALID_ADR;
+                       valid |= ACPI_VALID_ADR;
+               }
+
+               /* Execute the Device._sx_w methods */
+
+               status = acpi_ut_execute_power_methods(node,
+                                                      acpi_gbl_lowest_dstate_names,
+                                                      ACPI_NUM_sx_w_METHODS,
+                                                      info->lowest_dstates);
+               if (ACPI_SUCCESS(status)) {
+                       valid |= ACPI_VALID_SXWS;
                }
 
                /* Execute the Device._sx_d methods */
 
-               status = acpi_ut_execute_sxds(node, info->highest_dstates);
+               status = acpi_ut_execute_power_methods(node,
+                                                      acpi_gbl_highest_dstate_names,
+                                                      ACPI_NUM_sx_d_METHODS,
+                                                      info->highest_dstates);
                if (ACPI_SUCCESS(status)) {
-                       info->valid |= ACPI_VALID_SXDS;
+                       valid |= ACPI_VALID_SXDS;
                }
        }
 
-       /* Validate/Allocate/Clear caller buffer */
+       /*
+        * Create a pointer to the string area of the return buffer.
+        * Point to the end of the base struct acpi_device_info structure.
+        */
+       next_id_string = ACPI_CAST_PTR(char, info->compatible_id_list.ids);
+       if (cid_list) {
 
-       status = acpi_ut_initialize_buffer(buffer, size);
-       if (ACPI_FAILURE(status)) {
-               goto cleanup;
+               /* Point past the CID DEVICE_ID array */
+
+               next_id_string +=
+                   ((acpi_size) cid_list->count *
+                    sizeof(struct acpica_device_id));
        }
 
-       /* Populate the return buffer */
+       /*
+        * Copy the HID, UID, and CIDs to the return buffer. The variable-length
+        * strings are copied to the reserved area at the end of the buffer.
+        *
+        * For HID and CID, check if the ID is a PCI Root Bridge.
+        */
+       if (hid) {
+               next_id_string = acpi_ns_copy_device_id(&info->hardware_id,
+                                                       hid, next_id_string);
+
+               if (acpi_ut_is_pci_root_bridge(hid->string)) {
+                       info->flags |= ACPI_PCI_ROOT_BRIDGE;
+               }
+       }
 
-       return_info = buffer->pointer;
-       ACPI_MEMCPY(return_info, info, sizeof(struct acpi_device_info));
+       if (uid) {
+               next_id_string = acpi_ns_copy_device_id(&info->unique_id,
+                                                       uid, next_id_string);
+       }
 
        if (cid_list) {
-               ACPI_MEMCPY(&return_info->compatibility_id, cid_list,
-                           cid_list->size);
+               info->compatible_id_list.count = cid_list->count;
+               info->compatible_id_list.list_size = cid_list->list_size;
+
+               /* Copy each CID */
+
+               for (i = 0; i < cid_list->count; i++) {
+                       next_id_string =
+                           acpi_ns_copy_device_id(&info->compatible_id_list.
+                                                  ids[i], &cid_list->ids[i],
+                                                  next_id_string);
+
+                       if (acpi_ut_is_pci_root_bridge(cid_list->ids[i].string)) {
+                               info->flags |= ACPI_PCI_ROOT_BRIDGE;
+                       }
+               }
        }
 
+       /* Copy the fixed-length data */
+
+       info->info_size = info_size;
+       info->type = type;
+       info->name = name;
+       info->param_count = param_count;
+       info->valid = valid;
+
+       *return_buffer = info;
+       status = AE_OK;
+
       cleanup:
-       ACPI_FREE(info);
+       if (hid) {
+               ACPI_FREE(hid);
+       }
+       if (uid) {
+               ACPI_FREE(uid);
+       }
        if (cid_list) {
                ACPI_FREE(cid_list);
        }
index 006b16c..5503307 100644 (file)
 #include <acpi/acpi.h>
 #include "accommon.h"
 #include "acnamesp.h"
-#include "acinterp.h"
 
 #define _COMPONENT          ACPI_UTILITIES
 ACPI_MODULE_NAME("uteval")
 
-/* Local prototypes */
-static void
-acpi_ut_copy_id_string(char *destination, char *source, acpi_size max_length);
-
-static acpi_status
-acpi_ut_translate_one_cid(union acpi_operand_object *obj_desc,
-                         struct acpi_compatible_id *one_cid);
-
 /*
  * Strings supported by the _OSI predefined (internal) method.
  *
@@ -213,7 +204,7 @@ acpi_status acpi_osi_invalidate(char *interface)
  * RETURN:      Status
  *
  * DESCRIPTION: Evaluates a namespace object and verifies the type of the
- *              return object.  Common code that simplifies accessing objects
+ *              return object. Common code that simplifies accessing objects
  *              that have required return objects of fixed types.
  *
  *              NOTE: Internal function, no parameter validation
@@ -298,7 +289,7 @@ acpi_ut_evaluate_object(struct acpi_namespace_node *prefix_node,
 
        if ((acpi_gbl_enable_interpreter_slack) && (!expected_return_btypes)) {
                /*
-                * We received a return object, but one was not expected.  This can
+                * We received a return object, but one was not expected. This can
                 * happen frequently if the "implicit return" feature is enabled.
                 * Just delete the return object and return AE_OK.
                 */
@@ -340,12 +331,12 @@ acpi_ut_evaluate_object(struct acpi_namespace_node *prefix_node,
  *
  * PARAMETERS:  object_name         - Object name to be evaluated
  *              device_node         - Node for the device
- *              Address             - Where the value is returned
+ *              Value               - Where the value is returned
  *
  * RETURN:      Status
  *
  * DESCRIPTION: Evaluates a numeric namespace object for a selected device
- *              and stores result in *Address.
+ *              and stores result in *Value.
  *
  *              NOTE: Internal function, no parameter validation
  *
@@ -354,7 +345,7 @@ acpi_ut_evaluate_object(struct acpi_namespace_node *prefix_node,
 acpi_status
 acpi_ut_evaluate_numeric_object(char *object_name,
                                struct acpi_namespace_node *device_node,
-                               acpi_integer * address)
+                               acpi_integer *value)
 {
        union acpi_operand_object *obj_desc;
        acpi_status status;
@@ -369,295 +360,7 @@ acpi_ut_evaluate_numeric_object(char *object_name,
 
        /* Get the returned Integer */
 
-       *address = obj_desc->integer.value;
-
-       /* On exit, we must delete the return object */
-
-       acpi_ut_remove_reference(obj_desc);
-       return_ACPI_STATUS(status);
-}
-
-/*******************************************************************************
- *
- * FUNCTION:    acpi_ut_copy_id_string
- *
- * PARAMETERS:  Destination         - Where to copy the string
- *              Source              - Source string
- *              max_length          - Length of the destination buffer
- *
- * RETURN:      None
- *
- * DESCRIPTION: Copies an ID string for the _HID, _CID, and _UID methods.
- *              Performs removal of a leading asterisk if present -- workaround
- *              for a known issue on a bunch of machines.
- *
- ******************************************************************************/
-
-static void
-acpi_ut_copy_id_string(char *destination, char *source, acpi_size max_length)
-{
-
-       /*
-        * Workaround for ID strings that have a leading asterisk. This construct
-        * is not allowed by the ACPI specification  (ID strings must be
-        * alphanumeric), but enough existing machines have this embedded in their
-        * ID strings that the following code is useful.
-        */
-       if (*source == '*') {
-               source++;
-       }
-
-       /* Do the actual copy */
-
-       ACPI_STRNCPY(destination, source, max_length);
-}
-
-/*******************************************************************************
- *
- * FUNCTION:    acpi_ut_execute_HID
- *
- * PARAMETERS:  device_node         - Node for the device
- *              Hid                 - Where the HID is returned
- *
- * RETURN:      Status
- *
- * DESCRIPTION: Executes the _HID control method that returns the hardware
- *              ID of the device.
- *
- *              NOTE: Internal function, no parameter validation
- *
- ******************************************************************************/
-
-acpi_status
-acpi_ut_execute_HID(struct acpi_namespace_node *device_node,
-                   struct acpica_device_id *hid)
-{
-       union acpi_operand_object *obj_desc;
-       acpi_status status;
-
-       ACPI_FUNCTION_TRACE(ut_execute_HID);
-
-       status = acpi_ut_evaluate_object(device_node, METHOD_NAME__HID,
-                                        ACPI_BTYPE_INTEGER | ACPI_BTYPE_STRING,
-                                        &obj_desc);
-       if (ACPI_FAILURE(status)) {
-               return_ACPI_STATUS(status);
-       }
-
-       if (obj_desc->common.type == ACPI_TYPE_INTEGER) {
-
-               /* Convert the Numeric HID to string */
-
-               acpi_ex_eisa_id_to_string((u32) obj_desc->integer.value,
-                                         hid->value);
-       } else {
-               /* Copy the String HID from the returned object */
-
-               acpi_ut_copy_id_string(hid->value, obj_desc->string.pointer,
-                                      sizeof(hid->value));
-       }
-
-       /* On exit, we must delete the return object */
-
-       acpi_ut_remove_reference(obj_desc);
-       return_ACPI_STATUS(status);
-}
-
-/*******************************************************************************
- *
- * FUNCTION:    acpi_ut_translate_one_cid
- *
- * PARAMETERS:  obj_desc            - _CID object, must be integer or string
- *              one_cid             - Where the CID string is returned
- *
- * RETURN:      Status
- *
- * DESCRIPTION: Return a numeric or string _CID value as a string.
- *              (Compatible ID)
- *
- *              NOTE:  Assumes a maximum _CID string length of
- *                     ACPI_MAX_CID_LENGTH.
- *
- ******************************************************************************/
-
-static acpi_status
-acpi_ut_translate_one_cid(union acpi_operand_object *obj_desc,
-                         struct acpi_compatible_id *one_cid)
-{
-
-       switch (obj_desc->common.type) {
-       case ACPI_TYPE_INTEGER:
-
-               /* Convert the Numeric CID to string */
-
-               acpi_ex_eisa_id_to_string((u32) obj_desc->integer.value,
-                                         one_cid->value);
-               return (AE_OK);
-
-       case ACPI_TYPE_STRING:
-
-               if (obj_desc->string.length > ACPI_MAX_CID_LENGTH) {
-                       return (AE_AML_STRING_LIMIT);
-               }
-
-               /* Copy the String CID from the returned object */
-
-               acpi_ut_copy_id_string(one_cid->value, obj_desc->string.pointer,
-                                      ACPI_MAX_CID_LENGTH);
-               return (AE_OK);
-
-       default:
-
-               return (AE_TYPE);
-       }
-}
-
-/*******************************************************************************
- *
- * FUNCTION:    acpi_ut_execute_CID
- *
- * PARAMETERS:  device_node         - Node for the device
- *              return_cid_list     - Where the CID list is returned
- *
- * RETURN:      Status
- *
- * DESCRIPTION: Executes the _CID control method that returns one or more
- *              compatible hardware IDs for the device.
- *
- *              NOTE: Internal function, no parameter validation
- *
- ******************************************************************************/
-
-acpi_status
-acpi_ut_execute_CID(struct acpi_namespace_node * device_node,
-                   struct acpi_compatible_id_list ** return_cid_list)
-{
-       union acpi_operand_object *obj_desc;
-       acpi_status status;
-       u32 count;
-       u32 size;
-       struct acpi_compatible_id_list *cid_list;
-       u32 i;
-
-       ACPI_FUNCTION_TRACE(ut_execute_CID);
-
-       /* Evaluate the _CID method for this device */
-
-       status = acpi_ut_evaluate_object(device_node, METHOD_NAME__CID,
-                                        ACPI_BTYPE_INTEGER | ACPI_BTYPE_STRING
-                                        | ACPI_BTYPE_PACKAGE, &obj_desc);
-       if (ACPI_FAILURE(status)) {
-               return_ACPI_STATUS(status);
-       }
-
-       /* Get the number of _CIDs returned */
-
-       count = 1;
-       if (obj_desc->common.type == ACPI_TYPE_PACKAGE) {
-               count = obj_desc->package.count;
-       }
-
-       /* Allocate a worst-case buffer for the _CIDs */
-
-       size = (((count - 1) * sizeof(struct acpi_compatible_id)) +
-               sizeof(struct acpi_compatible_id_list));
-
-       cid_list = ACPI_ALLOCATE_ZEROED((acpi_size) size);
-       if (!cid_list) {
-               return_ACPI_STATUS(AE_NO_MEMORY);
-       }
-
-       /* Init CID list */
-
-       cid_list->count = count;
-       cid_list->size = size;
-
-       /*
-        *  A _CID can return either a single compatible ID or a package of
-        *  compatible IDs.  Each compatible ID can be one of the following:
-        *  1) Integer (32 bit compressed EISA ID) or
-        *  2) String (PCI ID format, e.g. "PCI\VEN_vvvv&DEV_dddd&SUBSYS_ssssssss")
-        */
-
-       /* The _CID object can be either a single CID or a package (list) of CIDs */
-
-       if (obj_desc->common.type == ACPI_TYPE_PACKAGE) {
-
-               /* Translate each package element */
-
-               for (i = 0; i < count; i++) {
-                       status =
-                           acpi_ut_translate_one_cid(obj_desc->package.
-                                                     elements[i],
-                                                     &cid_list->id[i]);
-                       if (ACPI_FAILURE(status)) {
-                               break;
-                       }
-               }
-       } else {
-               /* Only one CID, translate to a string */
-
-               status = acpi_ut_translate_one_cid(obj_desc, cid_list->id);
-       }
-
-       /* Cleanup on error */
-
-       if (ACPI_FAILURE(status)) {
-               ACPI_FREE(cid_list);
-       } else {
-               *return_cid_list = cid_list;
-       }
-
-       /* On exit, we must delete the _CID return object */
-
-       acpi_ut_remove_reference(obj_desc);
-       return_ACPI_STATUS(status);
-}
-
-/*******************************************************************************
- *
- * FUNCTION:    acpi_ut_execute_UID
- *
- * PARAMETERS:  device_node         - Node for the device
- *              Uid                 - Where the UID is returned
- *
- * RETURN:      Status
- *
- * DESCRIPTION: Executes the _UID control method that returns the hardware
- *              ID of the device.
- *
- *              NOTE: Internal function, no parameter validation
- *
- ******************************************************************************/
-
-acpi_status
-acpi_ut_execute_UID(struct acpi_namespace_node *device_node,
-                   struct acpica_device_id *uid)
-{
-       union acpi_operand_object *obj_desc;
-       acpi_status status;
-
-       ACPI_FUNCTION_TRACE(ut_execute_UID);
-
-       status = acpi_ut_evaluate_object(device_node, METHOD_NAME__UID,
-                                        ACPI_BTYPE_INTEGER | ACPI_BTYPE_STRING,
-                                        &obj_desc);
-       if (ACPI_FAILURE(status)) {
-               return_ACPI_STATUS(status);
-       }
-
-       if (obj_desc->common.type == ACPI_TYPE_INTEGER) {
-
-               /* Convert the Numeric UID to string */
-
-               acpi_ex_unsigned_integer_to_string(obj_desc->integer.value,
-                                                  uid->value);
-       } else {
-               /* Copy the String UID from the returned object */
-
-               acpi_ut_copy_id_string(uid->value, obj_desc->string.pointer,
-                                      sizeof(uid->value));
-       }
+       *value = obj_desc->integer.value;
 
        /* On exit, we must delete the return object */
 
@@ -716,60 +419,64 @@ acpi_ut_execute_STA(struct acpi_namespace_node *device_node, u32 * flags)
 
 /*******************************************************************************
  *
- * FUNCTION:    acpi_ut_execute_Sxds
+ * FUNCTION:    acpi_ut_execute_power_methods
  *
  * PARAMETERS:  device_node         - Node for the device
- *              Flags               - Where the status flags are returned
+ *              method_names        - Array of power method names
+ *              method_count        - Number of methods to execute
+ *              out_values          - Where the power method values are returned
  *
- * RETURN:      Status
+ * RETURN:      Status, out_values
  *
- * DESCRIPTION: Executes _STA for selected device and stores results in
- *              *Flags.
+ * DESCRIPTION: Executes the specified power methods for the device and returns
+ *              the result(s).
  *
  *              NOTE: Internal function, no parameter validation
  *
- ******************************************************************************/
+******************************************************************************/
 
 acpi_status
-acpi_ut_execute_sxds(struct acpi_namespace_node *device_node, u8 * highest)
+acpi_ut_execute_power_methods(struct acpi_namespace_node *device_node,
+                             const char **method_names,
+                             u8 method_count, u8 *out_values)
 {
        union acpi_operand_object *obj_desc;
        acpi_status status;
+       acpi_status final_status = AE_NOT_FOUND;
        u32 i;
 
-       ACPI_FUNCTION_TRACE(ut_execute_sxds);
+       ACPI_FUNCTION_TRACE(ut_execute_power_methods);
 
-       for (i = 0; i < 4; i++) {
-               highest[i] = 0xFF;
+       for (i = 0; i < method_count; i++) {
+               /*
+                * Execute the power method (_sx_d or _sx_w). The only allowable
+                * return type is an Integer.
+                */
                status = acpi_ut_evaluate_object(device_node,
                                                 ACPI_CAST_PTR(char,
-                                                              acpi_gbl_highest_dstate_names
-                                                              [i]),
+                                                              method_names[i]),
                                                 ACPI_BTYPE_INTEGER, &obj_desc);
-               if (ACPI_FAILURE(status)) {
-                       if (status != AE_NOT_FOUND) {
-                               ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
-                                                 "%s on Device %4.4s, %s\n",
-                                                 ACPI_CAST_PTR(char,
-                                                               acpi_gbl_highest_dstate_names
-                                                               [i]),
-                                                 acpi_ut_get_node_name
-                                                 (device_node),
-                                                 acpi_format_exception
-                                                 (status)));
-
-                               return_ACPI_STATUS(status);
-                       }
-               } else {
-                       /* Extract the Dstate value */
-
-                       highest[i] = (u8) obj_desc->integer.value;
+               if (ACPI_SUCCESS(status)) {
+                       out_values[i] = (u8)obj_desc->integer.value;
 
                        /* Delete the return object */
 
                        acpi_ut_remove_reference(obj_desc);
+                       final_status = AE_OK;   /* At least one value is valid */
+                       continue;
                }
+
+               out_values[i] = ACPI_UINT8_MAX;
+               if (status == AE_NOT_FOUND) {
+                       continue;       /* Ignore if not found */
+               }
+
+               ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
+                                 "Failed %s on Device %4.4s, %s\n",
+                                 ACPI_CAST_PTR(char, method_names[i]),
+                                 acpi_ut_get_node_name(device_node),
+                                 acpi_format_exception(status)));
        }
 
-       return_ACPI_STATUS(AE_OK);
+       return_ACPI_STATUS(final_status);
 }
index 59e46f2..ed7a33c 100644 (file)
@@ -90,7 +90,15 @@ const char *acpi_gbl_sleep_state_names[ACPI_S_STATE_COUNT] = {
        "\\_S5_"
 };
 
-const char *acpi_gbl_highest_dstate_names[4] = {
+const char *acpi_gbl_lowest_dstate_names[ACPI_NUM_sx_w_METHODS] = {
+       "_S0W",
+       "_S1W",
+       "_S2W",
+       "_S3W",
+       "_S4W"
+};
+
+const char *acpi_gbl_highest_dstate_names[ACPI_NUM_sx_d_METHODS] = {
        "_S1D",
        "_S2D",
        "_S3D",
diff --git a/drivers/acpi/acpica/utids.c b/drivers/acpi/acpica/utids.c
new file mode 100644 (file)
index 0000000..52eaae4
--- /dev/null
@@ -0,0 +1,382 @@
+/******************************************************************************
+ *
+ * Module Name: utids - support for device IDs - HID, UID, CID
+ *
+ *****************************************************************************/
+
+/*
+ * Copyright (C) 2000 - 2009, Intel Corp.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions, and the following disclaimer,
+ *    without modification.
+ * 2. Redistributions in binary form must reproduce at minimum a disclaimer
+ *    substantially similar to the "NO WARRANTY" disclaimer below
+ *    ("Disclaimer") and any redistribution must be conditioned upon
+ *    including a substantially similar Disclaimer requirement for further
+ *    binary redistribution.
+ * 3. Neither the names of the above-listed copyright holders nor the names
+ *    of any contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") version 2 as published by the Free
+ * Software Foundation.
+ *
+ * NO WARRANTY
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGES.
+ */
+
+#include <acpi/acpi.h>
+#include "accommon.h"
+#include "acinterp.h"
+
+#define _COMPONENT          ACPI_UTILITIES
+ACPI_MODULE_NAME("utids")
+
+/* Local prototypes */
+static void acpi_ut_copy_id_string(char *destination, char *source);
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_ut_copy_id_string
+ *
+ * PARAMETERS:  Destination         - Where to copy the string
+ *              Source              - Source string
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Copies an ID string for the _HID, _CID, and _UID methods.
+ *              Performs removal of a leading asterisk if present -- workaround
+ *              for a known issue on a bunch of machines.
+ *
+ ******************************************************************************/
+
+static void acpi_ut_copy_id_string(char *destination, char *source)
+{
+
+       /*
+        * Workaround for ID strings that have a leading asterisk. This construct
+        * is not allowed by the ACPI specification  (ID strings must be
+        * alphanumeric), but enough existing machines have this embedded in their
+        * ID strings that the following code is useful.
+        */
+       if (*source == '*') {
+               source++;
+       }
+
+       /* Do the actual copy */
+
+       ACPI_STRCPY(destination, source);
+}
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_ut_execute_HID
+ *
+ * PARAMETERS:  device_node         - Node for the device
+ *              return_id           - Where the string HID is returned
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Executes the _HID control method that returns the hardware
+ *              ID of the device. The HID is either an 32-bit encoded EISAID
+ *              Integer or a String. A string is always returned. An EISAID
+ *              is converted to a string.
+ *
+ *              NOTE: Internal function, no parameter validation
+ *
+ ******************************************************************************/
+
+acpi_status
+acpi_ut_execute_HID(struct acpi_namespace_node *device_node,
+                   struct acpica_device_id **return_id)
+{
+       union acpi_operand_object *obj_desc;
+       struct acpica_device_id *hid;
+       u32 length;
+       acpi_status status;
+
+       ACPI_FUNCTION_TRACE(ut_execute_HID);
+
+       status = acpi_ut_evaluate_object(device_node, METHOD_NAME__HID,
+                                        ACPI_BTYPE_INTEGER | ACPI_BTYPE_STRING,
+                                        &obj_desc);
+       if (ACPI_FAILURE(status)) {
+               return_ACPI_STATUS(status);
+       }
+
+       /* Get the size of the String to be returned, includes null terminator */
+
+       if (obj_desc->common.type == ACPI_TYPE_INTEGER) {
+               length = ACPI_EISAID_STRING_SIZE;
+       } else {
+               length = obj_desc->string.length + 1;
+       }
+
+       /* Allocate a buffer for the HID */
+
+       hid =
+           ACPI_ALLOCATE_ZEROED(sizeof(struct acpica_device_id) +
+                                (acpi_size) length);
+       if (!hid) {
+               status = AE_NO_MEMORY;
+               goto cleanup;
+       }
+
+       /* Area for the string starts after DEVICE_ID struct */
+
+       hid->string = ACPI_ADD_PTR(char, hid, sizeof(struct acpica_device_id));
+
+       /* Convert EISAID to a string or simply copy existing string */
+
+       if (obj_desc->common.type == ACPI_TYPE_INTEGER) {
+               acpi_ex_eisa_id_to_string(hid->string, obj_desc->integer.value);
+       } else {
+               acpi_ut_copy_id_string(hid->string, obj_desc->string.pointer);
+       }
+
+       hid->length = length;
+       *return_id = hid;
+
+cleanup:
+
+       /* On exit, we must delete the return object */
+
+       acpi_ut_remove_reference(obj_desc);
+       return_ACPI_STATUS(status);
+}
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_ut_execute_UID
+ *
+ * PARAMETERS:  device_node         - Node for the device
+ *              return_id           - Where the string UID is returned
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Executes the _UID control method that returns the unique
+ *              ID of the device. The UID is either a 64-bit Integer (NOT an
+ *              EISAID) or a string. Always returns a string. A 64-bit integer
+ *              is converted to a decimal string.
+ *
+ *              NOTE: Internal function, no parameter validation
+ *
+ ******************************************************************************/
+
+acpi_status
+acpi_ut_execute_UID(struct acpi_namespace_node *device_node,
+                   struct acpica_device_id **return_id)
+{
+       union acpi_operand_object *obj_desc;
+       struct acpica_device_id *uid;
+       u32 length;
+       acpi_status status;
+
+       ACPI_FUNCTION_TRACE(ut_execute_UID);
+
+       status = acpi_ut_evaluate_object(device_node, METHOD_NAME__UID,
+                                        ACPI_BTYPE_INTEGER | ACPI_BTYPE_STRING,
+                                        &obj_desc);
+       if (ACPI_FAILURE(status)) {
+               return_ACPI_STATUS(status);
+       }
+
+       /* Get the size of the String to be returned, includes null terminator */
+
+       if (obj_desc->common.type == ACPI_TYPE_INTEGER) {
+               length = ACPI_MAX64_DECIMAL_DIGITS + 1;
+       } else {
+               length = obj_desc->string.length + 1;
+       }
+
+       /* Allocate a buffer for the UID */
+
+       uid =
+           ACPI_ALLOCATE_ZEROED(sizeof(struct acpica_device_id) +
+                                (acpi_size) length);
+       if (!uid) {
+               status = AE_NO_MEMORY;
+               goto cleanup;
+       }
+
+       /* Area for the string starts after DEVICE_ID struct */
+
+       uid->string = ACPI_ADD_PTR(char, uid, sizeof(struct acpica_device_id));
+
+       /* Convert an Integer to string, or just copy an existing string */
+
+       if (obj_desc->common.type == ACPI_TYPE_INTEGER) {
+               acpi_ex_integer_to_string(uid->string, obj_desc->integer.value);
+       } else {
+               acpi_ut_copy_id_string(uid->string, obj_desc->string.pointer);
+       }
+
+       uid->length = length;
+       *return_id = uid;
+
+cleanup:
+
+       /* On exit, we must delete the return object */
+
+       acpi_ut_remove_reference(obj_desc);
+       return_ACPI_STATUS(status);
+}
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_ut_execute_CID
+ *
+ * PARAMETERS:  device_node         - Node for the device
+ *              return_cid_list     - Where the CID list is returned
+ *
+ * RETURN:      Status, list of CID strings
+ *
+ * DESCRIPTION: Executes the _CID control method that returns one or more
+ *              compatible hardware IDs for the device.
+ *
+ *              NOTE: Internal function, no parameter validation
+ *
+ * A _CID method can return either a single compatible ID or a package of
+ * compatible IDs. Each compatible ID can be one of the following:
+ * 1) Integer (32 bit compressed EISA ID) or
+ * 2) String (PCI ID format, e.g. "PCI\VEN_vvvv&DEV_dddd&SUBSYS_ssssssss")
+ *
+ * The Integer CIDs are converted to string format by this function.
+ *
+ ******************************************************************************/
+
+acpi_status
+acpi_ut_execute_CID(struct acpi_namespace_node *device_node,
+                   struct acpica_device_id_list **return_cid_list)
+{
+       union acpi_operand_object **cid_objects;
+       union acpi_operand_object *obj_desc;
+       struct acpica_device_id_list *cid_list;
+       char *next_id_string;
+       u32 string_area_size;
+       u32 length;
+       u32 cid_list_size;
+       acpi_status status;
+       u32 count;
+       u32 i;
+
+       ACPI_FUNCTION_TRACE(ut_execute_CID);
+
+       /* Evaluate the _CID method for this device */
+
+       status = acpi_ut_evaluate_object(device_node, METHOD_NAME__CID,
+                                        ACPI_BTYPE_INTEGER | ACPI_BTYPE_STRING
+                                        | ACPI_BTYPE_PACKAGE, &obj_desc);
+       if (ACPI_FAILURE(status)) {
+               return_ACPI_STATUS(status);
+       }
+
+       /*
+        * Get the count and size of the returned _CIDs. _CID can return either
+        * a Package of Integers/Strings or a single Integer or String.
+        * Note: This section also validates that all CID elements are of the
+        * correct type (Integer or String).
+        */
+       if (obj_desc->common.type == ACPI_TYPE_PACKAGE) {
+               count = obj_desc->package.count;
+               cid_objects = obj_desc->package.elements;
+       } else {                /* Single Integer or String CID */
+
+               count = 1;
+               cid_objects = &obj_desc;
+       }
+
+       string_area_size = 0;
+       for (i = 0; i < count; i++) {
+
+               /* String lengths include null terminator */
+
+               switch (cid_objects[i]->common.type) {
+               case ACPI_TYPE_INTEGER:
+                       string_area_size += ACPI_EISAID_STRING_SIZE;
+                       break;
+
+               case ACPI_TYPE_STRING:
+                       string_area_size += cid_objects[i]->string.length + 1;
+                       break;
+
+               default:
+                       status = AE_TYPE;
+                       goto cleanup;
+               }
+       }
+
+       /*
+        * Now that we know the length of the CIDs, allocate return buffer:
+        * 1) Size of the base structure +
+        * 2) Size of the CID DEVICE_ID array +
+        * 3) Size of the actual CID strings
+        */
+       cid_list_size = sizeof(struct acpica_device_id_list) +
+           ((count - 1) * sizeof(struct acpica_device_id)) + string_area_size;
+
+       cid_list = ACPI_ALLOCATE_ZEROED(cid_list_size);
+       if (!cid_list) {
+               status = AE_NO_MEMORY;
+               goto cleanup;
+       }
+
+       /* Area for CID strings starts after the CID DEVICE_ID array */
+
+       next_id_string = ACPI_CAST_PTR(char, cid_list->ids) +
+           ((acpi_size) count * sizeof(struct acpica_device_id));
+
+       /* Copy/convert the CIDs to the return buffer */
+
+       for (i = 0; i < count; i++) {
+               if (cid_objects[i]->common.type == ACPI_TYPE_INTEGER) {
+
+                       /* Convert the Integer (EISAID) CID to a string */
+
+                       acpi_ex_eisa_id_to_string(next_id_string,
+                                                 cid_objects[i]->integer.
+                                                 value);
+                       length = ACPI_EISAID_STRING_SIZE;
+               } else {        /* ACPI_TYPE_STRING */
+
+                       /* Copy the String CID from the returned object */
+
+                       acpi_ut_copy_id_string(next_id_string,
+                                              cid_objects[i]->string.pointer);
+                       length = cid_objects[i]->string.length + 1;
+               }
+
+               cid_list->ids[i].string = next_id_string;
+               cid_list->ids[i].length = length;
+               next_id_string += length;
+       }
+
+       /* Finish the CID list */
+
+       cid_list->count = count;
+       cid_list->list_size = cid_list_size;
+       *return_cid_list = cid_list;
+
+cleanup:
+
+       /* On exit, we must delete the _CID return object */
+
+       acpi_ut_remove_reference(obj_desc);
+       return_ACPI_STATUS(status);
+}
index fbe7823..9cd6533 100644 (file)
@@ -120,6 +120,34 @@ const char *acpi_ut_validate_exception(acpi_status status)
 
 /*******************************************************************************
  *
+ * FUNCTION:    acpi_ut_is_pci_root_bridge
+ *
+ * PARAMETERS:  Id              - The HID/CID in string format
+ *
+ * RETURN:      TRUE if the Id is a match for a PCI/PCI-Express Root Bridge
+ *
+ * DESCRIPTION: Determine if the input ID is a PCI Root Bridge ID.
+ *
+ ******************************************************************************/
+
+u8 acpi_ut_is_pci_root_bridge(char *id)
+{
+
+       /*
+        * Check if this is a PCI root bridge.
+        * ACPI 3.0+: check for a PCI Express root also.
+        */
+       if (!(ACPI_STRCMP(id,
+                         PCI_ROOT_HID_STRING)) ||
+           !(ACPI_STRCMP(id, PCI_EXPRESS_ROOT_HID_STRING))) {
+               return (TRUE);
+       }
+
+       return (FALSE);
+}
+
+/*******************************************************************************
+ *
  * FUNCTION:    acpi_ut_is_aml_table
  *
  * PARAMETERS:  Table               - An ACPI table
index fe0cdf8..2aee8c2 100644 (file)
@@ -200,20 +200,17 @@ container_walk_namespace_cb(acpi_handle handle,
                            u32 lvl, void *context, void **rv)
 {
        char *hid = NULL;
-       struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
        struct acpi_device_info *info;
        acpi_status status;
        int *action = context;
 
-
-       status = acpi_get_object_info(handle, &buffer);
-       if (ACPI_FAILURE(status) || !buffer.pointer) {
+       status = acpi_get_object_info(handle, &info);
+       if (ACPI_FAILURE(status)) {
                return AE_OK;
        }
 
-       info = buffer.pointer;
        if (info->valid & ACPI_VALID_HID)
-               hid = info->hardware_id.value;
+               hid = info->hardware_id.string;
 
        if (hid == NULL) {
                goto end;
@@ -240,7 +237,7 @@ container_walk_namespace_cb(acpi_handle handle,
        }
 
       end:
-       kfree(buffer.pointer);
+       kfree(info);
 
        return AE_OK;
 }
index efb959d..39536b8 100644 (file)
@@ -231,18 +231,16 @@ static int is_ata(acpi_handle handle)
 static int is_battery(acpi_handle handle)
 {
        struct acpi_device_info *info;
-       struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
        int ret = 1;
 
-       if (!ACPI_SUCCESS(acpi_get_object_info(handle, &buffer)))
+       if (!ACPI_SUCCESS(acpi_get_object_info(handle, &info)))
                return 0;
-       info = buffer.pointer;
        if (!(info->valid & ACPI_VALID_HID))
                ret = 0;
        else
-               ret = !strcmp("PNP0C0A", info->hardware_id.value);
+               ret = !strcmp("PNP0C0A", info->hardware_id.string);
 
-       kfree(buffer.pointer);
+       kfree(info);
        return ret;
 }
 
index a8a5c29..27a7072 100644 (file)
@@ -93,15 +93,13 @@ do_acpi_find_child(acpi_handle handle, u32 lvl, void *context, void **rv)
 {
        acpi_status status;
        struct acpi_device_info *info;
-       struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
        struct acpi_find_child *find = context;
 
-       status = acpi_get_object_info(handle, &buffer);
+       status = acpi_get_object_info(handle, &info);
        if (ACPI_SUCCESS(status)) {
-               info = buffer.pointer;
                if (info->address == find->address)
                        find->handle = handle;
-               kfree(buffer.pointer);
+               kfree(info);
        }
        return AE_OK;
 }
index 781435d..0ab526d 100644 (file)
@@ -60,13 +60,13 @@ static int create_modalias(struct acpi_device *acpi_dev, char *modalias,
        }
 
        if (acpi_dev->flags.compatible_ids) {
-               struct acpi_compatible_id_list *cid_list;
+               struct acpica_device_id_list *cid_list;
                int i;
 
                cid_list = acpi_dev->pnp.cid_list;
                for (i = 0; i < cid_list->count; i++) {
                        count = snprintf(&modalias[len], size, "%s:",
-                                        cid_list->id[i].value);
+                                        cid_list->ids[i].string);
                        if (count < 0 || count >= size) {
                                printk(KERN_ERR PREFIX "%s cid[%i] exceeds event buffer size",
                                       acpi_dev->pnp.device_name, i);
@@ -287,14 +287,14 @@ int acpi_match_device_ids(struct acpi_device *device,
        }
 
        if (device->flags.compatible_ids) {
-               struct acpi_compatible_id_list *cid_list = device->pnp.cid_list;
+               struct acpica_device_id_list *cid_list = device->pnp.cid_list;
                int i;
 
                for (id = ids; id->id[0]; id++) {
                        /* compare multiple _CID entries against driver ids */
                        for (i = 0; i < cid_list->count; i++) {
                                if (!strcmp((char*)id->id,
-                                           cid_list->id[i].value))
+                                           cid_list->ids[i].string))
                                        return 0;
                        }
                }
@@ -999,33 +999,89 @@ static int acpi_dock_match(struct acpi_device *device)
        return acpi_get_handle(device->handle, "_DCK", &tmp);
 }
 
+static struct acpica_device_id_list*
+acpi_add_cid(
+       struct acpi_device_info         *info,
+       struct acpica_device_id         *new_cid)
+{
+       struct acpica_device_id_list    *cid;
+       char                            *next_id_string;
+       acpi_size                       cid_length;
+       acpi_size                       new_cid_length;
+       u32                             i;
+
+
+       /* Allocate new CID list with room for the new CID */
+
+       if (!new_cid)
+               new_cid_length = info->compatible_id_list.list_size;
+       else if (info->compatible_id_list.list_size)
+               new_cid_length = info->compatible_id_list.list_size +
+                       new_cid->length + sizeof(struct acpica_device_id);
+       else
+               new_cid_length = sizeof(struct acpica_device_id_list) + new_cid->length;
+
+       cid = ACPI_ALLOCATE_ZEROED(new_cid_length);
+       if (!cid) {
+               return NULL;
+       }
+
+       cid->list_size = new_cid_length;
+       cid->count = info->compatible_id_list.count;
+       if (new_cid)
+               cid->count++;
+       next_id_string = (char *) cid->ids + (cid->count * sizeof(struct acpica_device_id));
+
+       /* Copy all existing CIDs */
+
+       for (i = 0; i < info->compatible_id_list.count; i++) {
+               cid_length = info->compatible_id_list.ids[i].length;
+               cid->ids[i].string = next_id_string;
+               cid->ids[i].length = cid_length;
+
+               ACPI_MEMCPY(next_id_string, info->compatible_id_list.ids[i].string,
+                       cid_length);
+
+               next_id_string += cid_length;
+       }
+
+       /* Append the new CID */
+
+       if (new_cid) {
+               cid->ids[i].string = next_id_string;
+               cid->ids[i].length = new_cid->length;
+
+               ACPI_MEMCPY(next_id_string, new_cid->string, new_cid->length);
+       }
+
+       return cid;
+}
+
 static void acpi_device_set_id(struct acpi_device *device,
                               struct acpi_device *parent, acpi_handle handle,
                               int type)
 {
-       struct acpi_device_info *info;
-       struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
+       struct acpi_device_info *info = NULL;
        char *hid = NULL;
        char *uid = NULL;
-       struct acpi_compatible_id_list *cid_list = NULL;
-       const char *cid_add = NULL;
+       struct acpica_device_id_list *cid_list = NULL;
+       char *cid_add = NULL;
        acpi_status status;
 
        switch (type) {
        case ACPI_BUS_TYPE_DEVICE:
-               status = acpi_get_object_info(handle, &buffer);
+               status = acpi_get_object_info(handle, &info);
                if (ACPI_FAILURE(status)) {
                        printk(KERN_ERR PREFIX "%s: Error reading device info\n", __func__);
                        return;
                }
 
-               info = buffer.pointer;
                if (info->valid & ACPI_VALID_HID)
-                       hid = info->hardware_id.value;
+                       hid = info->hardware_id.string;
                if (info->valid & ACPI_VALID_UID)
-                       uid = info->unique_id.value;
+                       uid = info->unique_id.string;
                if (info->valid & ACPI_VALID_CID)
-                       cid_list = &info->compatibility_id;
+                       cid_list = &info->compatible_id_list;
                if (info->valid & ACPI_VALID_ADR) {
                        device->pnp.bus_address = info->address;
                        device->flags.bus_address = 1;
@@ -1076,55 +1132,44 @@ static void acpi_device_set_id(struct acpi_device *device,
        }
 
        if (hid) {
-               strcpy(device->pnp.hardware_id, hid);
-               device->flags.hardware_id = 1;
-       }
+               device->pnp.hardware_id = ACPI_ALLOCATE_ZEROED(strlen (hid) + 1);
+               if (device->pnp.hardware_id) {
+                       strcpy(device->pnp.hardware_id, hid);
+                       device->flags.hardware_id = 1;
+               }
+       } else
+               device->pnp.hardware_id = NULL;
+
        if (uid) {
-               strcpy(device->pnp.unique_id, uid);
-               device->flags.unique_id = 1;
-       }
+               device->pnp.unique_id = ACPI_ALLOCATE_ZEROED(strlen (uid) + 1);
+               if (device->pnp.unique_id) {
+                       strcpy(device->pnp.unique_id, uid);
+                       device->flags.unique_id = 1;
+               }
+       } else
+               device->pnp.unique_id = NULL;
+
        if (cid_list || cid_add) {
-               struct  acpi_compatible_id_list *list;
-               int size = 0;
-               int count = 0;
-
-               if (cid_list) {
-                       size = cid_list->size;
-               } else if (cid_add) {
-                       size = sizeof(struct acpi_compatible_id_list);
-                       cid_list = ACPI_ALLOCATE_ZEROED((acpi_size) size);
-                       if (!cid_list) {
-                               printk(KERN_ERR "Memory allocation error\n");
-                               kfree(buffer.pointer);
-                               return;
-                       } else {
-                               cid_list->count = 0;
-                               cid_list->size = size;
-                       }
+               struct acpica_device_id_list *list;
+
+               if (cid_add) {
+                       struct acpica_device_id cid;
+                       cid.length = strlen (cid_add) + 1;
+                       cid.string = cid_add;
+
+                       list = acpi_add_cid(info, &cid);
+               } else {
+                       list = acpi_add_cid(info, NULL);
                }
-               if (cid_add)
-                       size += sizeof(struct acpi_compatible_id);
-               list = kmalloc(size, GFP_KERNEL);
 
                if (list) {
-                       if (cid_list) {
-                               memcpy(list, cid_list, cid_list->size);
-                               count = cid_list->count;
-                       }
-                       if (cid_add) {
-                               strncpy(list->id[count].value, cid_add,
-                                       ACPI_MAX_CID_LENGTH);
-                               count++;
-                               device->flags.compatible_ids = 1;
-                       }
-                       list->size = size;
-                       list->count = count;
                        device->pnp.cid_list = list;
-               } else
-                       printk(KERN_ERR PREFIX "Memory allocation error\n");
+                       if (cid_add)
+                               device->flags.compatible_ids = 1;
+               }
        }
 
-       kfree(buffer.pointer);
+       kfree(info);
 }
 
 static int acpi_device_set_context(struct acpi_device *device, int type)
index 8f3d4c1..7bead4c 100644 (file)
@@ -478,7 +478,6 @@ zx1_gart_probe (acpi_handle obj, u32 depth, void *context, void **ret)
 {
        acpi_handle handle, parent;
        acpi_status status;
-       struct acpi_buffer buffer;
        struct acpi_device_info *info;
        u64 lba_hpa, sba_hpa, length;
        int match;
@@ -490,13 +489,11 @@ zx1_gart_probe (acpi_handle obj, u32 depth, void *context, void **ret)
        /* Look for an enclosing IOC scope and find its CSR space */
        handle = obj;
        do {
-               buffer.length = ACPI_ALLOCATE_LOCAL_BUFFER;
-               status = acpi_get_object_info(handle, &buffer);
+               status = acpi_get_object_info(handle, &info);
                if (ACPI_SUCCESS(status)) {
                        /* TBD check _CID also */
-                       info = buffer.pointer;
-                       info->hardware_id.value[sizeof(info->hardware_id)-1] = '\0';
-                       match = (strcmp(info->hardware_id.value, "HWP0001") == 0);
+                       info->hardware_id.string[sizeof(info->hardware_id.length)-1] = '\0';
+                       match = (strcmp(info->hardware_id.string, "HWP0001") == 0);
                        kfree(info);
                        if (match) {
                                status = hp_acpi_csr_space(handle, &sba_hpa, &length);
index c509c99..c0cf45a 100644 (file)
@@ -114,8 +114,6 @@ static int ide_get_dev_handle(struct device *dev, acpi_handle *handle,
        unsigned int bus, devnum, func;
        acpi_integer addr;
        acpi_handle dev_handle;
-       struct acpi_buffer buffer = {.length = ACPI_ALLOCATE_BUFFER,
-                                       .pointer = NULL};
        acpi_status status;
        struct acpi_device_info *dinfo = NULL;
        int ret = -ENODEV;
@@ -134,12 +132,11 @@ static int ide_get_dev_handle(struct device *dev, acpi_handle *handle,
                goto err;
        }
 
-       status = acpi_get_object_info(dev_handle, &buffer);
+       status = acpi_get_object_info(dev_handle, &dinfo);
        if (ACPI_FAILURE(status)) {
                DEBPRINT("get_object_info for device failed\n");
                goto err;
        }
-       dinfo = buffer.pointer;
        if (dinfo && (dinfo->valid & ACPI_VALID_ADR) &&
            dinfo->address == addr) {
                *pcidevfn = addr;
index 5befa7e..a9d926b 100644 (file)
@@ -398,23 +398,21 @@ static acpi_status __init ibm_find_acpi_device(acpi_handle handle,
        acpi_handle *phandle = (acpi_handle *)context;
        acpi_status status; 
        struct acpi_device_info *info;
-       struct acpi_buffer info_buffer = { ACPI_ALLOCATE_BUFFER, NULL };
        int retval = 0;
 
-       status = acpi_get_object_info(handle, &info_buffer);
+       status = acpi_get_object_info(handle, &info);
        if (ACPI_FAILURE(status)) {
                err("%s:  Failed to get device information status=0x%x\n",
                        __func__, status);
                return retval;
        }
-       info = info_buffer.pointer;
-       info->hardware_id.value[sizeof(info->hardware_id.value) - 1] = '\0';
+       info->hardware_id.string[sizeof(info->hardware_id.length) - 1] = '\0';
 
        if (info->current_status && (info->valid & ACPI_VALID_HID) &&
-                       (!strcmp(info->hardware_id.value, IBM_HARDWARE_ID1) ||
-                        !strcmp(info->hardware_id.value, IBM_HARDWARE_ID2))) {
+                       (!strcmp(info->hardware_id.string, IBM_HARDWARE_ID1) ||
+                        !strcmp(info->hardware_id.string, IBM_HARDWARE_ID2))) {
                dbg("found hardware: %s, handle: %p\n",
-                       info->hardware_id.value, handle);
+                       info->hardware_id.string, handle);
                *phandle = handle;
                /* returning non-zero causes the search to stop
                 * and returns this value to the caller of 
index dafaa4a..f9f68e0 100644 (file)
@@ -976,15 +976,12 @@ static acpi_status sony_walk_callback(acpi_handle handle, u32 level,
                                      void *context, void **return_value)
 {
        struct acpi_device_info *info;
-       struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
-
-       if (ACPI_SUCCESS(acpi_get_object_info(handle, &buffer))) {
-               info = buffer.pointer;
 
+       if (ACPI_SUCCESS(acpi_get_object_info(handle, &info))) {
                printk(KERN_WARNING DRV_PFX "method: name: %4.4s, args %X\n",
                        (char *)&info->name, info->param_count);
 
-               kfree(buffer.pointer);
+               kfree(info);
        }
 
        return AE_OK;
index 9496494..c07fdb9 100644 (file)
@@ -194,13 +194,13 @@ static int __init pnpacpi_add_device(struct acpi_device *device)
                pnpacpi_parse_resource_option_data(dev);
 
        if (device->flags.compatible_ids) {
-               struct acpi_compatible_id_list *cid_list = device->pnp.cid_list;
+               struct acpica_device_id_list *cid_list = device->pnp.cid_list;
                int i;
 
                for (i = 0; i < cid_list->count; i++) {
-                       if (!ispnpidacpi(cid_list->id[i].value))
+                       if (!ispnpidacpi(cid_list->ids[i].string))
                                continue;
-                       pnp_add_id(dev, cid_list->id[i].value);
+                       pnp_add_id(dev, cid_list->ids[i].string);
                }
        }
 
index c65e4ce..b91420b 100644 (file)
@@ -173,17 +173,15 @@ struct acpi_device_dir {
 
 typedef char acpi_bus_id[8];
 typedef unsigned long acpi_bus_address;
-typedef char acpi_hardware_id[15];
-typedef char acpi_unique_id[9];
 typedef char acpi_device_name[40];
 typedef char acpi_device_class[20];
 
 struct acpi_device_pnp {
        acpi_bus_id bus_id;     /* Object name */
        acpi_bus_address bus_address;   /* _ADR */
-       acpi_hardware_id hardware_id;   /* _HID */
-       struct acpi_compatible_id_list *cid_list;       /* _CIDs */
-       acpi_unique_id unique_id;       /* _UID */
+       char *hardware_id;      /* _HID */
+       struct acpica_device_id_list *cid_list; /* _CIDs */
+       char *unique_id;        /* _UID */
        acpi_device_name device_name;   /* Driver-determined */
        acpi_device_class device_class; /*        "          */
 };
index b450a19..04904c7 100644 (file)
@@ -200,7 +200,8 @@ acpi_evaluate_object_typed(acpi_handle object,
                           acpi_object_type return_type);
 
 acpi_status
-acpi_get_object_info(acpi_handle handle, struct acpi_buffer *return_buffer);
+acpi_get_object_info(acpi_handle handle,
+                    struct acpi_device_info **return_buffer);
 
 acpi_status acpi_install_method(u8 *buffer);
 
index 37ba576..7a4ff79 100644 (file)
@@ -338,7 +338,7 @@ typedef u32 acpi_physical_address;
 
 /* PM Timer ticks per second (HZ) */
 
-#define PM_TIMER_FREQUENCY  3579545
+#define PM_TIMER_FREQUENCY              3579545
 
 /*******************************************************************************
  *
@@ -969,38 +969,60 @@ acpi_status(*acpi_walk_callback) (acpi_handle obj_handle,
 #define ACPI_INTERRUPT_NOT_HANDLED      0x00
 #define ACPI_INTERRUPT_HANDLED          0x01
 
-/* Length of _HID, _UID, _CID, and UUID values */
+/* Length of 32-bit EISAID values when converted back to a string */
+
+#define ACPI_EISAID_STRING_SIZE         8      /* Includes null terminator */
+
+/* Length of UUID (string) values */
 
-#define ACPI_DEVICE_ID_LENGTH           0x09
-#define ACPI_MAX_CID_LENGTH             48
 #define ACPI_UUID_LENGTH                16
 
-/* Common string version of device HIDs and UIDs */
+/* Structures used for device/processor HID, UID, CID */
 
 struct acpica_device_id {
-       char value[ACPI_DEVICE_ID_LENGTH];
+       u32 length;             /* Length of string + null */
+       char *string;
 };
 
-/* Common string version of device CIDs */
-
-struct acpi_compatible_id {
-       char value[ACPI_MAX_CID_LENGTH];
+struct acpica_device_id_list {
+       u32 count;              /* Number of IDs in Ids array */
+       u32 list_size;          /* Size of list, including ID strings */
+       struct acpica_device_id ids[1]; /* ID array */
 };
 
-struct acpi_compatible_id_list {
-       u32 count;
-       u32 size;
-       struct acpi_compatible_id id[1];
+/*
+ * Structure returned from acpi_get_object_info.
+ * Optimized for both 32- and 64-bit builds
+ */
+struct acpi_device_info {
+       u32 info_size;          /* Size of info, including ID strings */
+       u32 name;               /* ACPI object Name */
+       acpi_object_type type;  /* ACPI object Type */
+       u8 param_count;         /* If a method, required parameter count */
+       u8 valid;               /* Indicates which optional fields are valid */
+       u8 flags;               /* Miscellaneous info */
+       u8 highest_dstates[4];  /* _sx_d values: 0xFF indicates not valid */
+       u8 lowest_dstates[5];   /* _sx_w values: 0xFF indicates not valid */
+       u32 current_status;     /* _STA value */
+       acpi_integer address;   /* _ADR value */
+       struct acpica_device_id hardware_id;    /* _HID value */
+       struct acpica_device_id unique_id;      /* _UID value */
+       struct acpica_device_id_list compatible_id_list;        /* _CID list <must be last> */
 };
 
-/* Structure and flags for acpi_get_object_info */
+/* Values for Flags field above (acpi_get_object_info) */
+
+#define ACPI_PCI_ROOT_BRIDGE            0x01
 
-#define ACPI_VALID_STA                  0x0001
-#define ACPI_VALID_ADR                  0x0002
-#define ACPI_VALID_HID                  0x0004
-#define ACPI_VALID_UID                  0x0008
-#define ACPI_VALID_CID                  0x0010
-#define ACPI_VALID_SXDS                 0x0020
+/* Flags for Valid field above (acpi_get_object_info) */
+
+#define ACPI_VALID_STA                  0x01
+#define ACPI_VALID_ADR                  0x02
+#define ACPI_VALID_HID                  0x04
+#define ACPI_VALID_UID                  0x08
+#define ACPI_VALID_CID                  0x10
+#define ACPI_VALID_SXDS                 0x20
+#define ACPI_VALID_SXWS                 0x40
 
 /* Flags for _STA method */
 
@@ -1011,29 +1033,6 @@ struct acpi_compatible_id_list {
 #define ACPI_STA_DEVICE_OK              0x08   /* Synonym */
 #define ACPI_STA_BATTERY_PRESENT        0x10
 
-#define ACPI_COMMON_OBJ_INFO \
-       acpi_object_type                type;           /* ACPI object type */ \
-       acpi_name                       name    /* ACPI object Name */
-
-struct acpi_obj_info_header {
-       ACPI_COMMON_OBJ_INFO;
-};
-
-/* Structure returned from Get Object Info */
-
-struct acpi_device_info {
-       ACPI_COMMON_OBJ_INFO;
-
-       u32 param_count;        /* If a method, required parameter count */
-       u32 valid;              /* Indicates which fields below are valid */
-       u32 current_status;     /* _STA value */
-       acpi_integer address;   /* _ADR value if any */
-       struct acpica_device_id hardware_id;    /* _HID value if any */
-       struct acpica_device_id unique_id;      /* _UID value if any */
-       u8 highest_dstates[4];  /* _sx_d values: 0xFF indicates not valid */
-       struct acpi_compatible_id_list compatibility_id;        /* List of _CIDs if any */
-};
-
 /* Context structs for address space handlers */
 
 struct acpi_pci_id {