]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /******************************************************************************* |
2 | * | |
3 | * Module Name: rsutils - Utilities for the resource manager | |
4 | * | |
5 | ******************************************************************************/ | |
6 | ||
7 | /* | |
7735ca0e | 8 | * Copyright (C) 2000 - 2017, Intel Corp. |
1da177e4 LT |
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 | ||
1da177e4 | 44 | #include <acpi/acpi.h> |
e2f7a777 LB |
45 | #include "accommon.h" |
46 | #include "acnamesp.h" | |
47 | #include "acresrc.h" | |
1da177e4 | 48 | |
1da177e4 | 49 | #define _COMPONENT ACPI_RESOURCES |
4be44fcd | 50 | ACPI_MODULE_NAME("rsutils") |
1da177e4 | 51 | |
0897831b BM |
52 | /******************************************************************************* |
53 | * | |
54 | * FUNCTION: acpi_rs_decode_bitmask | |
55 | * | |
ba494bee BM |
56 | * PARAMETERS: mask - Bitmask to decode |
57 | * list - Where the converted list is returned | |
0897831b BM |
58 | * |
59 | * RETURN: Count of bits set (length of list) | |
60 | * | |
61 | * DESCRIPTION: Convert a bit mask into a list of values | |
62 | * | |
63 | ******************************************************************************/ | |
64 | u8 acpi_rs_decode_bitmask(u16 mask, u8 * list) | |
65 | { | |
67a119f9 | 66 | u8 i; |
0897831b BM |
67 | u8 bit_count; |
68 | ||
96db255c BM |
69 | ACPI_FUNCTION_ENTRY(); |
70 | ||
0897831b BM |
71 | /* Decode the mask bits */ |
72 | ||
73 | for (i = 0, bit_count = 0; mask; i++) { | |
74 | if (mask & 0x0001) { | |
67a119f9 | 75 | list[bit_count] = i; |
0897831b BM |
76 | bit_count++; |
77 | } | |
78 | ||
79 | mask >>= 1; | |
80 | } | |
81 | ||
82 | return (bit_count); | |
83 | } | |
84 | ||
85 | /******************************************************************************* | |
86 | * | |
87 | * FUNCTION: acpi_rs_encode_bitmask | |
88 | * | |
ba494bee BM |
89 | * PARAMETERS: list - List of values to encode |
90 | * count - Length of list | |
0897831b BM |
91 | * |
92 | * RETURN: Encoded bitmask | |
93 | * | |
94 | * DESCRIPTION: Convert a list of values to an encoded bitmask | |
95 | * | |
96 | ******************************************************************************/ | |
97 | ||
98 | u16 acpi_rs_encode_bitmask(u8 * list, u8 count) | |
99 | { | |
67a119f9 BM |
100 | u32 i; |
101 | u16 mask; | |
0897831b | 102 | |
96db255c BM |
103 | ACPI_FUNCTION_ENTRY(); |
104 | ||
0897831b BM |
105 | /* Encode the list into a single bitmask */ |
106 | ||
107 | for (i = 0, mask = 0; i < count; i++) { | |
1d18c058 | 108 | mask |= (0x1 << list[i]); |
0897831b BM |
109 | } |
110 | ||
9c0d7939 | 111 | return (mask); |
0897831b BM |
112 | } |
113 | ||
50eca3eb BM |
114 | /******************************************************************************* |
115 | * | |
116 | * FUNCTION: acpi_rs_move_data | |
117 | * | |
ba494bee BM |
118 | * PARAMETERS: destination - Pointer to the destination descriptor |
119 | * source - Pointer to the source descriptor | |
50eca3eb BM |
120 | * item_count - How many items to move |
121 | * move_type - Byte width | |
122 | * | |
123 | * RETURN: None | |
124 | * | |
125 | * DESCRIPTION: Move multiple data items from one descriptor to another. Handles | |
126 | * alignment issues and endian issues if necessary, as configured | |
127 | * via the ACPI_MOVE_* macros. (This is why a memcpy is not used) | |
128 | * | |
129 | ******************************************************************************/ | |
0897831b | 130 | |
50eca3eb BM |
131 | void |
132 | acpi_rs_move_data(void *destination, void *source, u16 item_count, u8 move_type) | |
133 | { | |
67a119f9 | 134 | u32 i; |
50eca3eb | 135 | |
96db255c BM |
136 | ACPI_FUNCTION_ENTRY(); |
137 | ||
50eca3eb BM |
138 | /* One move per item */ |
139 | ||
140 | for (i = 0; i < item_count; i++) { | |
141 | switch (move_type) { | |
0897831b BM |
142 | /* |
143 | * For the 8-bit case, we can perform the move all at once | |
144 | * since there are no alignment or endian issues | |
145 | */ | |
146 | case ACPI_RSC_MOVE8: | |
e0fe0a8d LM |
147 | case ACPI_RSC_MOVE_GPIO_RES: |
148 | case ACPI_RSC_MOVE_SERIAL_VEN: | |
149 | case ACPI_RSC_MOVE_SERIAL_RES: | |
1d1ea1b7 | 150 | |
4fa4616e | 151 | memcpy(destination, source, item_count); |
0897831b | 152 | return; |
50eca3eb | 153 | |
0897831b BM |
154 | /* |
155 | * 16-, 32-, and 64-bit cases must use the move macros that perform | |
58f87ed0 | 156 | * endian conversion and/or accommodate hardware that cannot perform |
0897831b BM |
157 | * misaligned memory transfers |
158 | */ | |
159 | case ACPI_RSC_MOVE16: | |
e0fe0a8d | 160 | case ACPI_RSC_MOVE_GPIO_PIN: |
1d1ea1b7 | 161 | |
c51a4de8 BM |
162 | ACPI_MOVE_16_TO_16(&ACPI_CAST_PTR(u16, destination)[i], |
163 | &ACPI_CAST_PTR(u16, source)[i]); | |
50eca3eb BM |
164 | break; |
165 | ||
0897831b | 166 | case ACPI_RSC_MOVE32: |
1d1ea1b7 | 167 | |
c51a4de8 BM |
168 | ACPI_MOVE_32_TO_32(&ACPI_CAST_PTR(u32, destination)[i], |
169 | &ACPI_CAST_PTR(u32, source)[i]); | |
50eca3eb BM |
170 | break; |
171 | ||
0897831b | 172 | case ACPI_RSC_MOVE64: |
1d1ea1b7 | 173 | |
c51a4de8 BM |
174 | ACPI_MOVE_64_TO_64(&ACPI_CAST_PTR(u64, destination)[i], |
175 | &ACPI_CAST_PTR(u64, source)[i]); | |
50eca3eb BM |
176 | break; |
177 | ||
178 | default: | |
1d1ea1b7 | 179 | |
50eca3eb BM |
180 | return; |
181 | } | |
182 | } | |
183 | } | |
184 | ||
50eca3eb BM |
185 | /******************************************************************************* |
186 | * | |
0897831b | 187 | * FUNCTION: acpi_rs_set_resource_length |
50eca3eb | 188 | * |
0897831b BM |
189 | * PARAMETERS: total_length - Length of the AML descriptor, including |
190 | * the header and length fields. | |
ba494bee | 191 | * aml - Pointer to the raw AML descriptor |
50eca3eb | 192 | * |
0897831b | 193 | * RETURN: None |
50eca3eb | 194 | * |
0897831b BM |
195 | * DESCRIPTION: Set the resource_length field of an AML |
196 | * resource descriptor, both Large and Small descriptors are | |
197 | * supported automatically. Note: Descriptor Type field must | |
198 | * be valid. | |
50eca3eb BM |
199 | * |
200 | ******************************************************************************/ | |
201 | ||
0897831b BM |
202 | void |
203 | acpi_rs_set_resource_length(acpi_rsdesc_size total_length, | |
204 | union aml_resource *aml) | |
50eca3eb | 205 | { |
0897831b | 206 | acpi_rs_length resource_length; |
50eca3eb BM |
207 | |
208 | ACPI_FUNCTION_ENTRY(); | |
209 | ||
96db255c | 210 | /* Length is the total descriptor length minus the header length */ |
50eca3eb | 211 | |
96db255c BM |
212 | resource_length = (acpi_rs_length) |
213 | (total_length - acpi_ut_get_resource_header_length(aml)); | |
50eca3eb | 214 | |
96db255c | 215 | /* Length is stored differently for large and small descriptors */ |
0897831b | 216 | |
96db255c | 217 | if (aml->small_header.descriptor_type & ACPI_RESOURCE_NAME_LARGE) { |
52fc0b02 | 218 | |
96db255c | 219 | /* Large descriptor -- bytes 1-2 contain the 16-bit length */ |
50eca3eb | 220 | |
0897831b BM |
221 | ACPI_MOVE_16_TO_16(&aml->large_header.resource_length, |
222 | &resource_length); | |
50eca3eb | 223 | } else { |
1fad8738 BM |
224 | /* |
225 | * Small descriptor -- bits 2:0 of byte 0 contain the length | |
226 | * Clear any existing length, preserving descriptor type bits | |
227 | */ | |
0897831b | 228 | aml->small_header.descriptor_type = (u8) |
1fad8738 BM |
229 | ((aml->small_header.descriptor_type & |
230 | ~ACPI_RESOURCE_NAME_SMALL_LENGTH_MASK) | |
0897831b | 231 | | resource_length); |
50eca3eb | 232 | } |
50eca3eb BM |
233 | } |
234 | ||
235 | /******************************************************************************* | |
236 | * | |
237 | * FUNCTION: acpi_rs_set_resource_header | |
238 | * | |
239 | * PARAMETERS: descriptor_type - Byte to be inserted as the type | |
240 | * total_length - Length of the AML descriptor, including | |
241 | * the header and length fields. | |
ba494bee | 242 | * aml - Pointer to the raw AML descriptor |
50eca3eb BM |
243 | * |
244 | * RETURN: None | |
245 | * | |
246 | * DESCRIPTION: Set the descriptor_type and resource_length fields of an AML | |
247 | * resource descriptor, both Large and Small descriptors are | |
248 | * supported automatically | |
249 | * | |
250 | ******************************************************************************/ | |
251 | ||
252 | void | |
253 | acpi_rs_set_resource_header(u8 descriptor_type, | |
0897831b BM |
254 | acpi_rsdesc_size total_length, |
255 | union aml_resource *aml) | |
50eca3eb | 256 | { |
50eca3eb BM |
257 | ACPI_FUNCTION_ENTRY(); |
258 | ||
96db255c | 259 | /* Set the Resource Type */ |
50eca3eb BM |
260 | |
261 | aml->small_header.descriptor_type = descriptor_type; | |
262 | ||
0897831b | 263 | /* Set the Resource Length */ |
50eca3eb | 264 | |
0897831b | 265 | acpi_rs_set_resource_length(total_length, aml); |
50eca3eb BM |
266 | } |
267 | ||
268 | /******************************************************************************* | |
269 | * | |
270 | * FUNCTION: acpi_rs_strcpy | |
271 | * | |
ba494bee BM |
272 | * PARAMETERS: destination - Pointer to the destination string |
273 | * source - Pointer to the source string | |
50eca3eb BM |
274 | * |
275 | * RETURN: String length, including NULL terminator | |
276 | * | |
277 | * DESCRIPTION: Local string copy that returns the string length, saving a | |
278 | * strcpy followed by a strlen. | |
279 | * | |
280 | ******************************************************************************/ | |
281 | ||
282 | static u16 acpi_rs_strcpy(char *destination, char *source) | |
283 | { | |
284 | u16 i; | |
285 | ||
286 | ACPI_FUNCTION_ENTRY(); | |
287 | ||
288 | for (i = 0; source[i]; i++) { | |
289 | destination[i] = source[i]; | |
290 | } | |
291 | ||
292 | destination[i] = 0; | |
293 | ||
294 | /* Return string length including the NULL terminator */ | |
295 | ||
296 | return ((u16) (i + 1)); | |
297 | } | |
298 | ||
299 | /******************************************************************************* | |
300 | * | |
301 | * FUNCTION: acpi_rs_get_resource_source | |
302 | * | |
303 | * PARAMETERS: resource_length - Length field of the descriptor | |
304 | * minimum_length - Minimum length of the descriptor (minus | |
305 | * any optional fields) | |
306 | * resource_source - Where the resource_source is returned | |
ba494bee | 307 | * aml - Pointer to the raw AML descriptor |
50eca3eb BM |
308 | * string_ptr - (optional) where to store the actual |
309 | * resource_source string | |
310 | * | |
ea936b78 BM |
311 | * RETURN: Length of the string plus NULL terminator, rounded up to native |
312 | * word boundary | |
50eca3eb BM |
313 | * |
314 | * DESCRIPTION: Copy the optional resource_source data from a raw AML descriptor | |
315 | * to an internal resource descriptor | |
316 | * | |
317 | ******************************************************************************/ | |
318 | ||
0897831b BM |
319 | acpi_rs_length |
320 | acpi_rs_get_resource_source(acpi_rs_length resource_length, | |
321 | acpi_rs_length minimum_length, | |
50eca3eb BM |
322 | struct acpi_resource_source * resource_source, |
323 | union aml_resource * aml, char *string_ptr) | |
324 | { | |
0897831b | 325 | acpi_rsdesc_size total_length; |
50eca3eb BM |
326 | u8 *aml_resource_source; |
327 | ||
328 | ACPI_FUNCTION_ENTRY(); | |
329 | ||
330 | total_length = | |
331 | resource_length + sizeof(struct aml_resource_large_header); | |
c51a4de8 | 332 | aml_resource_source = ACPI_ADD_PTR(u8, aml, minimum_length); |
50eca3eb BM |
333 | |
334 | /* | |
1fad8738 BM |
335 | * resource_source is present if the length of the descriptor is longer |
336 | * than the minimum length. | |
50eca3eb BM |
337 | * |
338 | * Note: Some resource descriptors will have an additional null, so | |
339 | * we add 1 to the minimum length. | |
340 | */ | |
f5c1e1c5 | 341 | if (total_length > (acpi_rsdesc_size)(minimum_length + 1)) { |
52fc0b02 | 342 | |
50eca3eb BM |
343 | /* Get the resource_source_index */ |
344 | ||
345 | resource_source->index = aml_resource_source[0]; | |
346 | ||
347 | resource_source->string_ptr = string_ptr; | |
348 | if (!string_ptr) { | |
349 | /* | |
350 | * String destination pointer is not specified; Set the String | |
351 | * pointer to the end of the current resource_source structure. | |
352 | */ | |
c51a4de8 BM |
353 | resource_source->string_ptr = |
354 | ACPI_ADD_PTR(char, resource_source, | |
355 | sizeof(struct acpi_resource_source)); | |
50eca3eb BM |
356 | } |
357 | ||
0897831b | 358 | /* |
ea936b78 BM |
359 | * In order for the Resource length to be a multiple of the native |
360 | * word, calculate the length of the string (+1 for NULL terminator) | |
361 | * and expand to the next word multiple. | |
0897831b BM |
362 | * |
363 | * Zero the entire area of the buffer. | |
364 | */ | |
3e8214e5 | 365 | total_length = |
4fa4616e | 366 | (u32)strlen(ACPI_CAST_PTR(char, &aml_resource_source[1])) + |
3e8214e5 | 367 | 1; |
1fad8738 | 368 | |
52c1d803 | 369 | total_length = (u32)ACPI_ROUND_UP_TO_NATIVE_WORD(total_length); |
52fc0b02 | 370 | |
4fa4616e | 371 | memset(resource_source->string_ptr, 0, total_length); |
0897831b | 372 | |
50eca3eb BM |
373 | /* Copy the resource_source string to the destination */ |
374 | ||
375 | resource_source->string_length = | |
376 | acpi_rs_strcpy(resource_source->string_ptr, | |
52fc0b02 BM |
377 | ACPI_CAST_PTR(char, |
378 | &aml_resource_source[1])); | |
50eca3eb | 379 | |
f5c1e1c5 | 380 | return ((acpi_rs_length)total_length); |
50eca3eb | 381 | } |
96db255c BM |
382 | |
383 | /* resource_source is not present */ | |
384 | ||
385 | resource_source->index = 0; | |
386 | resource_source->string_length = 0; | |
387 | resource_source->string_ptr = NULL; | |
388 | return (0); | |
50eca3eb BM |
389 | } |
390 | ||
391 | /******************************************************************************* | |
392 | * | |
393 | * FUNCTION: acpi_rs_set_resource_source | |
394 | * | |
ba494bee | 395 | * PARAMETERS: aml - Pointer to the raw AML descriptor |
50eca3eb BM |
396 | * minimum_length - Minimum length of the descriptor (minus |
397 | * any optional fields) | |
398 | * resource_source - Internal resource_source | |
399 | ||
400 | * | |
401 | * RETURN: Total length of the AML descriptor | |
402 | * | |
0897831b | 403 | * DESCRIPTION: Convert an optional resource_source from internal format to a |
50eca3eb BM |
404 | * raw AML resource descriptor |
405 | * | |
406 | ******************************************************************************/ | |
407 | ||
0897831b | 408 | acpi_rsdesc_size |
f5c1e1c5 | 409 | acpi_rs_set_resource_source(union aml_resource *aml, |
0897831b | 410 | acpi_rs_length minimum_length, |
f5c1e1c5 | 411 | struct acpi_resource_source *resource_source) |
50eca3eb BM |
412 | { |
413 | u8 *aml_resource_source; | |
0897831b | 414 | acpi_rsdesc_size descriptor_length; |
50eca3eb BM |
415 | |
416 | ACPI_FUNCTION_ENTRY(); | |
417 | ||
418 | descriptor_length = minimum_length; | |
419 | ||
420 | /* Non-zero string length indicates presence of a resource_source */ | |
421 | ||
422 | if (resource_source->string_length) { | |
52fc0b02 | 423 | |
50eca3eb BM |
424 | /* Point to the end of the AML descriptor */ |
425 | ||
c51a4de8 | 426 | aml_resource_source = ACPI_ADD_PTR(u8, aml, minimum_length); |
50eca3eb BM |
427 | |
428 | /* Copy the resource_source_index */ | |
429 | ||
430 | aml_resource_source[0] = (u8) resource_source->index; | |
431 | ||
432 | /* Copy the resource_source string */ | |
433 | ||
4fa4616e BM |
434 | strcpy(ACPI_CAST_PTR(char, &aml_resource_source[1]), |
435 | resource_source->string_ptr); | |
50eca3eb BM |
436 | |
437 | /* | |
438 | * Add the length of the string (+ 1 for null terminator) to the | |
439 | * final descriptor length | |
440 | */ | |
1fad8738 BM |
441 | descriptor_length += ((acpi_rsdesc_size) |
442 | resource_source->string_length + 1); | |
50eca3eb BM |
443 | } |
444 | ||
445 | /* Return the new total length of the AML descriptor */ | |
446 | ||
447 | return (descriptor_length); | |
448 | } | |
449 | ||
1da177e4 LT |
450 | /******************************************************************************* |
451 | * | |
452 | * FUNCTION: acpi_rs_get_prt_method_data | |
453 | * | |
ba494bee | 454 | * PARAMETERS: node - Device node |
52fc0b02 BM |
455 | * ret_buffer - Pointer to a buffer structure for the |
456 | * results | |
1da177e4 LT |
457 | * |
458 | * RETURN: Status | |
459 | * | |
460 | * DESCRIPTION: This function is called to get the _PRT value of an object | |
461 | * contained in an object specified by the handle passed in | |
462 | * | |
463 | * If the function fails an appropriate status will be returned | |
464 | * and the contents of the callers buffer is undefined. | |
465 | * | |
466 | ******************************************************************************/ | |
50eca3eb | 467 | |
1da177e4 | 468 | acpi_status |
f5c1e1c5 LZ |
469 | acpi_rs_get_prt_method_data(struct acpi_namespace_node *node, |
470 | struct acpi_buffer *ret_buffer) | |
1da177e4 | 471 | { |
4be44fcd LB |
472 | union acpi_operand_object *obj_desc; |
473 | acpi_status status; | |
1da177e4 | 474 | |
b229cf92 | 475 | ACPI_FUNCTION_TRACE(rs_get_prt_method_data); |
1da177e4 LT |
476 | |
477 | /* Parameters guaranteed valid by caller */ | |
478 | ||
44f6c012 RM |
479 | /* Execute the method, no parameters */ |
480 | ||
1fad8738 BM |
481 | status = |
482 | acpi_ut_evaluate_object(node, METHOD_NAME__PRT, ACPI_BTYPE_PACKAGE, | |
483 | &obj_desc); | |
4be44fcd LB |
484 | if (ACPI_FAILURE(status)) { |
485 | return_ACPI_STATUS(status); | |
1da177e4 LT |
486 | } |
487 | ||
488 | /* | |
489 | * Create a resource linked list from the byte stream buffer that comes | |
490 | * back from the _CRS method execution. | |
491 | */ | |
4be44fcd | 492 | status = acpi_rs_create_pci_routing_table(obj_desc, ret_buffer); |
1da177e4 LT |
493 | |
494 | /* On exit, we must delete the object returned by evaluate_object */ | |
495 | ||
4be44fcd LB |
496 | acpi_ut_remove_reference(obj_desc); |
497 | return_ACPI_STATUS(status); | |
1da177e4 LT |
498 | } |
499 | ||
1da177e4 LT |
500 | /******************************************************************************* |
501 | * | |
502 | * FUNCTION: acpi_rs_get_crs_method_data | |
503 | * | |
ba494bee | 504 | * PARAMETERS: node - Device node |
52fc0b02 BM |
505 | * ret_buffer - Pointer to a buffer structure for the |
506 | * results | |
1da177e4 LT |
507 | * |
508 | * RETURN: Status | |
509 | * | |
510 | * DESCRIPTION: This function is called to get the _CRS value of an object | |
511 | * contained in an object specified by the handle passed in | |
512 | * | |
513 | * If the function fails an appropriate status will be returned | |
514 | * and the contents of the callers buffer is undefined. | |
515 | * | |
516 | ******************************************************************************/ | |
517 | ||
518 | acpi_status | |
4119532c BM |
519 | acpi_rs_get_crs_method_data(struct acpi_namespace_node *node, |
520 | struct acpi_buffer *ret_buffer) | |
1da177e4 | 521 | { |
4be44fcd LB |
522 | union acpi_operand_object *obj_desc; |
523 | acpi_status status; | |
1da177e4 | 524 | |
b229cf92 | 525 | ACPI_FUNCTION_TRACE(rs_get_crs_method_data); |
1da177e4 LT |
526 | |
527 | /* Parameters guaranteed valid by caller */ | |
528 | ||
44f6c012 RM |
529 | /* Execute the method, no parameters */ |
530 | ||
1fad8738 BM |
531 | status = |
532 | acpi_ut_evaluate_object(node, METHOD_NAME__CRS, ACPI_BTYPE_BUFFER, | |
533 | &obj_desc); | |
4be44fcd LB |
534 | if (ACPI_FAILURE(status)) { |
535 | return_ACPI_STATUS(status); | |
1da177e4 LT |
536 | } |
537 | ||
538 | /* | |
539 | * Make the call to create a resource linked list from the | |
540 | * byte stream buffer that comes back from the _CRS method | |
541 | * execution. | |
542 | */ | |
4be44fcd | 543 | status = acpi_rs_create_resource_list(obj_desc, ret_buffer); |
1da177e4 | 544 | |
ba494bee | 545 | /* On exit, we must delete the object returned by evaluateObject */ |
1da177e4 | 546 | |
4be44fcd LB |
547 | acpi_ut_remove_reference(obj_desc); |
548 | return_ACPI_STATUS(status); | |
1da177e4 LT |
549 | } |
550 | ||
1da177e4 LT |
551 | /******************************************************************************* |
552 | * | |
553 | * FUNCTION: acpi_rs_get_prs_method_data | |
554 | * | |
ba494bee | 555 | * PARAMETERS: node - Device node |
52fc0b02 BM |
556 | * ret_buffer - Pointer to a buffer structure for the |
557 | * results | |
1da177e4 LT |
558 | * |
559 | * RETURN: Status | |
560 | * | |
561 | * DESCRIPTION: This function is called to get the _PRS value of an object | |
562 | * contained in an object specified by the handle passed in | |
563 | * | |
564 | * If the function fails an appropriate status will be returned | |
565 | * and the contents of the callers buffer is undefined. | |
566 | * | |
567 | ******************************************************************************/ | |
44f6c012 | 568 | |
1da177e4 | 569 | acpi_status |
4119532c BM |
570 | acpi_rs_get_prs_method_data(struct acpi_namespace_node *node, |
571 | struct acpi_buffer *ret_buffer) | |
1da177e4 | 572 | { |
4be44fcd LB |
573 | union acpi_operand_object *obj_desc; |
574 | acpi_status status; | |
1da177e4 | 575 | |
b229cf92 | 576 | ACPI_FUNCTION_TRACE(rs_get_prs_method_data); |
1da177e4 LT |
577 | |
578 | /* Parameters guaranteed valid by caller */ | |
579 | ||
44f6c012 RM |
580 | /* Execute the method, no parameters */ |
581 | ||
1fad8738 BM |
582 | status = |
583 | acpi_ut_evaluate_object(node, METHOD_NAME__PRS, ACPI_BTYPE_BUFFER, | |
584 | &obj_desc); | |
4be44fcd LB |
585 | if (ACPI_FAILURE(status)) { |
586 | return_ACPI_STATUS(status); | |
1da177e4 LT |
587 | } |
588 | ||
589 | /* | |
590 | * Make the call to create a resource linked list from the | |
591 | * byte stream buffer that comes back from the _CRS method | |
592 | * execution. | |
593 | */ | |
4be44fcd | 594 | status = acpi_rs_create_resource_list(obj_desc, ret_buffer); |
1da177e4 | 595 | |
ba494bee | 596 | /* On exit, we must delete the object returned by evaluateObject */ |
1da177e4 | 597 | |
4be44fcd LB |
598 | acpi_ut_remove_reference(obj_desc); |
599 | return_ACPI_STATUS(status); | |
1da177e4 | 600 | } |
1da177e4 | 601 | |
a91cdde2 BM |
602 | /******************************************************************************* |
603 | * | |
604 | * FUNCTION: acpi_rs_get_aei_method_data | |
605 | * | |
ba494bee | 606 | * PARAMETERS: node - Device node |
a91cdde2 BM |
607 | * ret_buffer - Pointer to a buffer structure for the |
608 | * results | |
609 | * | |
610 | * RETURN: Status | |
611 | * | |
612 | * DESCRIPTION: This function is called to get the _AEI value of an object | |
613 | * contained in an object specified by the handle passed in | |
614 | * | |
615 | * If the function fails an appropriate status will be returned | |
616 | * and the contents of the callers buffer is undefined. | |
617 | * | |
618 | ******************************************************************************/ | |
619 | ||
620 | acpi_status | |
621 | acpi_rs_get_aei_method_data(struct acpi_namespace_node *node, | |
622 | struct acpi_buffer *ret_buffer) | |
623 | { | |
624 | union acpi_operand_object *obj_desc; | |
625 | acpi_status status; | |
626 | ||
627 | ACPI_FUNCTION_TRACE(rs_get_aei_method_data); | |
628 | ||
629 | /* Parameters guaranteed valid by caller */ | |
630 | ||
631 | /* Execute the method, no parameters */ | |
632 | ||
1fad8738 BM |
633 | status = |
634 | acpi_ut_evaluate_object(node, METHOD_NAME__AEI, ACPI_BTYPE_BUFFER, | |
635 | &obj_desc); | |
a91cdde2 BM |
636 | if (ACPI_FAILURE(status)) { |
637 | return_ACPI_STATUS(status); | |
638 | } | |
639 | ||
640 | /* | |
641 | * Make the call to create a resource linked list from the | |
642 | * byte stream buffer that comes back from the _CRS method | |
643 | * execution. | |
644 | */ | |
645 | status = acpi_rs_create_resource_list(obj_desc, ret_buffer); | |
646 | ||
ba494bee | 647 | /* On exit, we must delete the object returned by evaluateObject */ |
a91cdde2 BM |
648 | |
649 | acpi_ut_remove_reference(obj_desc); | |
650 | return_ACPI_STATUS(status); | |
651 | } | |
652 | ||
1da177e4 LT |
653 | /******************************************************************************* |
654 | * | |
655 | * FUNCTION: acpi_rs_get_method_data | |
656 | * | |
ba494bee BM |
657 | * PARAMETERS: handle - Handle to the containing object |
658 | * path - Path to method, relative to Handle | |
52fc0b02 BM |
659 | * ret_buffer - Pointer to a buffer structure for the |
660 | * results | |
1da177e4 LT |
661 | * |
662 | * RETURN: Status | |
663 | * | |
664 | * DESCRIPTION: This function is called to get the _CRS or _PRS value of an | |
665 | * object contained in an object specified by the handle passed in | |
666 | * | |
667 | * If the function fails an appropriate status will be returned | |
668 | * and the contents of the callers buffer is undefined. | |
669 | * | |
670 | ******************************************************************************/ | |
671 | ||
672 | acpi_status | |
4be44fcd | 673 | acpi_rs_get_method_data(acpi_handle handle, |
0dfaaa3d | 674 | const char *path, struct acpi_buffer *ret_buffer) |
1da177e4 | 675 | { |
4be44fcd LB |
676 | union acpi_operand_object *obj_desc; |
677 | acpi_status status; | |
1da177e4 | 678 | |
b229cf92 | 679 | ACPI_FUNCTION_TRACE(rs_get_method_data); |
1da177e4 LT |
680 | |
681 | /* Parameters guaranteed valid by caller */ | |
682 | ||
44f6c012 RM |
683 | /* Execute the method, no parameters */ |
684 | ||
4be44fcd | 685 | status = |
0fdce476 RW |
686 | acpi_ut_evaluate_object(ACPI_CAST_PTR |
687 | (struct acpi_namespace_node, handle), path, | |
688 | ACPI_BTYPE_BUFFER, &obj_desc); | |
4be44fcd LB |
689 | if (ACPI_FAILURE(status)) { |
690 | return_ACPI_STATUS(status); | |
1da177e4 LT |
691 | } |
692 | ||
693 | /* | |
694 | * Make the call to create a resource linked list from the | |
695 | * byte stream buffer that comes back from the method | |
696 | * execution. | |
697 | */ | |
4be44fcd | 698 | status = acpi_rs_create_resource_list(obj_desc, ret_buffer); |
1da177e4 LT |
699 | |
700 | /* On exit, we must delete the object returned by evaluate_object */ | |
701 | ||
4be44fcd LB |
702 | acpi_ut_remove_reference(obj_desc); |
703 | return_ACPI_STATUS(status); | |
1da177e4 LT |
704 | } |
705 | ||
706 | /******************************************************************************* | |
707 | * | |
708 | * FUNCTION: acpi_rs_set_srs_method_data | |
709 | * | |
ba494bee | 710 | * PARAMETERS: node - Device node |
52fc0b02 BM |
711 | * in_buffer - Pointer to a buffer structure of the |
712 | * parameter | |
1da177e4 LT |
713 | * |
714 | * RETURN: Status | |
715 | * | |
716 | * DESCRIPTION: This function is called to set the _SRS of an object contained | |
717 | * in an object specified by the handle passed in | |
718 | * | |
719 | * If the function fails an appropriate status will be returned | |
720 | * and the contents of the callers buffer is undefined. | |
721 | * | |
4119532c BM |
722 | * Note: Parameters guaranteed valid by caller |
723 | * | |
1da177e4 LT |
724 | ******************************************************************************/ |
725 | ||
726 | acpi_status | |
4119532c BM |
727 | acpi_rs_set_srs_method_data(struct acpi_namespace_node *node, |
728 | struct acpi_buffer *in_buffer) | |
1da177e4 | 729 | { |
4119532c BM |
730 | struct acpi_evaluate_info *info; |
731 | union acpi_operand_object *args[2]; | |
4be44fcd LB |
732 | acpi_status status; |
733 | struct acpi_buffer buffer; | |
1da177e4 | 734 | |
b229cf92 | 735 | ACPI_FUNCTION_TRACE(rs_set_srs_method_data); |
1da177e4 | 736 | |
4119532c BM |
737 | /* Allocate and initialize the evaluation information block */ |
738 | ||
739 | info = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_evaluate_info)); | |
740 | if (!info) { | |
741 | return_ACPI_STATUS(AE_NO_MEMORY); | |
742 | } | |
743 | ||
744 | info->prefix_node = node; | |
29a241cc | 745 | info->relative_pathname = METHOD_NAME__SRS; |
4119532c | 746 | info->parameters = args; |
4119532c | 747 | info->flags = ACPI_IGNORE_RETURN_VALUE; |
1da177e4 LT |
748 | |
749 | /* | |
750 | * The in_buffer parameter will point to a linked list of | |
4119532c | 751 | * resource parameters. It needs to be formatted into a |
1da177e4 LT |
752 | * byte stream to be sent in as an input parameter to _SRS |
753 | * | |
754 | * Convert the linked list into a byte stream | |
755 | */ | |
756 | buffer.length = ACPI_ALLOCATE_LOCAL_BUFFER; | |
9a0a3597 | 757 | status = acpi_rs_create_aml_resources(in_buffer, &buffer); |
4be44fcd | 758 | if (ACPI_FAILURE(status)) { |
4119532c | 759 | goto cleanup; |
1da177e4 LT |
760 | } |
761 | ||
4119532c | 762 | /* Create and initialize the method parameter object */ |
44f6c012 | 763 | |
4119532c BM |
764 | args[0] = acpi_ut_create_internal_object(ACPI_TYPE_BUFFER); |
765 | if (!args[0]) { | |
766 | /* | |
767 | * Must free the buffer allocated above (otherwise it is freed | |
768 | * later) | |
769 | */ | |
770 | ACPI_FREE(buffer.pointer); | |
771 | status = AE_NO_MEMORY; | |
772 | goto cleanup; | |
1da177e4 LT |
773 | } |
774 | ||
4119532c BM |
775 | args[0]->buffer.length = (u32) buffer.length; |
776 | args[0]->buffer.pointer = buffer.pointer; | |
777 | args[0]->common.flags = AOPOBJ_DATA_VALID; | |
778 | args[1] = NULL; | |
1da177e4 | 779 | |
4119532c | 780 | /* Execute the method, no return value is expected */ |
1da177e4 | 781 | |
4119532c | 782 | status = acpi_ns_evaluate(info); |
44f6c012 | 783 | |
4119532c | 784 | /* Clean up and return the status from acpi_ns_evaluate */ |
1da177e4 | 785 | |
4119532c | 786 | acpi_ut_remove_reference(args[0]); |
44f6c012 | 787 | |
10622bf8 | 788 | cleanup: |
4119532c | 789 | ACPI_FREE(info); |
4be44fcd | 790 | return_ACPI_STATUS(status); |
1da177e4 | 791 | } |