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