Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | |
2 | /****************************************************************************** | |
3 | * | |
4 | * Module Name: exprep - ACPI AML (p-code) execution - field prep utilities | |
5 | * | |
6 | *****************************************************************************/ | |
7 | ||
8 | /* | |
9 | * Copyright (C) 2000 - 2005, R. Byron Moore | |
10 | * All rights reserved. | |
11 | * | |
12 | * Redistribution and use in source and binary forms, with or without | |
13 | * modification, are permitted provided that the following conditions | |
14 | * are met: | |
15 | * 1. Redistributions of source code must retain the above copyright | |
16 | * notice, this list of conditions, and the following disclaimer, | |
17 | * without modification. | |
18 | * 2. Redistributions in binary form must reproduce at minimum a disclaimer | |
19 | * substantially similar to the "NO WARRANTY" disclaimer below | |
20 | * ("Disclaimer") and any redistribution must be conditioned upon | |
21 | * including a substantially similar Disclaimer requirement for further | |
22 | * binary redistribution. | |
23 | * 3. Neither the names of the above-listed copyright holders nor the names | |
24 | * of any contributors may be used to endorse or promote products derived | |
25 | * from this software without specific prior written permission. | |
26 | * | |
27 | * Alternatively, this software may be distributed under the terms of the | |
28 | * GNU General Public License ("GPL") version 2 as published by the Free | |
29 | * Software Foundation. | |
30 | * | |
31 | * NO WARRANTY | |
32 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |
33 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
34 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR | |
35 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |
36 | * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | |
37 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | |
38 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | |
39 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, | |
40 | * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING | |
41 | * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE | |
42 | * POSSIBILITY OF SUCH DAMAGES. | |
43 | */ | |
44 | ||
45 | ||
46 | #include <acpi/acpi.h> | |
47 | #include <acpi/acinterp.h> | |
48 | #include <acpi/amlcode.h> | |
49 | #include <acpi/acnamesp.h> | |
50 | ||
51 | ||
52 | #define _COMPONENT ACPI_EXECUTER | |
53 | ACPI_MODULE_NAME ("exprep") | |
54 | ||
55 | ||
56 | #ifdef ACPI_UNDER_DEVELOPMENT | |
57 | /******************************************************************************* | |
58 | * | |
59 | * FUNCTION: acpi_ex_generate_access | |
60 | * | |
61 | * PARAMETERS: field_bit_offset - Start of field within parent region/buffer | |
62 | * field_bit_length - Length of field in bits | |
63 | * region_length - Length of parent in bytes | |
64 | * | |
65 | * RETURN: Field granularity (8, 16, 32 or 64) and | |
66 | * byte_alignment (1, 2, 3, or 4) | |
67 | * | |
68 | * DESCRIPTION: Generate an optimal access width for fields defined with the | |
69 | * any_acc keyword. | |
70 | * | |
71 | * NOTE: Need to have the region_length in order to check for boundary | |
72 | * conditions (end-of-region). However, the region_length is a deferred | |
73 | * operation. Therefore, to complete this implementation, the generation | |
74 | * of this access width must be deferred until the region length has | |
75 | * been evaluated. | |
76 | * | |
77 | ******************************************************************************/ | |
78 | ||
79 | static u32 | |
80 | acpi_ex_generate_access ( | |
81 | u32 field_bit_offset, | |
82 | u32 field_bit_length, | |
83 | u32 region_length) | |
84 | { | |
85 | u32 field_byte_length; | |
86 | u32 field_byte_offset; | |
87 | u32 field_byte_end_offset; | |
88 | u32 access_byte_width; | |
89 | u32 field_start_offset; | |
90 | u32 field_end_offset; | |
91 | u32 minimum_access_width = 0xFFFFFFFF; | |
92 | u32 minimum_accesses = 0xFFFFFFFF; | |
93 | u32 accesses; | |
94 | ||
95 | ||
96 | ACPI_FUNCTION_TRACE ("ex_generate_access"); | |
97 | ||
98 | ||
99 | /* Round Field start offset and length to "minimal" byte boundaries */ | |
100 | ||
101 | field_byte_offset = ACPI_DIV_8 (ACPI_ROUND_DOWN (field_bit_offset, 8)); | |
102 | field_byte_end_offset = ACPI_DIV_8 (ACPI_ROUND_UP (field_bit_length + field_bit_offset, 8)); | |
103 | field_byte_length = field_byte_end_offset - field_byte_offset; | |
104 | ||
105 | ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, | |
106 | "Bit length %d, Bit offset %d\n", | |
107 | field_bit_length, field_bit_offset)); | |
108 | ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, | |
109 | "Byte Length %d, Byte Offset %d, End Offset %d\n", | |
110 | field_byte_length, field_byte_offset, field_byte_end_offset)); | |
111 | ||
112 | /* | |
113 | * Iterative search for the maximum access width that is both aligned | |
114 | * and does not go beyond the end of the region | |
115 | * | |
116 | * Start at byte_acc and work upwards to qword_acc max. (1,2,4,8 bytes) | |
117 | */ | |
118 | for (access_byte_width = 1; access_byte_width <= 8; access_byte_width <<= 1) { | |
119 | /* | |
120 | * 1) Round end offset up to next access boundary and make sure that this | |
121 | * does not go beyond the end of the parent region. | |
122 | * 2) When the Access width is greater than the field_byte_length, we are done. | |
123 | * (This does not optimize for the perfectly aligned case yet). | |
124 | */ | |
125 | if (ACPI_ROUND_UP (field_byte_end_offset, access_byte_width) <= region_length) { | |
126 | field_start_offset = ACPI_ROUND_DOWN (field_byte_offset, access_byte_width) / | |
127 | access_byte_width; | |
128 | field_end_offset = ACPI_ROUND_UP ((field_byte_length + field_byte_offset), | |
129 | access_byte_width) / access_byte_width; | |
130 | accesses = field_end_offset - field_start_offset; | |
131 | ||
132 | ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, | |
133 | "access_width %d end is within region\n", access_byte_width)); | |
134 | ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, | |
135 | "Field Start %d, Field End %d -- requires %d accesses\n", | |
136 | field_start_offset, field_end_offset, accesses)); | |
137 | ||
138 | /* Single access is optimal */ | |
139 | ||
140 | if (accesses <= 1) { | |
141 | ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, | |
142 | "Entire field can be accessed with one operation of size %d\n", | |
143 | access_byte_width)); | |
144 | return_VALUE (access_byte_width); | |
145 | } | |
146 | ||
147 | /* | |
148 | * Fits in the region, but requires more than one read/write. | |
149 | * try the next wider access on next iteration | |
150 | */ | |
151 | if (accesses < minimum_accesses) { | |
152 | minimum_accesses = accesses; | |
153 | minimum_access_width = access_byte_width; | |
154 | } | |
155 | } | |
156 | else { | |
157 | ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, | |
158 | "access_width %d end is NOT within region\n", access_byte_width)); | |
159 | if (access_byte_width == 1) { | |
160 | ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, | |
161 | "Field goes beyond end-of-region!\n")); | |
162 | return_VALUE (0); /* Field does not fit in the region at all */ | |
163 | } | |
164 | ||
165 | /* This width goes beyond the end-of-region, back off to previous access */ | |
166 | ||
167 | ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, | |
168 | "Backing off to previous optimal access width of %d\n", | |
169 | minimum_access_width)); | |
170 | return_VALUE (minimum_access_width); | |
171 | } | |
172 | } | |
173 | ||
174 | /* Could not read/write field with one operation, just use max access width */ | |
175 | ||
176 | ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, | |
177 | "Cannot access field in one operation, using width 8\n")); | |
178 | return_VALUE (8); | |
179 | } | |
180 | #endif /* ACPI_UNDER_DEVELOPMENT */ | |
181 | ||
182 | ||
183 | /******************************************************************************* | |
184 | * | |
185 | * FUNCTION: acpi_ex_decode_field_access | |
186 | * | |
187 | * PARAMETERS: Access - Encoded field access bits | |
188 | * Length - Field length. | |
189 | * | |
190 | * RETURN: Field granularity (8, 16, 32 or 64) and | |
191 | * byte_alignment (1, 2, 3, or 4) | |
192 | * | |
193 | * DESCRIPTION: Decode the access_type bits of a field definition. | |
194 | * | |
195 | ******************************************************************************/ | |
196 | ||
197 | static u32 | |
198 | acpi_ex_decode_field_access ( | |
199 | union acpi_operand_object *obj_desc, | |
200 | u8 field_flags, | |
201 | u32 *return_byte_alignment) | |
202 | { | |
203 | u32 access; | |
204 | u32 byte_alignment; | |
205 | u32 bit_length; | |
206 | ||
207 | ||
208 | ACPI_FUNCTION_TRACE ("ex_decode_field_access"); | |
209 | ||
210 | ||
211 | access = (field_flags & AML_FIELD_ACCESS_TYPE_MASK); | |
212 | ||
213 | switch (access) { | |
214 | case AML_FIELD_ACCESS_ANY: | |
215 | ||
216 | #ifdef ACPI_UNDER_DEVELOPMENT | |
217 | byte_alignment = acpi_ex_generate_access (obj_desc->common_field.start_field_bit_offset, | |
218 | obj_desc->common_field.bit_length, | |
219 | 0xFFFFFFFF /* Temp until we pass region_length as param */); | |
220 | bit_length = byte_alignment * 8; | |
221 | #endif | |
222 | ||
223 | byte_alignment = 1; | |
224 | bit_length = 8; | |
225 | break; | |
226 | ||
227 | case AML_FIELD_ACCESS_BYTE: | |
228 | case AML_FIELD_ACCESS_BUFFER: /* ACPI 2.0 (SMBus Buffer) */ | |
229 | byte_alignment = 1; | |
230 | bit_length = 8; | |
231 | break; | |
232 | ||
233 | case AML_FIELD_ACCESS_WORD: | |
234 | byte_alignment = 2; | |
235 | bit_length = 16; | |
236 | break; | |
237 | ||
238 | case AML_FIELD_ACCESS_DWORD: | |
239 | byte_alignment = 4; | |
240 | bit_length = 32; | |
241 | break; | |
242 | ||
243 | case AML_FIELD_ACCESS_QWORD: /* ACPI 2.0 */ | |
244 | byte_alignment = 8; | |
245 | bit_length = 64; | |
246 | break; | |
247 | ||
248 | default: | |
249 | /* Invalid field access type */ | |
250 | ||
251 | ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, | |
252 | "Unknown field access type %X\n", | |
253 | access)); | |
254 | return_VALUE (0); | |
255 | } | |
256 | ||
257 | if (ACPI_GET_OBJECT_TYPE (obj_desc) == ACPI_TYPE_BUFFER_FIELD) { | |
258 | /* | |
259 | * buffer_field access can be on any byte boundary, so the | |
260 | * byte_alignment is always 1 byte -- regardless of any byte_alignment | |
261 | * implied by the field access type. | |
262 | */ | |
263 | byte_alignment = 1; | |
264 | } | |
265 | ||
266 | *return_byte_alignment = byte_alignment; | |
267 | return_VALUE (bit_length); | |
268 | } | |
269 | ||
270 | ||
271 | /******************************************************************************* | |
272 | * | |
273 | * FUNCTION: acpi_ex_prep_common_field_object | |
274 | * | |
275 | * PARAMETERS: obj_desc - The field object | |
276 | * field_flags - Access, lock_rule, and update_rule. | |
277 | * The format of a field_flag is described | |
278 | * in the ACPI specification | |
279 | * field_bit_position - Field start position | |
280 | * field_bit_length - Field length in number of bits | |
281 | * | |
282 | * RETURN: Status | |
283 | * | |
284 | * DESCRIPTION: Initialize the areas of the field object that are common | |
285 | * to the various types of fields. Note: This is very "sensitive" | |
286 | * code because we are solving the general case for field | |
287 | * alignment. | |
288 | * | |
289 | ******************************************************************************/ | |
290 | ||
291 | acpi_status | |
292 | acpi_ex_prep_common_field_object ( | |
293 | union acpi_operand_object *obj_desc, | |
294 | u8 field_flags, | |
295 | u8 field_attribute, | |
296 | u32 field_bit_position, | |
297 | u32 field_bit_length) | |
298 | { | |
299 | u32 access_bit_width; | |
300 | u32 byte_alignment; | |
301 | u32 nearest_byte_address; | |
302 | ||
303 | ||
304 | ACPI_FUNCTION_TRACE ("ex_prep_common_field_object"); | |
305 | ||
306 | ||
307 | /* | |
308 | * Note: the structure being initialized is the | |
309 | * ACPI_COMMON_FIELD_INFO; No structure fields outside of the common | |
310 | * area are initialized by this procedure. | |
311 | */ | |
312 | obj_desc->common_field.field_flags = field_flags; | |
313 | obj_desc->common_field.attribute = field_attribute; | |
314 | obj_desc->common_field.bit_length = field_bit_length; | |
315 | ||
316 | /* | |
317 | * Decode the access type so we can compute offsets. The access type gives | |
318 | * two pieces of information - the width of each field access and the | |
319 | * necessary byte_alignment (address granularity) of the access. | |
320 | * | |
321 | * For any_acc, the access_bit_width is the largest width that is both | |
322 | * necessary and possible in an attempt to access the whole field in one | |
323 | * I/O operation. However, for any_acc, the byte_alignment is always one | |
324 | * byte. | |
325 | * | |
326 | * For all Buffer Fields, the byte_alignment is always one byte. | |
327 | * | |
328 | * For all other access types (Byte, Word, Dword, Qword), the Bitwidth is | |
329 | * the same (equivalent) as the byte_alignment. | |
330 | */ | |
331 | access_bit_width = acpi_ex_decode_field_access (obj_desc, field_flags, | |
332 | &byte_alignment); | |
333 | if (!access_bit_width) { | |
334 | return_ACPI_STATUS (AE_AML_OPERAND_VALUE); | |
335 | } | |
336 | ||
337 | /* Setup width (access granularity) fields */ | |
338 | ||
339 | obj_desc->common_field.access_byte_width = (u8) | |
340 | ACPI_DIV_8 (access_bit_width); /* 1, 2, 4, 8 */ | |
341 | ||
342 | obj_desc->common_field.access_bit_width = (u8) access_bit_width; | |
343 | ||
344 | /* | |
345 | * base_byte_offset is the address of the start of the field within the | |
346 | * region. It is the byte address of the first *datum* (field-width data | |
347 | * unit) of the field. (i.e., the first datum that contains at least the | |
348 | * first *bit* of the field.) | |
349 | * | |
350 | * Note: byte_alignment is always either equal to the access_bit_width or 8 | |
351 | * (Byte access), and it defines the addressing granularity of the parent | |
352 | * region or buffer. | |
353 | */ | |
354 | nearest_byte_address = | |
355 | ACPI_ROUND_BITS_DOWN_TO_BYTES (field_bit_position); | |
356 | obj_desc->common_field.base_byte_offset = (u32) | |
357 | ACPI_ROUND_DOWN (nearest_byte_address, byte_alignment); | |
358 | ||
359 | /* | |
360 | * start_field_bit_offset is the offset of the first bit of the field within | |
361 | * a field datum. | |
362 | */ | |
363 | obj_desc->common_field.start_field_bit_offset = (u8) | |
364 | (field_bit_position - ACPI_MUL_8 (obj_desc->common_field.base_byte_offset)); | |
365 | ||
366 | /* | |
367 | * Does the entire field fit within a single field access element? (datum) | |
368 | * (i.e., without crossing a datum boundary) | |
369 | */ | |
370 | if ((obj_desc->common_field.start_field_bit_offset + field_bit_length) <= | |
371 | (u16) access_bit_width) { | |
372 | obj_desc->common.flags |= AOPOBJ_SINGLE_DATUM; | |
373 | } | |
374 | ||
375 | return_ACPI_STATUS (AE_OK); | |
376 | } | |
377 | ||
378 | ||
379 | /******************************************************************************* | |
380 | * | |
381 | * FUNCTION: acpi_ex_prep_field_value | |
382 | * | |
383 | * PARAMETERS: Node - Owning Node | |
384 | * region_node - Region in which field is being defined | |
385 | * field_flags - Access, lock_rule, and update_rule. | |
386 | * field_bit_position - Field start position | |
387 | * field_bit_length - Field length in number of bits | |
388 | * | |
389 | * RETURN: Status | |
390 | * | |
391 | * DESCRIPTION: Construct an union acpi_operand_object of type def_field and | |
392 | * connect it to the parent Node. | |
393 | * | |
394 | ******************************************************************************/ | |
395 | ||
396 | acpi_status | |
397 | acpi_ex_prep_field_value ( | |
398 | struct acpi_create_field_info *info) | |
399 | { | |
400 | union acpi_operand_object *obj_desc; | |
401 | u32 type; | |
402 | acpi_status status; | |
403 | ||
404 | ||
405 | ACPI_FUNCTION_TRACE ("ex_prep_field_value"); | |
406 | ||
407 | ||
408 | /* Parameter validation */ | |
409 | ||
410 | if (info->field_type != ACPI_TYPE_LOCAL_INDEX_FIELD) { | |
411 | if (!info->region_node) { | |
412 | ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Null region_node\n")); | |
413 | return_ACPI_STATUS (AE_AML_NO_OPERAND); | |
414 | } | |
415 | ||
416 | type = acpi_ns_get_type (info->region_node); | |
417 | if (type != ACPI_TYPE_REGION) { | |
418 | ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, | |
419 | "Needed Region, found type %X (%s)\n", | |
420 | type, acpi_ut_get_type_name (type))); | |
421 | ||
422 | return_ACPI_STATUS (AE_AML_OPERAND_TYPE); | |
423 | } | |
424 | } | |
425 | ||
426 | /* Allocate a new field object */ | |
427 | ||
428 | obj_desc = acpi_ut_create_internal_object (info->field_type); | |
429 | if (!obj_desc) { | |
430 | return_ACPI_STATUS (AE_NO_MEMORY); | |
431 | } | |
432 | ||
433 | /* Initialize areas of the object that are common to all fields */ | |
434 | ||
435 | obj_desc->common_field.node = info->field_node; | |
436 | status = acpi_ex_prep_common_field_object (obj_desc, info->field_flags, | |
437 | info->attribute, info->field_bit_position, info->field_bit_length); | |
438 | if (ACPI_FAILURE (status)) { | |
439 | acpi_ut_delete_object_desc (obj_desc); | |
440 | return_ACPI_STATUS (status); | |
441 | } | |
442 | ||
443 | /* Initialize areas of the object that are specific to the field type */ | |
444 | ||
445 | switch (info->field_type) { | |
446 | case ACPI_TYPE_LOCAL_REGION_FIELD: | |
447 | ||
448 | obj_desc->field.region_obj = acpi_ns_get_attached_object (info->region_node); | |
449 | ||
450 | /* An additional reference for the container */ | |
451 | ||
452 | acpi_ut_add_reference (obj_desc->field.region_obj); | |
453 | ||
454 | ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, | |
455 | "region_field: bit_off %X, Off %X, Gran %X, Region %p\n", | |
456 | obj_desc->field.start_field_bit_offset, obj_desc->field.base_byte_offset, | |
457 | obj_desc->field.access_byte_width, obj_desc->field.region_obj)); | |
458 | break; | |
459 | ||
460 | ||
461 | case ACPI_TYPE_LOCAL_BANK_FIELD: | |
462 | ||
463 | obj_desc->bank_field.value = info->bank_value; | |
464 | obj_desc->bank_field.region_obj = acpi_ns_get_attached_object (info->region_node); | |
465 | obj_desc->bank_field.bank_obj = acpi_ns_get_attached_object (info->register_node); | |
466 | ||
467 | /* An additional reference for the attached objects */ | |
468 | ||
469 | acpi_ut_add_reference (obj_desc->bank_field.region_obj); | |
470 | acpi_ut_add_reference (obj_desc->bank_field.bank_obj); | |
471 | ||
472 | ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, | |
473 | "Bank Field: bit_off %X, Off %X, Gran %X, Region %p, bank_reg %p\n", | |
474 | obj_desc->bank_field.start_field_bit_offset, | |
475 | obj_desc->bank_field.base_byte_offset, | |
476 | obj_desc->field.access_byte_width, | |
477 | obj_desc->bank_field.region_obj, | |
478 | obj_desc->bank_field.bank_obj)); | |
479 | break; | |
480 | ||
481 | ||
482 | case ACPI_TYPE_LOCAL_INDEX_FIELD: | |
483 | ||
484 | obj_desc->index_field.index_obj = acpi_ns_get_attached_object (info->register_node); | |
485 | obj_desc->index_field.data_obj = acpi_ns_get_attached_object (info->data_register_node); | |
486 | obj_desc->index_field.value = (u32) | |
487 | (info->field_bit_position / ACPI_MUL_8 (obj_desc->field.access_byte_width)); | |
488 | ||
489 | if (!obj_desc->index_field.data_obj || !obj_desc->index_field.index_obj) { | |
490 | ACPI_REPORT_ERROR (("Null Index Object during field prep\n")); | |
491 | acpi_ut_delete_object_desc (obj_desc); | |
492 | return_ACPI_STATUS (AE_AML_INTERNAL); | |
493 | } | |
494 | ||
495 | /* An additional reference for the attached objects */ | |
496 | ||
497 | acpi_ut_add_reference (obj_desc->index_field.data_obj); | |
498 | acpi_ut_add_reference (obj_desc->index_field.index_obj); | |
499 | ||
500 | ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, | |
501 | "index_field: bit_off %X, Off %X, Value %X, Gran %X, Index %p, Data %p\n", | |
502 | obj_desc->index_field.start_field_bit_offset, | |
503 | obj_desc->index_field.base_byte_offset, | |
504 | obj_desc->index_field.value, | |
505 | obj_desc->field.access_byte_width, | |
506 | obj_desc->index_field.index_obj, | |
507 | obj_desc->index_field.data_obj)); | |
508 | break; | |
509 | ||
510 | default: | |
511 | /* No other types should get here */ | |
512 | break; | |
513 | } | |
514 | ||
515 | /* | |
516 | * Store the constructed descriptor (obj_desc) into the parent Node, | |
517 | * preserving the current type of that named_obj. | |
518 | */ | |
519 | status = acpi_ns_attach_object (info->field_node, obj_desc, | |
520 | acpi_ns_get_type (info->field_node)); | |
521 | ||
522 | ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, "Set named_obj %p [%4.4s], obj_desc %p\n", | |
523 | info->field_node, acpi_ut_get_node_name (info->field_node), obj_desc)); | |
524 | ||
525 | /* Remove local reference to the object */ | |
526 | ||
527 | acpi_ut_remove_reference (obj_desc); | |
528 | return_ACPI_STATUS (status); | |
529 | } | |
530 |