1 /*******************************************************************************
3 * Module Name: rsxface - Public interfaces to the resource manager
5 ******************************************************************************/
8 * Copyright (C) 2000 - 2006, R. Byron Moore
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions, and the following disclaimer,
16 * without modification.
17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18 * substantially similar to the "NO WARRANTY" disclaimer below
19 * ("Disclaimer") and any redistribution must be conditioned upon
20 * including a substantially similar Disclaimer requirement for further
21 * binary redistribution.
22 * 3. Neither the names of the above-listed copyright holders nor the names
23 * of any contributors may be used to endorse or promote products derived
24 * from this software without specific prior written permission.
26 * Alternatively, this software may be distributed under the terms of the
27 * GNU General Public License ("GPL") version 2 as published by the Free
28 * Software Foundation.
31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41 * POSSIBILITY OF SUCH DAMAGES.
44 #include <linux/module.h>
46 #include <acpi/acpi.h>
47 #include <acpi/acresrc.h>
49 #define _COMPONENT ACPI_RESOURCES
50 ACPI_MODULE_NAME("rsxface")
52 /* Local macros for 16,32-bit to 64-bit conversion */
53 #define ACPI_COPY_FIELD(out, in, field) ((out)->field = (in)->field)
54 #define ACPI_COPY_ADDRESS(out, in) \
55 ACPI_COPY_FIELD(out, in, resource_type); \
56 ACPI_COPY_FIELD(out, in, producer_consumer); \
57 ACPI_COPY_FIELD(out, in, decode); \
58 ACPI_COPY_FIELD(out, in, min_address_fixed); \
59 ACPI_COPY_FIELD(out, in, max_address_fixed); \
60 ACPI_COPY_FIELD(out, in, info); \
61 ACPI_COPY_FIELD(out, in, granularity); \
62 ACPI_COPY_FIELD(out, in, minimum); \
63 ACPI_COPY_FIELD(out, in, maximum); \
64 ACPI_COPY_FIELD(out, in, translation_offset); \
65 ACPI_COPY_FIELD(out, in, address_length); \
66 ACPI_COPY_FIELD(out, in, resource_source);
67 /* Local prototypes */
69 acpi_rs_match_vendor_resource(struct acpi_resource *resource, void *context);
71 /*******************************************************************************
73 * FUNCTION: acpi_get_irq_routing_table
75 * PARAMETERS: device_handle - a handle to the Bus device we are querying
76 * ret_buffer - a pointer to a buffer to receive the
77 * current resources for the device
81 * DESCRIPTION: This function is called to get the IRQ routing table for a
82 * specific bus. The caller must first acquire a handle for the
83 * desired bus. The routine table is placed in the buffer pointed
84 * to by the ret_buffer variable parameter.
86 * If the function fails an appropriate status will be returned
87 * and the value of ret_buffer is undefined.
89 * This function attempts to execute the _PRT method contained in
90 * the object indicated by the passed device_handle.
92 ******************************************************************************/
95 acpi_get_irq_routing_table(acpi_handle device_handle,
96 struct acpi_buffer *ret_buffer)
100 ACPI_FUNCTION_TRACE("acpi_get_irq_routing_table ");
103 * Must have a valid handle and buffer, So we have to have a handle
104 * and a return buffer structure, and if there is a non-zero buffer length
105 * we also need a valid pointer in the buffer. If it's a zero buffer length,
106 * we'll be returning the needed buffer size, so keep going.
108 if (!device_handle) {
109 return_ACPI_STATUS(AE_BAD_PARAMETER);
112 status = acpi_ut_validate_buffer(ret_buffer);
113 if (ACPI_FAILURE(status)) {
114 return_ACPI_STATUS(status);
117 status = acpi_rs_get_prt_method_data(device_handle, ret_buffer);
118 return_ACPI_STATUS(status);
121 /*******************************************************************************
123 * FUNCTION: acpi_get_current_resources
125 * PARAMETERS: device_handle - a handle to the device object for the
126 * device we are querying
127 * ret_buffer - a pointer to a buffer to receive the
128 * current resources for the device
132 * DESCRIPTION: This function is called to get the current resources for a
133 * specific device. The caller must first acquire a handle for
134 * the desired device. The resource data is placed in the buffer
135 * pointed to by the ret_buffer variable parameter.
137 * If the function fails an appropriate status will be returned
138 * and the value of ret_buffer is undefined.
140 * This function attempts to execute the _CRS method contained in
141 * the object indicated by the passed device_handle.
143 ******************************************************************************/
146 acpi_get_current_resources(acpi_handle device_handle,
147 struct acpi_buffer *ret_buffer)
151 ACPI_FUNCTION_TRACE("acpi_get_current_resources");
154 * Must have a valid handle and buffer, So we have to have a handle
155 * and a return buffer structure, and if there is a non-zero buffer length
156 * we also need a valid pointer in the buffer. If it's a zero buffer length,
157 * we'll be returning the needed buffer size, so keep going.
159 if (!device_handle) {
160 return_ACPI_STATUS(AE_BAD_PARAMETER);
163 status = acpi_ut_validate_buffer(ret_buffer);
164 if (ACPI_FAILURE(status)) {
165 return_ACPI_STATUS(status);
168 status = acpi_rs_get_crs_method_data(device_handle, ret_buffer);
169 return_ACPI_STATUS(status);
172 EXPORT_SYMBOL(acpi_get_current_resources);
174 /*******************************************************************************
176 * FUNCTION: acpi_get_possible_resources
178 * PARAMETERS: device_handle - a handle to the device object for the
179 * device we are querying
180 * ret_buffer - a pointer to a buffer to receive the
181 * resources for the device
185 * DESCRIPTION: This function is called to get a list of the possible resources
186 * for a specific device. The caller must first acquire a handle
187 * for the desired device. The resource data is placed in the
188 * buffer pointed to by the ret_buffer variable.
190 * If the function fails an appropriate status will be returned
191 * and the value of ret_buffer is undefined.
193 ******************************************************************************/
195 #ifdef ACPI_FUTURE_USAGE
197 acpi_get_possible_resources(acpi_handle device_handle,
198 struct acpi_buffer *ret_buffer)
202 ACPI_FUNCTION_TRACE("acpi_get_possible_resources");
205 * Must have a valid handle and buffer, So we have to have a handle
206 * and a return buffer structure, and if there is a non-zero buffer length
207 * we also need a valid pointer in the buffer. If it's a zero buffer length,
208 * we'll be returning the needed buffer size, so keep going.
210 if (!device_handle) {
211 return_ACPI_STATUS(AE_BAD_PARAMETER);
214 status = acpi_ut_validate_buffer(ret_buffer);
215 if (ACPI_FAILURE(status)) {
216 return_ACPI_STATUS(status);
219 status = acpi_rs_get_prs_method_data(device_handle, ret_buffer);
220 return_ACPI_STATUS(status);
223 EXPORT_SYMBOL(acpi_get_possible_resources);
224 #endif /* ACPI_FUTURE_USAGE */
226 /*******************************************************************************
228 * FUNCTION: acpi_walk_resources
230 * PARAMETERS: device_handle - Handle to the device object for the
231 * device we are querying
232 * Name - Method name of the resources we want
233 * (METHOD_NAME__CRS or METHOD_NAME__PRS)
234 * user_function - Called for each resource
235 * Context - Passed to user_function
239 * DESCRIPTION: Retrieves the current or possible resource list for the
240 * specified device. The user_function is called once for
241 * each resource in the list.
243 ******************************************************************************/
246 acpi_walk_resources(acpi_handle device_handle,
248 ACPI_WALK_RESOURCE_CALLBACK user_function, void *context)
251 struct acpi_buffer buffer;
252 struct acpi_resource *resource;
253 struct acpi_resource *resource_end;
255 ACPI_FUNCTION_TRACE("acpi_walk_resources");
257 /* Parameter validation */
259 if (!device_handle || !user_function || !name ||
260 (ACPI_STRNCMP(name, METHOD_NAME__CRS, sizeof(METHOD_NAME__CRS)) &&
261 ACPI_STRNCMP(name, METHOD_NAME__PRS, sizeof(METHOD_NAME__PRS)))) {
262 return_ACPI_STATUS(AE_BAD_PARAMETER);
265 /* Get the _CRS or _PRS resource list */
267 buffer.length = ACPI_ALLOCATE_LOCAL_BUFFER;
268 status = acpi_rs_get_method_data(device_handle, name, &buffer);
269 if (ACPI_FAILURE(status)) {
270 return_ACPI_STATUS(status);
273 /* Buffer now contains the resource list */
275 resource = ACPI_CAST_PTR(struct acpi_resource, buffer.pointer);
277 ACPI_ADD_PTR(struct acpi_resource, buffer.pointer, buffer.length);
279 /* Walk the resource list until the end_tag is found (or buffer end) */
281 while (resource < resource_end) {
283 /* Sanity check the resource */
285 if (resource->type > ACPI_RESOURCE_TYPE_MAX) {
286 status = AE_AML_INVALID_RESOURCE_TYPE;
290 /* Invoke the user function, abort on any error returned */
292 status = user_function(resource, context);
293 if (ACPI_FAILURE(status)) {
294 if (status == AE_CTRL_TERMINATE) {
296 /* This is an OK termination by the user function */
303 /* end_tag indicates end-of-list */
305 if (resource->type == ACPI_RESOURCE_TYPE_END_TAG) {
309 /* Get the next resource descriptor */
312 ACPI_ADD_PTR(struct acpi_resource, resource,
316 ACPI_MEM_FREE(buffer.pointer);
317 return_ACPI_STATUS(status);
320 EXPORT_SYMBOL(acpi_walk_resources);
322 /*******************************************************************************
324 * FUNCTION: acpi_set_current_resources
326 * PARAMETERS: device_handle - a handle to the device object for the
327 * device we are changing the resources of
328 * in_buffer - a pointer to a buffer containing the
329 * resources to be set for the device
333 * DESCRIPTION: This function is called to set the current resources for a
334 * specific device. The caller must first acquire a handle for
335 * the desired device. The resource data is passed to the routine
336 * the buffer pointed to by the in_buffer variable.
338 ******************************************************************************/
341 acpi_set_current_resources(acpi_handle device_handle,
342 struct acpi_buffer *in_buffer)
346 ACPI_FUNCTION_TRACE("acpi_set_current_resources");
348 /* Must have a valid handle and buffer */
350 if ((!device_handle) ||
351 (!in_buffer) || (!in_buffer->pointer) || (!in_buffer->length)) {
352 return_ACPI_STATUS(AE_BAD_PARAMETER);
355 status = acpi_rs_set_srs_method_data(device_handle, in_buffer);
356 return_ACPI_STATUS(status);
359 EXPORT_SYMBOL(acpi_set_current_resources);
361 /******************************************************************************
363 * FUNCTION: acpi_resource_to_address64
365 * PARAMETERS: Resource - Pointer to a resource
366 * Out - Pointer to the users's return
368 * struct acpi_resource_address64)
372 * DESCRIPTION: If the resource is an address16, address32, or address64,
373 * copy it to the address64 return buffer. This saves the
374 * caller from having to duplicate code for different-sized
377 ******************************************************************************/
380 acpi_resource_to_address64(struct acpi_resource *resource,
381 struct acpi_resource_address64 *out)
383 struct acpi_resource_address16 *address16;
384 struct acpi_resource_address32 *address32;
386 if (!resource || !out) {
387 return (AE_BAD_PARAMETER);
390 /* Convert 16 or 32 address descriptor to 64 */
392 switch (resource->type) {
393 case ACPI_RESOURCE_TYPE_ADDRESS16:
395 address16 = (struct acpi_resource_address16 *)&resource->data;
396 ACPI_COPY_ADDRESS(out, address16);
399 case ACPI_RESOURCE_TYPE_ADDRESS32:
401 address32 = (struct acpi_resource_address32 *)&resource->data;
402 ACPI_COPY_ADDRESS(out, address32);
405 case ACPI_RESOURCE_TYPE_ADDRESS64:
407 /* Simple copy for 64 bit source */
409 ACPI_MEMCPY(out, &resource->data,
410 sizeof(struct acpi_resource_address64));
414 return (AE_BAD_PARAMETER);
420 EXPORT_SYMBOL(acpi_resource_to_address64);
422 /*******************************************************************************
424 * FUNCTION: acpi_get_vendor_resource
426 * PARAMETERS: device_handle - Handle for the parent device object
427 * Name - Method name for the parent resource
428 * (METHOD_NAME__CRS or METHOD_NAME__PRS)
429 * Uuid - Pointer to the UUID to be matched.
430 * includes both subtype and 16-byte UUID
431 * ret_buffer - Where the vendor resource is returned
435 * DESCRIPTION: Walk a resource template for the specified evice to find a
436 * vendor-defined resource that matches the supplied UUID and
437 * UUID subtype. Returns a struct acpi_resource of type Vendor.
439 ******************************************************************************/
442 acpi_get_vendor_resource(acpi_handle device_handle,
444 struct acpi_vendor_uuid * uuid,
445 struct acpi_buffer * ret_buffer)
447 struct acpi_vendor_walk_info info;
450 /* Other parameters are validated by acpi_walk_resources */
452 if (!uuid || !ret_buffer) {
453 return (AE_BAD_PARAMETER);
457 info.buffer = ret_buffer;
458 info.status = AE_NOT_EXIST;
460 /* Walk the _CRS or _PRS resource list for this device */
463 acpi_walk_resources(device_handle, name,
464 acpi_rs_match_vendor_resource, &info);
465 if (ACPI_FAILURE(status)) {
469 return (info.status);
472 /*******************************************************************************
474 * FUNCTION: acpi_rs_match_vendor_resource
476 * PARAMETERS: ACPI_WALK_RESOURCE_CALLBACK
480 * DESCRIPTION: Match a vendor resource via the ACPI 3.0 UUID
482 ******************************************************************************/
485 acpi_rs_match_vendor_resource(struct acpi_resource *resource, void *context)
487 struct acpi_vendor_walk_info *info = context;
488 struct acpi_resource_vendor_typed *vendor;
489 struct acpi_buffer *buffer;
492 /* Ignore all descriptors except Vendor */
494 if (resource->type != ACPI_RESOURCE_TYPE_VENDOR) {
498 vendor = &resource->data.vendor_typed;
501 * For a valid match, these conditions must hold:
503 * 1) Length of descriptor data must be at least as long as a UUID struct
504 * 2) The UUID subtypes must match
505 * 3) The UUID data must match
507 if ((vendor->byte_length < (ACPI_UUID_LENGTH + 1)) ||
508 (vendor->uuid_subtype != info->uuid->subtype) ||
509 (ACPI_MEMCMP(vendor->uuid, info->uuid->data, ACPI_UUID_LENGTH))) {
513 /* Validate/Allocate/Clear caller buffer */
515 buffer = info->buffer;
516 status = acpi_ut_initialize_buffer(buffer, resource->length);
517 if (ACPI_FAILURE(status)) {
521 /* Found the correct resource, copy and return it */
523 ACPI_MEMCPY(buffer->pointer, resource, resource->length);
524 buffer->length = resource->length;
526 /* Found the desired descriptor, terminate resource walk */
528 info->status = AE_OK;
529 return (AE_CTRL_TERMINATE);