Loading...
1/*******************************************************************************
2 *
3 * Module Name: rsxface - Public interfaces to the resource manager
4 *
5 ******************************************************************************/
6
7/*
8 * Copyright (C) 2000 - 2011, Intel Corp.
9 * All rights reserved.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
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.
25 *
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.
29 *
30 * NO WARRANTY
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.
42 */
43
44#include <acpi/acpi.h>
45#include "accommon.h"
46#include "acresrc.h"
47#include "acnamesp.h"
48
49#define _COMPONENT ACPI_RESOURCES
50ACPI_MODULE_NAME("rsxface")
51
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 */
68static acpi_status
69acpi_rs_match_vendor_resource(struct acpi_resource *resource, void *context);
70
71static acpi_status
72acpi_rs_validate_parameters(acpi_handle device_handle,
73 struct acpi_buffer *buffer,
74 struct acpi_namespace_node **return_node);
75
76/*******************************************************************************
77 *
78 * FUNCTION: acpi_rs_validate_parameters
79 *
80 * PARAMETERS: device_handle - Handle to a device
81 * Buffer - Pointer to a data buffer
82 * return_node - Pointer to where the device node is returned
83 *
84 * RETURN: Status
85 *
86 * DESCRIPTION: Common parameter validation for resource interfaces
87 *
88 ******************************************************************************/
89
90static acpi_status
91acpi_rs_validate_parameters(acpi_handle device_handle,
92 struct acpi_buffer *buffer,
93 struct acpi_namespace_node **return_node)
94{
95 acpi_status status;
96 struct acpi_namespace_node *node;
97
98 ACPI_FUNCTION_TRACE(rs_validate_parameters);
99
100 /*
101 * Must have a valid handle to an ACPI device
102 */
103 if (!device_handle) {
104 return_ACPI_STATUS(AE_BAD_PARAMETER);
105 }
106
107 node = acpi_ns_validate_handle(device_handle);
108 if (!node) {
109 return_ACPI_STATUS(AE_BAD_PARAMETER);
110 }
111
112 if (node->type != ACPI_TYPE_DEVICE) {
113 return_ACPI_STATUS(AE_TYPE);
114 }
115
116 /*
117 * Validate the user buffer object
118 *
119 * if there is a non-zero buffer length we also need a valid pointer in
120 * the buffer. If it's a zero buffer length, we'll be returning the
121 * needed buffer size (later), so keep going.
122 */
123 status = acpi_ut_validate_buffer(buffer);
124 if (ACPI_FAILURE(status)) {
125 return_ACPI_STATUS(status);
126 }
127
128 *return_node = node;
129 return_ACPI_STATUS(AE_OK);
130}
131
132/*******************************************************************************
133 *
134 * FUNCTION: acpi_get_irq_routing_table
135 *
136 * PARAMETERS: device_handle - Handle to the Bus device we are querying
137 * ret_buffer - Pointer to a buffer to receive the
138 * current resources for the device
139 *
140 * RETURN: Status
141 *
142 * DESCRIPTION: This function is called to get the IRQ routing table for a
143 * specific bus. The caller must first acquire a handle for the
144 * desired bus. The routine table is placed in the buffer pointed
145 * to by the ret_buffer variable parameter.
146 *
147 * If the function fails an appropriate status will be returned
148 * and the value of ret_buffer is undefined.
149 *
150 * This function attempts to execute the _PRT method contained in
151 * the object indicated by the passed device_handle.
152 *
153 ******************************************************************************/
154
155acpi_status
156acpi_get_irq_routing_table(acpi_handle device_handle,
157 struct acpi_buffer *ret_buffer)
158{
159 acpi_status status;
160 struct acpi_namespace_node *node;
161
162 ACPI_FUNCTION_TRACE(acpi_get_irq_routing_table);
163
164 /* Validate parameters then dispatch to internal routine */
165
166 status = acpi_rs_validate_parameters(device_handle, ret_buffer, &node);
167 if (ACPI_FAILURE(status)) {
168 return_ACPI_STATUS(status);
169 }
170
171 status = acpi_rs_get_prt_method_data(node, ret_buffer);
172 return_ACPI_STATUS(status);
173}
174
175ACPI_EXPORT_SYMBOL(acpi_get_irq_routing_table)
176
177/*******************************************************************************
178 *
179 * FUNCTION: acpi_get_current_resources
180 *
181 * PARAMETERS: device_handle - Handle to the device object for the
182 * device we are querying
183 * ret_buffer - Pointer to a buffer to receive the
184 * current resources for the device
185 *
186 * RETURN: Status
187 *
188 * DESCRIPTION: This function is called to get the current resources for a
189 * specific device. The caller must first acquire a handle for
190 * the desired device. The resource data is placed in the buffer
191 * pointed to by the ret_buffer variable parameter.
192 *
193 * If the function fails an appropriate status will be returned
194 * and the value of ret_buffer is undefined.
195 *
196 * This function attempts to execute the _CRS method contained in
197 * the object indicated by the passed device_handle.
198 *
199 ******************************************************************************/
200acpi_status
201acpi_get_current_resources(acpi_handle device_handle,
202 struct acpi_buffer *ret_buffer)
203{
204 acpi_status status;
205 struct acpi_namespace_node *node;
206
207 ACPI_FUNCTION_TRACE(acpi_get_current_resources);
208
209 /* Validate parameters then dispatch to internal routine */
210
211 status = acpi_rs_validate_parameters(device_handle, ret_buffer, &node);
212 if (ACPI_FAILURE(status)) {
213 return_ACPI_STATUS(status);
214 }
215
216 status = acpi_rs_get_crs_method_data(node, ret_buffer);
217 return_ACPI_STATUS(status);
218}
219
220ACPI_EXPORT_SYMBOL(acpi_get_current_resources)
221#ifdef ACPI_FUTURE_USAGE
222/*******************************************************************************
223 *
224 * FUNCTION: acpi_get_possible_resources
225 *
226 * PARAMETERS: device_handle - Handle to the device object for the
227 * device we are querying
228 * ret_buffer - Pointer to a buffer to receive the
229 * resources for the device
230 *
231 * RETURN: Status
232 *
233 * DESCRIPTION: This function is called to get a list of the possible resources
234 * for a specific device. The caller must first acquire a handle
235 * for the desired device. The resource data is placed in the
236 * buffer pointed to by the ret_buffer variable.
237 *
238 * If the function fails an appropriate status will be returned
239 * and the value of ret_buffer is undefined.
240 *
241 ******************************************************************************/
242acpi_status
243acpi_get_possible_resources(acpi_handle device_handle,
244 struct acpi_buffer *ret_buffer)
245{
246 acpi_status status;
247 struct acpi_namespace_node *node;
248
249 ACPI_FUNCTION_TRACE(acpi_get_possible_resources);
250
251 /* Validate parameters then dispatch to internal routine */
252
253 status = acpi_rs_validate_parameters(device_handle, ret_buffer, &node);
254 if (ACPI_FAILURE(status)) {
255 return_ACPI_STATUS(status);
256 }
257
258 status = acpi_rs_get_prs_method_data(node, ret_buffer);
259 return_ACPI_STATUS(status);
260}
261
262ACPI_EXPORT_SYMBOL(acpi_get_possible_resources)
263#endif /* ACPI_FUTURE_USAGE */
264/*******************************************************************************
265 *
266 * FUNCTION: acpi_set_current_resources
267 *
268 * PARAMETERS: device_handle - Handle to the device object for the
269 * device we are setting resources
270 * in_buffer - Pointer to a buffer containing the
271 * resources to be set for the device
272 *
273 * RETURN: Status
274 *
275 * DESCRIPTION: This function is called to set the current resources for a
276 * specific device. The caller must first acquire a handle for
277 * the desired device. The resource data is passed to the routine
278 * the buffer pointed to by the in_buffer variable.
279 *
280 ******************************************************************************/
281acpi_status
282acpi_set_current_resources(acpi_handle device_handle,
283 struct acpi_buffer *in_buffer)
284{
285 acpi_status status;
286 struct acpi_namespace_node *node;
287
288 ACPI_FUNCTION_TRACE(acpi_set_current_resources);
289
290 /* Validate the buffer, don't allow zero length */
291
292 if ((!in_buffer) || (!in_buffer->pointer) || (!in_buffer->length)) {
293 return_ACPI_STATUS(AE_BAD_PARAMETER);
294 }
295
296 /* Validate parameters then dispatch to internal routine */
297
298 status = acpi_rs_validate_parameters(device_handle, in_buffer, &node);
299 if (ACPI_FAILURE(status)) {
300 return_ACPI_STATUS(status);
301 }
302
303 status = acpi_rs_set_srs_method_data(node, in_buffer);
304 return_ACPI_STATUS(status);
305}
306
307ACPI_EXPORT_SYMBOL(acpi_set_current_resources)
308
309/******************************************************************************
310 *
311 * FUNCTION: acpi_resource_to_address64
312 *
313 * PARAMETERS: Resource - Pointer to a resource
314 * Out - Pointer to the users's return buffer
315 * (a struct acpi_resource_address64)
316 *
317 * RETURN: Status
318 *
319 * DESCRIPTION: If the resource is an address16, address32, or address64,
320 * copy it to the address64 return buffer. This saves the
321 * caller from having to duplicate code for different-sized
322 * addresses.
323 *
324 ******************************************************************************/
325acpi_status
326acpi_resource_to_address64(struct acpi_resource *resource,
327 struct acpi_resource_address64 *out)
328{
329 struct acpi_resource_address16 *address16;
330 struct acpi_resource_address32 *address32;
331
332 if (!resource || !out) {
333 return (AE_BAD_PARAMETER);
334 }
335
336 /* Convert 16 or 32 address descriptor to 64 */
337
338 switch (resource->type) {
339 case ACPI_RESOURCE_TYPE_ADDRESS16:
340
341 address16 =
342 ACPI_CAST_PTR(struct acpi_resource_address16,
343 &resource->data);
344 ACPI_COPY_ADDRESS(out, address16);
345 break;
346
347 case ACPI_RESOURCE_TYPE_ADDRESS32:
348
349 address32 =
350 ACPI_CAST_PTR(struct acpi_resource_address32,
351 &resource->data);
352 ACPI_COPY_ADDRESS(out, address32);
353 break;
354
355 case ACPI_RESOURCE_TYPE_ADDRESS64:
356
357 /* Simple copy for 64 bit source */
358
359 ACPI_MEMCPY(out, &resource->data,
360 sizeof(struct acpi_resource_address64));
361 break;
362
363 default:
364 return (AE_BAD_PARAMETER);
365 }
366
367 return (AE_OK);
368}
369
370ACPI_EXPORT_SYMBOL(acpi_resource_to_address64)
371
372/*******************************************************************************
373 *
374 * FUNCTION: acpi_get_vendor_resource
375 *
376 * PARAMETERS: device_handle - Handle for the parent device object
377 * Name - Method name for the parent resource
378 * (METHOD_NAME__CRS or METHOD_NAME__PRS)
379 * Uuid - Pointer to the UUID to be matched.
380 * includes both subtype and 16-byte UUID
381 * ret_buffer - Where the vendor resource is returned
382 *
383 * RETURN: Status
384 *
385 * DESCRIPTION: Walk a resource template for the specified evice to find a
386 * vendor-defined resource that matches the supplied UUID and
387 * UUID subtype. Returns a struct acpi_resource of type Vendor.
388 *
389 ******************************************************************************/
390acpi_status
391acpi_get_vendor_resource(acpi_handle device_handle,
392 char *name,
393 struct acpi_vendor_uuid * uuid,
394 struct acpi_buffer * ret_buffer)
395{
396 struct acpi_vendor_walk_info info;
397 acpi_status status;
398
399 /* Other parameters are validated by acpi_walk_resources */
400
401 if (!uuid || !ret_buffer) {
402 return (AE_BAD_PARAMETER);
403 }
404
405 info.uuid = uuid;
406 info.buffer = ret_buffer;
407 info.status = AE_NOT_EXIST;
408
409 /* Walk the _CRS or _PRS resource list for this device */
410
411 status =
412 acpi_walk_resources(device_handle, name,
413 acpi_rs_match_vendor_resource, &info);
414 if (ACPI_FAILURE(status)) {
415 return (status);
416 }
417
418 return (info.status);
419}
420
421ACPI_EXPORT_SYMBOL(acpi_get_vendor_resource)
422
423/*******************************************************************************
424 *
425 * FUNCTION: acpi_rs_match_vendor_resource
426 *
427 * PARAMETERS: acpi_walk_resource_callback
428 *
429 * RETURN: Status
430 *
431 * DESCRIPTION: Match a vendor resource via the ACPI 3.0 UUID
432 *
433 ******************************************************************************/
434static acpi_status
435acpi_rs_match_vendor_resource(struct acpi_resource *resource, void *context)
436{
437 struct acpi_vendor_walk_info *info = context;
438 struct acpi_resource_vendor_typed *vendor;
439 struct acpi_buffer *buffer;
440 acpi_status status;
441
442 /* Ignore all descriptors except Vendor */
443
444 if (resource->type != ACPI_RESOURCE_TYPE_VENDOR) {
445 return (AE_OK);
446 }
447
448 vendor = &resource->data.vendor_typed;
449
450 /*
451 * For a valid match, these conditions must hold:
452 *
453 * 1) Length of descriptor data must be at least as long as a UUID struct
454 * 2) The UUID subtypes must match
455 * 3) The UUID data must match
456 */
457 if ((vendor->byte_length < (ACPI_UUID_LENGTH + 1)) ||
458 (vendor->uuid_subtype != info->uuid->subtype) ||
459 (ACPI_MEMCMP(vendor->uuid, info->uuid->data, ACPI_UUID_LENGTH))) {
460 return (AE_OK);
461 }
462
463 /* Validate/Allocate/Clear caller buffer */
464
465 buffer = info->buffer;
466 status = acpi_ut_initialize_buffer(buffer, resource->length);
467 if (ACPI_FAILURE(status)) {
468 return (status);
469 }
470
471 /* Found the correct resource, copy and return it */
472
473 ACPI_MEMCPY(buffer->pointer, resource, resource->length);
474 buffer->length = resource->length;
475
476 /* Found the desired descriptor, terminate resource walk */
477
478 info->status = AE_OK;
479 return (AE_CTRL_TERMINATE);
480}
481
482/*******************************************************************************
483 *
484 * FUNCTION: acpi_walk_resources
485 *
486 * PARAMETERS: device_handle - Handle to the device object for the
487 * device we are querying
488 * Name - Method name of the resources we want
489 * (METHOD_NAME__CRS or METHOD_NAME__PRS)
490 * user_function - Called for each resource
491 * Context - Passed to user_function
492 *
493 * RETURN: Status
494 *
495 * DESCRIPTION: Retrieves the current or possible resource list for the
496 * specified device. The user_function is called once for
497 * each resource in the list.
498 *
499 ******************************************************************************/
500acpi_status
501acpi_walk_resources(acpi_handle device_handle,
502 char *name,
503 acpi_walk_resource_callback user_function, void *context)
504{
505 acpi_status status;
506 struct acpi_buffer buffer;
507 struct acpi_resource *resource;
508 struct acpi_resource *resource_end;
509
510 ACPI_FUNCTION_TRACE(acpi_walk_resources);
511
512 /* Parameter validation */
513
514 if (!device_handle || !user_function || !name ||
515 (!ACPI_COMPARE_NAME(name, METHOD_NAME__CRS) &&
516 !ACPI_COMPARE_NAME(name, METHOD_NAME__PRS))) {
517 return_ACPI_STATUS(AE_BAD_PARAMETER);
518 }
519
520 /* Get the _CRS or _PRS resource list */
521
522 buffer.length = ACPI_ALLOCATE_LOCAL_BUFFER;
523 status = acpi_rs_get_method_data(device_handle, name, &buffer);
524 if (ACPI_FAILURE(status)) {
525 return_ACPI_STATUS(status);
526 }
527
528 /* Buffer now contains the resource list */
529
530 resource = ACPI_CAST_PTR(struct acpi_resource, buffer.pointer);
531 resource_end =
532 ACPI_ADD_PTR(struct acpi_resource, buffer.pointer, buffer.length);
533
534 /* Walk the resource list until the end_tag is found (or buffer end) */
535
536 while (resource < resource_end) {
537
538 /* Sanity check the resource */
539
540 if (resource->type > ACPI_RESOURCE_TYPE_MAX) {
541 status = AE_AML_INVALID_RESOURCE_TYPE;
542 break;
543 }
544
545 /* Invoke the user function, abort on any error returned */
546
547 status = user_function(resource, context);
548 if (ACPI_FAILURE(status)) {
549 if (status == AE_CTRL_TERMINATE) {
550
551 /* This is an OK termination by the user function */
552
553 status = AE_OK;
554 }
555 break;
556 }
557
558 /* end_tag indicates end-of-list */
559
560 if (resource->type == ACPI_RESOURCE_TYPE_END_TAG) {
561 break;
562 }
563
564 /* Get the next resource descriptor */
565
566 resource =
567 ACPI_ADD_PTR(struct acpi_resource, resource,
568 resource->length);
569 }
570
571 ACPI_FREE(buffer.pointer);
572 return_ACPI_STATUS(status);
573}
574
575ACPI_EXPORT_SYMBOL(acpi_walk_resources)
1/*******************************************************************************
2 *
3 * Module Name: rsxface - Public interfaces to the resource manager
4 *
5 ******************************************************************************/
6
7/*
8 * Copyright (C) 2000 - 2016, Intel Corp.
9 * All rights reserved.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
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.
25 *
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.
29 *
30 * NO WARRANTY
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.
42 */
43
44#define EXPORT_ACPI_INTERFACES
45
46#include <acpi/acpi.h>
47#include "accommon.h"
48#include "acresrc.h"
49#include "acnamesp.h"
50
51#define _COMPONENT ACPI_RESOURCES
52ACPI_MODULE_NAME("rsxface")
53
54/* Local macros for 16,32-bit to 64-bit conversion */
55#define ACPI_COPY_FIELD(out, in, field) ((out)->field = (in)->field)
56#define ACPI_COPY_ADDRESS(out, in) \
57 ACPI_COPY_FIELD(out, in, resource_type); \
58 ACPI_COPY_FIELD(out, in, producer_consumer); \
59 ACPI_COPY_FIELD(out, in, decode); \
60 ACPI_COPY_FIELD(out, in, min_address_fixed); \
61 ACPI_COPY_FIELD(out, in, max_address_fixed); \
62 ACPI_COPY_FIELD(out, in, info); \
63 ACPI_COPY_FIELD(out, in, address.granularity); \
64 ACPI_COPY_FIELD(out, in, address.minimum); \
65 ACPI_COPY_FIELD(out, in, address.maximum); \
66 ACPI_COPY_FIELD(out, in, address.translation_offset); \
67 ACPI_COPY_FIELD(out, in, address.address_length); \
68 ACPI_COPY_FIELD(out, in, resource_source);
69/* Local prototypes */
70static acpi_status
71acpi_rs_match_vendor_resource(struct acpi_resource *resource, void *context);
72
73static acpi_status
74acpi_rs_validate_parameters(acpi_handle device_handle,
75 struct acpi_buffer *buffer,
76 struct acpi_namespace_node **return_node);
77
78/*******************************************************************************
79 *
80 * FUNCTION: acpi_rs_validate_parameters
81 *
82 * PARAMETERS: device_handle - Handle to a device
83 * buffer - Pointer to a data buffer
84 * return_node - Pointer to where the device node is returned
85 *
86 * RETURN: Status
87 *
88 * DESCRIPTION: Common parameter validation for resource interfaces
89 *
90 ******************************************************************************/
91
92static acpi_status
93acpi_rs_validate_parameters(acpi_handle device_handle,
94 struct acpi_buffer *buffer,
95 struct acpi_namespace_node **return_node)
96{
97 acpi_status status;
98 struct acpi_namespace_node *node;
99
100 ACPI_FUNCTION_TRACE(rs_validate_parameters);
101
102 /*
103 * Must have a valid handle to an ACPI device
104 */
105 if (!device_handle) {
106 return_ACPI_STATUS(AE_BAD_PARAMETER);
107 }
108
109 node = acpi_ns_validate_handle(device_handle);
110 if (!node) {
111 return_ACPI_STATUS(AE_BAD_PARAMETER);
112 }
113
114 if (node->type != ACPI_TYPE_DEVICE) {
115 return_ACPI_STATUS(AE_TYPE);
116 }
117
118 /*
119 * Validate the user buffer object
120 *
121 * if there is a non-zero buffer length we also need a valid pointer in
122 * the buffer. If it's a zero buffer length, we'll be returning the
123 * needed buffer size (later), so keep going.
124 */
125 status = acpi_ut_validate_buffer(buffer);
126 if (ACPI_FAILURE(status)) {
127 return_ACPI_STATUS(status);
128 }
129
130 *return_node = node;
131 return_ACPI_STATUS(AE_OK);
132}
133
134/*******************************************************************************
135 *
136 * FUNCTION: acpi_get_irq_routing_table
137 *
138 * PARAMETERS: device_handle - Handle to the Bus device we are querying
139 * ret_buffer - Pointer to a buffer to receive the
140 * current resources for the device
141 *
142 * RETURN: Status
143 *
144 * DESCRIPTION: This function is called to get the IRQ routing table for a
145 * specific bus. The caller must first acquire a handle for the
146 * desired bus. The routine table is placed in the buffer pointed
147 * to by the ret_buffer variable parameter.
148 *
149 * If the function fails an appropriate status will be returned
150 * and the value of ret_buffer is undefined.
151 *
152 * This function attempts to execute the _PRT method contained in
153 * the object indicated by the passed device_handle.
154 *
155 ******************************************************************************/
156
157acpi_status
158acpi_get_irq_routing_table(acpi_handle device_handle,
159 struct acpi_buffer *ret_buffer)
160{
161 acpi_status status;
162 struct acpi_namespace_node *node;
163
164 ACPI_FUNCTION_TRACE(acpi_get_irq_routing_table);
165
166 /* Validate parameters then dispatch to internal routine */
167
168 status = acpi_rs_validate_parameters(device_handle, ret_buffer, &node);
169 if (ACPI_FAILURE(status)) {
170 return_ACPI_STATUS(status);
171 }
172
173 status = acpi_rs_get_prt_method_data(node, ret_buffer);
174 return_ACPI_STATUS(status);
175}
176
177ACPI_EXPORT_SYMBOL(acpi_get_irq_routing_table)
178
179/*******************************************************************************
180 *
181 * FUNCTION: acpi_get_current_resources
182 *
183 * PARAMETERS: device_handle - Handle to the device object for the
184 * device we are querying
185 * ret_buffer - Pointer to a buffer to receive the
186 * current resources for the device
187 *
188 * RETURN: Status
189 *
190 * DESCRIPTION: This function is called to get the current resources for a
191 * specific device. The caller must first acquire a handle for
192 * the desired device. The resource data is placed in the buffer
193 * pointed to by the ret_buffer variable parameter.
194 *
195 * If the function fails an appropriate status will be returned
196 * and the value of ret_buffer is undefined.
197 *
198 * This function attempts to execute the _CRS method contained in
199 * the object indicated by the passed device_handle.
200 *
201 ******************************************************************************/
202acpi_status
203acpi_get_current_resources(acpi_handle device_handle,
204 struct acpi_buffer *ret_buffer)
205{
206 acpi_status status;
207 struct acpi_namespace_node *node;
208
209 ACPI_FUNCTION_TRACE(acpi_get_current_resources);
210
211 /* Validate parameters then dispatch to internal routine */
212
213 status = acpi_rs_validate_parameters(device_handle, ret_buffer, &node);
214 if (ACPI_FAILURE(status)) {
215 return_ACPI_STATUS(status);
216 }
217
218 status = acpi_rs_get_crs_method_data(node, ret_buffer);
219 return_ACPI_STATUS(status);
220}
221
222ACPI_EXPORT_SYMBOL(acpi_get_current_resources)
223
224/*******************************************************************************
225 *
226 * FUNCTION: acpi_get_possible_resources
227 *
228 * PARAMETERS: device_handle - Handle to the device object for the
229 * device we are querying
230 * ret_buffer - Pointer to a buffer to receive the
231 * resources for the device
232 *
233 * RETURN: Status
234 *
235 * DESCRIPTION: This function is called to get a list of the possible resources
236 * for a specific device. The caller must first acquire a handle
237 * for the desired device. The resource data is placed in the
238 * buffer pointed to by the ret_buffer variable.
239 *
240 * If the function fails an appropriate status will be returned
241 * and the value of ret_buffer is undefined.
242 *
243 ******************************************************************************/
244acpi_status
245acpi_get_possible_resources(acpi_handle device_handle,
246 struct acpi_buffer *ret_buffer)
247{
248 acpi_status status;
249 struct acpi_namespace_node *node;
250
251 ACPI_FUNCTION_TRACE(acpi_get_possible_resources);
252
253 /* Validate parameters then dispatch to internal routine */
254
255 status = acpi_rs_validate_parameters(device_handle, ret_buffer, &node);
256 if (ACPI_FAILURE(status)) {
257 return_ACPI_STATUS(status);
258 }
259
260 status = acpi_rs_get_prs_method_data(node, ret_buffer);
261 return_ACPI_STATUS(status);
262}
263
264ACPI_EXPORT_SYMBOL(acpi_get_possible_resources)
265
266/*******************************************************************************
267 *
268 * FUNCTION: acpi_set_current_resources
269 *
270 * PARAMETERS: device_handle - Handle to the device object for the
271 * device we are setting resources
272 * in_buffer - Pointer to a buffer containing the
273 * resources to be set for the device
274 *
275 * RETURN: Status
276 *
277 * DESCRIPTION: This function is called to set the current resources for a
278 * specific device. The caller must first acquire a handle for
279 * the desired device. The resource data is passed to the routine
280 * the buffer pointed to by the in_buffer variable.
281 *
282 ******************************************************************************/
283acpi_status
284acpi_set_current_resources(acpi_handle device_handle,
285 struct acpi_buffer *in_buffer)
286{
287 acpi_status status;
288 struct acpi_namespace_node *node;
289
290 ACPI_FUNCTION_TRACE(acpi_set_current_resources);
291
292 /* Validate the buffer, don't allow zero length */
293
294 if ((!in_buffer) || (!in_buffer->pointer) || (!in_buffer->length)) {
295 return_ACPI_STATUS(AE_BAD_PARAMETER);
296 }
297
298 /* Validate parameters then dispatch to internal routine */
299
300 status = acpi_rs_validate_parameters(device_handle, in_buffer, &node);
301 if (ACPI_FAILURE(status)) {
302 return_ACPI_STATUS(status);
303 }
304
305 status = acpi_rs_set_srs_method_data(node, in_buffer);
306 return_ACPI_STATUS(status);
307}
308
309ACPI_EXPORT_SYMBOL(acpi_set_current_resources)
310
311/*******************************************************************************
312 *
313 * FUNCTION: acpi_get_event_resources
314 *
315 * PARAMETERS: device_handle - Handle to the device object for the
316 * device we are getting resources
317 * in_buffer - Pointer to a buffer containing the
318 * resources to be set for the device
319 *
320 * RETURN: Status
321 *
322 * DESCRIPTION: This function is called to get the event resources for a
323 * specific device. The caller must first acquire a handle for
324 * the desired device. The resource data is passed to the routine
325 * the buffer pointed to by the in_buffer variable. Uses the
326 * _AEI method.
327 *
328 ******************************************************************************/
329acpi_status
330acpi_get_event_resources(acpi_handle device_handle,
331 struct acpi_buffer *ret_buffer)
332{
333 acpi_status status;
334 struct acpi_namespace_node *node;
335
336 ACPI_FUNCTION_TRACE(acpi_get_event_resources);
337
338 /* Validate parameters then dispatch to internal routine */
339
340 status = acpi_rs_validate_parameters(device_handle, ret_buffer, &node);
341 if (ACPI_FAILURE(status)) {
342 return_ACPI_STATUS(status);
343 }
344
345 status = acpi_rs_get_aei_method_data(node, ret_buffer);
346 return_ACPI_STATUS(status);
347}
348
349ACPI_EXPORT_SYMBOL(acpi_get_event_resources)
350
351/******************************************************************************
352 *
353 * FUNCTION: acpi_resource_to_address64
354 *
355 * PARAMETERS: resource - Pointer to a resource
356 * out - Pointer to the users's return buffer
357 * (a struct acpi_resource_address64)
358 *
359 * RETURN: Status
360 *
361 * DESCRIPTION: If the resource is an address16, address32, or address64,
362 * copy it to the address64 return buffer. This saves the
363 * caller from having to duplicate code for different-sized
364 * addresses.
365 *
366 ******************************************************************************/
367acpi_status
368acpi_resource_to_address64(struct acpi_resource *resource,
369 struct acpi_resource_address64 *out)
370{
371 struct acpi_resource_address16 *address16;
372 struct acpi_resource_address32 *address32;
373
374 if (!resource || !out) {
375 return (AE_BAD_PARAMETER);
376 }
377
378 /* Convert 16 or 32 address descriptor to 64 */
379
380 switch (resource->type) {
381 case ACPI_RESOURCE_TYPE_ADDRESS16:
382
383 address16 =
384 ACPI_CAST_PTR(struct acpi_resource_address16,
385 &resource->data);
386 ACPI_COPY_ADDRESS(out, address16);
387 break;
388
389 case ACPI_RESOURCE_TYPE_ADDRESS32:
390
391 address32 =
392 ACPI_CAST_PTR(struct acpi_resource_address32,
393 &resource->data);
394 ACPI_COPY_ADDRESS(out, address32);
395 break;
396
397 case ACPI_RESOURCE_TYPE_ADDRESS64:
398
399 /* Simple copy for 64 bit source */
400
401 memcpy(out, &resource->data,
402 sizeof(struct acpi_resource_address64));
403 break;
404
405 default:
406
407 return (AE_BAD_PARAMETER);
408 }
409
410 return (AE_OK);
411}
412
413ACPI_EXPORT_SYMBOL(acpi_resource_to_address64)
414
415/*******************************************************************************
416 *
417 * FUNCTION: acpi_get_vendor_resource
418 *
419 * PARAMETERS: device_handle - Handle for the parent device object
420 * name - Method name for the parent resource
421 * (METHOD_NAME__CRS or METHOD_NAME__PRS)
422 * uuid - Pointer to the UUID to be matched.
423 * includes both subtype and 16-byte UUID
424 * ret_buffer - Where the vendor resource is returned
425 *
426 * RETURN: Status
427 *
428 * DESCRIPTION: Walk a resource template for the specified device to find a
429 * vendor-defined resource that matches the supplied UUID and
430 * UUID subtype. Returns a struct acpi_resource of type Vendor.
431 *
432 ******************************************************************************/
433acpi_status
434acpi_get_vendor_resource(acpi_handle device_handle,
435 char *name,
436 struct acpi_vendor_uuid * uuid,
437 struct acpi_buffer * ret_buffer)
438{
439 struct acpi_vendor_walk_info info;
440 acpi_status status;
441
442 /* Other parameters are validated by acpi_walk_resources */
443
444 if (!uuid || !ret_buffer) {
445 return (AE_BAD_PARAMETER);
446 }
447
448 info.uuid = uuid;
449 info.buffer = ret_buffer;
450 info.status = AE_NOT_EXIST;
451
452 /* Walk the _CRS or _PRS resource list for this device */
453
454 status =
455 acpi_walk_resources(device_handle, name,
456 acpi_rs_match_vendor_resource, &info);
457 if (ACPI_FAILURE(status)) {
458 return (status);
459 }
460
461 return (info.status);
462}
463
464ACPI_EXPORT_SYMBOL(acpi_get_vendor_resource)
465
466/*******************************************************************************
467 *
468 * FUNCTION: acpi_rs_match_vendor_resource
469 *
470 * PARAMETERS: acpi_walk_resource_callback
471 *
472 * RETURN: Status
473 *
474 * DESCRIPTION: Match a vendor resource via the ACPI 3.0 UUID
475 *
476 ******************************************************************************/
477static acpi_status
478acpi_rs_match_vendor_resource(struct acpi_resource *resource, void *context)
479{
480 struct acpi_vendor_walk_info *info = context;
481 struct acpi_resource_vendor_typed *vendor;
482 struct acpi_buffer *buffer;
483 acpi_status status;
484
485 /* Ignore all descriptors except Vendor */
486
487 if (resource->type != ACPI_RESOURCE_TYPE_VENDOR) {
488 return (AE_OK);
489 }
490
491 vendor = &resource->data.vendor_typed;
492
493 /*
494 * For a valid match, these conditions must hold:
495 *
496 * 1) Length of descriptor data must be at least as long as a UUID struct
497 * 2) The UUID subtypes must match
498 * 3) The UUID data must match
499 */
500 if ((vendor->byte_length < (ACPI_UUID_LENGTH + 1)) ||
501 (vendor->uuid_subtype != info->uuid->subtype) ||
502 (memcmp(vendor->uuid, info->uuid->data, ACPI_UUID_LENGTH))) {
503 return (AE_OK);
504 }
505
506 /* Validate/Allocate/Clear caller buffer */
507
508 buffer = info->buffer;
509 status = acpi_ut_initialize_buffer(buffer, resource->length);
510 if (ACPI_FAILURE(status)) {
511 return (status);
512 }
513
514 /* Found the correct resource, copy and return it */
515
516 memcpy(buffer->pointer, resource, resource->length);
517 buffer->length = resource->length;
518
519 /* Found the desired descriptor, terminate resource walk */
520
521 info->status = AE_OK;
522 return (AE_CTRL_TERMINATE);
523}
524
525/*******************************************************************************
526 *
527 * FUNCTION: acpi_walk_resource_buffer
528 *
529 * PARAMETERS: buffer - Formatted buffer returned by one of the
530 * various Get*Resource functions
531 * user_function - Called for each resource
532 * context - Passed to user_function
533 *
534 * RETURN: Status
535 *
536 * DESCRIPTION: Walks the input resource template. The user_function is called
537 * once for each resource in the list.
538 *
539 ******************************************************************************/
540
541acpi_status
542acpi_walk_resource_buffer(struct acpi_buffer * buffer,
543 acpi_walk_resource_callback user_function,
544 void *context)
545{
546 acpi_status status = AE_OK;
547 struct acpi_resource *resource;
548 struct acpi_resource *resource_end;
549
550 ACPI_FUNCTION_TRACE(acpi_walk_resource_buffer);
551
552 /* Parameter validation */
553
554 if (!buffer || !buffer->pointer || !user_function) {
555 return_ACPI_STATUS(AE_BAD_PARAMETER);
556 }
557
558 /* Buffer contains the resource list and length */
559
560 resource = ACPI_CAST_PTR(struct acpi_resource, buffer->pointer);
561 resource_end =
562 ACPI_ADD_PTR(struct acpi_resource, buffer->pointer, buffer->length);
563
564 /* Walk the resource list until the end_tag is found (or buffer end) */
565
566 while (resource < resource_end) {
567
568 /* Sanity check the resource type */
569
570 if (resource->type > ACPI_RESOURCE_TYPE_MAX) {
571 status = AE_AML_INVALID_RESOURCE_TYPE;
572 break;
573 }
574
575 /* Sanity check the length. It must not be zero, or we loop forever */
576
577 if (!resource->length) {
578 return_ACPI_STATUS(AE_AML_BAD_RESOURCE_LENGTH);
579 }
580
581 /* Invoke the user function, abort on any error returned */
582
583 status = user_function(resource, context);
584 if (ACPI_FAILURE(status)) {
585 if (status == AE_CTRL_TERMINATE) {
586
587 /* This is an OK termination by the user function */
588
589 status = AE_OK;
590 }
591 break;
592 }
593
594 /* end_tag indicates end-of-list */
595
596 if (resource->type == ACPI_RESOURCE_TYPE_END_TAG) {
597 break;
598 }
599
600 /* Get the next resource descriptor */
601
602 resource = ACPI_NEXT_RESOURCE(resource);
603 }
604
605 return_ACPI_STATUS(status);
606}
607
608ACPI_EXPORT_SYMBOL(acpi_walk_resource_buffer)
609
610/*******************************************************************************
611 *
612 * FUNCTION: acpi_walk_resources
613 *
614 * PARAMETERS: device_handle - Handle to the device object for the
615 * device we are querying
616 * name - Method name of the resources we want.
617 * (METHOD_NAME__CRS, METHOD_NAME__PRS, or
618 * METHOD_NAME__AEI)
619 * user_function - Called for each resource
620 * context - Passed to user_function
621 *
622 * RETURN: Status
623 *
624 * DESCRIPTION: Retrieves the current or possible resource list for the
625 * specified device. The user_function is called once for
626 * each resource in the list.
627 *
628 ******************************************************************************/
629acpi_status
630acpi_walk_resources(acpi_handle device_handle,
631 char *name,
632 acpi_walk_resource_callback user_function, void *context)
633{
634 acpi_status status;
635 struct acpi_buffer buffer;
636
637 ACPI_FUNCTION_TRACE(acpi_walk_resources);
638
639 /* Parameter validation */
640
641 if (!device_handle || !user_function || !name ||
642 (!ACPI_COMPARE_NAME(name, METHOD_NAME__CRS) &&
643 !ACPI_COMPARE_NAME(name, METHOD_NAME__PRS) &&
644 !ACPI_COMPARE_NAME(name, METHOD_NAME__AEI))) {
645 return_ACPI_STATUS(AE_BAD_PARAMETER);
646 }
647
648 /* Get the _CRS/_PRS/_AEI resource list */
649
650 buffer.length = ACPI_ALLOCATE_LOCAL_BUFFER;
651 status = acpi_rs_get_method_data(device_handle, name, &buffer);
652 if (ACPI_FAILURE(status)) {
653 return_ACPI_STATUS(status);
654 }
655
656 /* Walk the resource list and cleanup */
657
658 status = acpi_walk_resource_buffer(&buffer, user_function, context);
659 ACPI_FREE(buffer.pointer);
660 return_ACPI_STATUS(status);
661}
662
663ACPI_EXPORT_SYMBOL(acpi_walk_resources)