1 
2 /******************************************************************************
3  *
4  * Module Name: exprep - ACPI AML (p-code) execution - field prep utilities
5  *
6  *****************************************************************************/
7 
8 /*
9  * Copyright (C) 2000 - 2012, Intel Corp.
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 #include <acpi/acpi.h>
46 #include "accommon.h"
47 #include "acinterp.h"
48 #include "amlcode.h"
49 #include "acnamesp.h"
50 #include "acdispat.h"
51 
52 #define _COMPONENT          ACPI_EXECUTER
53 ACPI_MODULE_NAME("exprep")
54 
55 /* Local prototypes */
56 static u32
57 acpi_ex_decode_field_access(union acpi_operand_object *obj_desc,
58 			    u8 field_flags, u32 * return_byte_alignment);
59 
60 #ifdef ACPI_UNDER_DEVELOPMENT
61 
62 static u32
63 acpi_ex_generate_access(u32 field_bit_offset,
64 			u32 field_bit_length, u32 region_length);
65 
66 /*******************************************************************************
67  *
68  * FUNCTION:    acpi_ex_generate_access
69  *
70  * PARAMETERS:  field_bit_offset    - Start of field within parent region/buffer
71  *              field_bit_length    - Length of field in bits
72  *              region_length       - Length of parent in bytes
73  *
74  * RETURN:      Field granularity (8, 16, 32 or 64) and
75  *              byte_alignment (1, 2, 3, or 4)
76  *
77  * DESCRIPTION: Generate an optimal access width for fields defined with the
78  *              any_acc keyword.
79  *
80  * NOTE: Need to have the region_length in order to check for boundary
81  *       conditions (end-of-region).  However, the region_length is a deferred
82  *       operation.  Therefore, to complete this implementation, the generation
83  *       of this access width must be deferred until the region length has
84  *       been evaluated.
85  *
86  ******************************************************************************/
87 
88 static u32
acpi_ex_generate_access(u32 field_bit_offset,u32 field_bit_length,u32 region_length)89 acpi_ex_generate_access(u32 field_bit_offset,
90 			u32 field_bit_length, u32 region_length)
91 {
92 	u32 field_byte_length;
93 	u32 field_byte_offset;
94 	u32 field_byte_end_offset;
95 	u32 access_byte_width;
96 	u32 field_start_offset;
97 	u32 field_end_offset;
98 	u32 minimum_access_width = 0xFFFFFFFF;
99 	u32 minimum_accesses = 0xFFFFFFFF;
100 	u32 accesses;
101 
102 	ACPI_FUNCTION_TRACE(ex_generate_access);
103 
104 	/* Round Field start offset and length to "minimal" byte boundaries */
105 
106 	field_byte_offset = ACPI_DIV_8(ACPI_ROUND_DOWN(field_bit_offset, 8));
107 	field_byte_end_offset = ACPI_DIV_8(ACPI_ROUND_UP(field_bit_length +
108 							 field_bit_offset, 8));
109 	field_byte_length = field_byte_end_offset - field_byte_offset;
110 
111 	ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,
112 			  "Bit length %u, Bit offset %u\n",
113 			  field_bit_length, field_bit_offset));
114 
115 	ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,
116 			  "Byte Length %u, Byte Offset %u, End Offset %u\n",
117 			  field_byte_length, field_byte_offset,
118 			  field_byte_end_offset));
119 
120 	/*
121 	 * Iterative search for the maximum access width that is both aligned
122 	 * and does not go beyond the end of the region
123 	 *
124 	 * Start at byte_acc and work upwards to qword_acc max. (1,2,4,8 bytes)
125 	 */
126 	for (access_byte_width = 1; access_byte_width <= 8;
127 	     access_byte_width <<= 1) {
128 		/*
129 		 * 1) Round end offset up to next access boundary and make sure that
130 		 *    this does not go beyond the end of the parent region.
131 		 * 2) When the Access width is greater than the field_byte_length, we
132 		 *    are done. (This does not optimize for the perfectly aligned
133 		 *    case yet).
134 		 */
135 		if (ACPI_ROUND_UP(field_byte_end_offset, access_byte_width) <=
136 		    region_length) {
137 			field_start_offset =
138 			    ACPI_ROUND_DOWN(field_byte_offset,
139 					    access_byte_width) /
140 			    access_byte_width;
141 
142 			field_end_offset =
143 			    ACPI_ROUND_UP((field_byte_length +
144 					   field_byte_offset),
145 					  access_byte_width) /
146 			    access_byte_width;
147 
148 			accesses = field_end_offset - field_start_offset;
149 
150 			ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,
151 					  "AccessWidth %u end is within region\n",
152 					  access_byte_width));
153 
154 			ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,
155 					  "Field Start %u, Field End %u -- requires %u accesses\n",
156 					  field_start_offset, field_end_offset,
157 					  accesses));
158 
159 			/* Single access is optimal */
160 
161 			if (accesses <= 1) {
162 				ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,
163 						  "Entire field can be accessed with one operation of size %u\n",
164 						  access_byte_width));
165 				return_VALUE(access_byte_width);
166 			}
167 
168 			/*
169 			 * Fits in the region, but requires more than one read/write.
170 			 * try the next wider access on next iteration
171 			 */
172 			if (accesses < minimum_accesses) {
173 				minimum_accesses = accesses;
174 				minimum_access_width = access_byte_width;
175 			}
176 		} else {
177 			ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,
178 					  "AccessWidth %u end is NOT within region\n",
179 					  access_byte_width));
180 			if (access_byte_width == 1) {
181 				ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,
182 						  "Field goes beyond end-of-region!\n"));
183 
184 				/* Field does not fit in the region at all */
185 
186 				return_VALUE(0);
187 			}
188 
189 			/*
190 			 * This width goes beyond the end-of-region, back off to
191 			 * previous access
192 			 */
193 			ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,
194 					  "Backing off to previous optimal access width of %u\n",
195 					  minimum_access_width));
196 			return_VALUE(minimum_access_width);
197 		}
198 	}
199 
200 	/*
201 	 * Could not read/write field with one operation,
202 	 * just use max access width
203 	 */
204 	ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,
205 			  "Cannot access field in one operation, using width 8\n"));
206 	return_VALUE(8);
207 }
208 #endif				/* ACPI_UNDER_DEVELOPMENT */
209 
210 /*******************************************************************************
211  *
212  * FUNCTION:    acpi_ex_decode_field_access
213  *
214  * PARAMETERS:  obj_desc            - Field object
215  *              field_flags         - Encoded fieldflags (contains access bits)
216  *              return_byte_alignment - Where the byte alignment is returned
217  *
218  * RETURN:      Field granularity (8, 16, 32 or 64) and
219  *              byte_alignment (1, 2, 3, or 4)
220  *
221  * DESCRIPTION: Decode the access_type bits of a field definition.
222  *
223  ******************************************************************************/
224 
225 static u32
acpi_ex_decode_field_access(union acpi_operand_object * obj_desc,u8 field_flags,u32 * return_byte_alignment)226 acpi_ex_decode_field_access(union acpi_operand_object *obj_desc,
227 			    u8 field_flags, u32 * return_byte_alignment)
228 {
229 	u32 access;
230 	u32 byte_alignment;
231 	u32 bit_length;
232 
233 	ACPI_FUNCTION_TRACE(ex_decode_field_access);
234 
235 	access = (field_flags & AML_FIELD_ACCESS_TYPE_MASK);
236 
237 	switch (access) {
238 	case AML_FIELD_ACCESS_ANY:
239 
240 #ifdef ACPI_UNDER_DEVELOPMENT
241 		byte_alignment =
242 		    acpi_ex_generate_access(obj_desc->common_field.
243 					    start_field_bit_offset,
244 					    obj_desc->common_field.bit_length,
245 					    0xFFFFFFFF
246 					    /* Temp until we pass region_length as parameter */
247 		    );
248 		bit_length = byte_alignment * 8;
249 #endif
250 
251 		byte_alignment = 1;
252 		bit_length = 8;
253 		break;
254 
255 	case AML_FIELD_ACCESS_BYTE:
256 	case AML_FIELD_ACCESS_BUFFER:	/* ACPI 2.0 (SMBus Buffer) */
257 		byte_alignment = 1;
258 		bit_length = 8;
259 		break;
260 
261 	case AML_FIELD_ACCESS_WORD:
262 		byte_alignment = 2;
263 		bit_length = 16;
264 		break;
265 
266 	case AML_FIELD_ACCESS_DWORD:
267 		byte_alignment = 4;
268 		bit_length = 32;
269 		break;
270 
271 	case AML_FIELD_ACCESS_QWORD:	/* ACPI 2.0 */
272 		byte_alignment = 8;
273 		bit_length = 64;
274 		break;
275 
276 	default:
277 		/* Invalid field access type */
278 
279 		ACPI_ERROR((AE_INFO, "Unknown field access type 0x%X", access));
280 		return_UINT32(0);
281 	}
282 
283 	if (obj_desc->common.type == ACPI_TYPE_BUFFER_FIELD) {
284 		/*
285 		 * buffer_field access can be on any byte boundary, so the
286 		 * byte_alignment is always 1 byte -- regardless of any byte_alignment
287 		 * implied by the field access type.
288 		 */
289 		byte_alignment = 1;
290 	}
291 
292 	*return_byte_alignment = byte_alignment;
293 	return_UINT32(bit_length);
294 }
295 
296 /*******************************************************************************
297  *
298  * FUNCTION:    acpi_ex_prep_common_field_object
299  *
300  * PARAMETERS:  obj_desc            - The field object
301  *              field_flags         - Access, lock_rule, and update_rule.
302  *                                    The format of a field_flag is described
303  *                                    in the ACPI specification
304  *              field_attribute     - Special attributes (not used)
305  *              field_bit_position  - Field start position
306  *              field_bit_length    - Field length in number of bits
307  *
308  * RETURN:      Status
309  *
310  * DESCRIPTION: Initialize the areas of the field object that are common
311  *              to the various types of fields.  Note: This is very "sensitive"
312  *              code because we are solving the general case for field
313  *              alignment.
314  *
315  ******************************************************************************/
316 
317 acpi_status
acpi_ex_prep_common_field_object(union acpi_operand_object * obj_desc,u8 field_flags,u8 field_attribute,u32 field_bit_position,u32 field_bit_length)318 acpi_ex_prep_common_field_object(union acpi_operand_object *obj_desc,
319 				 u8 field_flags,
320 				 u8 field_attribute,
321 				 u32 field_bit_position, u32 field_bit_length)
322 {
323 	u32 access_bit_width;
324 	u32 byte_alignment;
325 	u32 nearest_byte_address;
326 
327 	ACPI_FUNCTION_TRACE(ex_prep_common_field_object);
328 
329 	/*
330 	 * Note: the structure being initialized is the
331 	 * ACPI_COMMON_FIELD_INFO;  No structure fields outside of the common
332 	 * area are initialized by this procedure.
333 	 */
334 	obj_desc->common_field.field_flags = field_flags;
335 	obj_desc->common_field.attribute = field_attribute;
336 	obj_desc->common_field.bit_length = field_bit_length;
337 
338 	/*
339 	 * Decode the access type so we can compute offsets.  The access type gives
340 	 * two pieces of information - the width of each field access and the
341 	 * necessary byte_alignment (address granularity) of the access.
342 	 *
343 	 * For any_acc, the access_bit_width is the largest width that is both
344 	 * necessary and possible in an attempt to access the whole field in one
345 	 * I/O operation.  However, for any_acc, the byte_alignment is always one
346 	 * byte.
347 	 *
348 	 * For all Buffer Fields, the byte_alignment is always one byte.
349 	 *
350 	 * For all other access types (Byte, Word, Dword, Qword), the Bitwidth is
351 	 * the same (equivalent) as the byte_alignment.
352 	 */
353 	access_bit_width = acpi_ex_decode_field_access(obj_desc, field_flags,
354 						       &byte_alignment);
355 	if (!access_bit_width) {
356 		return_ACPI_STATUS(AE_AML_OPERAND_VALUE);
357 	}
358 
359 	/* Setup width (access granularity) fields (values are: 1, 2, 4, 8) */
360 
361 	obj_desc->common_field.access_byte_width = (u8)
362 	    ACPI_DIV_8(access_bit_width);
363 
364 	/*
365 	 * base_byte_offset is the address of the start of the field within the
366 	 * region.  It is the byte address of the first *datum* (field-width data
367 	 * unit) of the field. (i.e., the first datum that contains at least the
368 	 * first *bit* of the field.)
369 	 *
370 	 * Note: byte_alignment is always either equal to the access_bit_width or 8
371 	 * (Byte access), and it defines the addressing granularity of the parent
372 	 * region or buffer.
373 	 */
374 	nearest_byte_address =
375 	    ACPI_ROUND_BITS_DOWN_TO_BYTES(field_bit_position);
376 	obj_desc->common_field.base_byte_offset = (u32)
377 	    ACPI_ROUND_DOWN(nearest_byte_address, byte_alignment);
378 
379 	/*
380 	 * start_field_bit_offset is the offset of the first bit of the field within
381 	 * a field datum.
382 	 */
383 	obj_desc->common_field.start_field_bit_offset = (u8)
384 	    (field_bit_position -
385 	     ACPI_MUL_8(obj_desc->common_field.base_byte_offset));
386 
387 	return_ACPI_STATUS(AE_OK);
388 }
389 
390 /*******************************************************************************
391  *
392  * FUNCTION:    acpi_ex_prep_field_value
393  *
394  * PARAMETERS:  Info    - Contains all field creation info
395  *
396  * RETURN:      Status
397  *
398  * DESCRIPTION: Construct a union acpi_operand_object of type def_field and
399  *              connect it to the parent Node.
400  *
401  ******************************************************************************/
402 
acpi_ex_prep_field_value(struct acpi_create_field_info * info)403 acpi_status acpi_ex_prep_field_value(struct acpi_create_field_info *info)
404 {
405 	union acpi_operand_object *obj_desc;
406 	union acpi_operand_object *second_desc = NULL;
407 	acpi_status status;
408 	u32 access_byte_width;
409 	u32 type;
410 
411 	ACPI_FUNCTION_TRACE(ex_prep_field_value);
412 
413 	/* Parameter validation */
414 
415 	if (info->field_type != ACPI_TYPE_LOCAL_INDEX_FIELD) {
416 		if (!info->region_node) {
417 			ACPI_ERROR((AE_INFO, "Null RegionNode"));
418 			return_ACPI_STATUS(AE_AML_NO_OPERAND);
419 		}
420 
421 		type = acpi_ns_get_type(info->region_node);
422 		if (type != ACPI_TYPE_REGION) {
423 			ACPI_ERROR((AE_INFO,
424 				    "Needed Region, found type 0x%X (%s)", type,
425 				    acpi_ut_get_type_name(type)));
426 
427 			return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
428 		}
429 	}
430 
431 	/* Allocate a new field object */
432 
433 	obj_desc = acpi_ut_create_internal_object(info->field_type);
434 	if (!obj_desc) {
435 		return_ACPI_STATUS(AE_NO_MEMORY);
436 	}
437 
438 	/* Initialize areas of the object that are common to all fields */
439 
440 	obj_desc->common_field.node = info->field_node;
441 	status = acpi_ex_prep_common_field_object(obj_desc,
442 						  info->field_flags,
443 						  info->attribute,
444 						  info->field_bit_position,
445 						  info->field_bit_length);
446 	if (ACPI_FAILURE(status)) {
447 		acpi_ut_delete_object_desc(obj_desc);
448 		return_ACPI_STATUS(status);
449 	}
450 
451 	/* Initialize areas of the object that are specific to the field type */
452 
453 	switch (info->field_type) {
454 	case ACPI_TYPE_LOCAL_REGION_FIELD:
455 
456 		obj_desc->field.region_obj =
457 		    acpi_ns_get_attached_object(info->region_node);
458 
459 		/* Fields specific to generic_serial_bus fields */
460 
461 		obj_desc->field.access_length = info->access_length;
462 
463 		if (info->connection_node) {
464 			second_desc = info->connection_node->object;
465 			if (!(second_desc->common.flags & AOPOBJ_DATA_VALID)) {
466 				status =
467 				    acpi_ds_get_buffer_arguments(second_desc);
468 				if (ACPI_FAILURE(status)) {
469 					acpi_ut_delete_object_desc(obj_desc);
470 					return_ACPI_STATUS(status);
471 				}
472 			}
473 
474 			obj_desc->field.resource_buffer =
475 			    second_desc->buffer.pointer;
476 			obj_desc->field.resource_length =
477 			    (u16)second_desc->buffer.length;
478 		} else if (info->resource_buffer) {
479 			obj_desc->field.resource_buffer = info->resource_buffer;
480 			obj_desc->field.resource_length = info->resource_length;
481 		}
482 
483 		/* Allow full data read from EC address space */
484 
485 		if ((obj_desc->field.region_obj->region.space_id ==
486 		     ACPI_ADR_SPACE_EC)
487 		    && (obj_desc->common_field.bit_length > 8)) {
488 			access_byte_width =
489 			    ACPI_ROUND_BITS_UP_TO_BYTES(obj_desc->common_field.
490 							bit_length);
491 
492 			/* Maximum byte width supported is 255 */
493 
494 			if (access_byte_width < 256) {
495 				obj_desc->common_field.access_byte_width =
496 				    (u8)access_byte_width;
497 			}
498 		}
499 		/* An additional reference for the container */
500 
501 		acpi_ut_add_reference(obj_desc->field.region_obj);
502 
503 		ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,
504 				  "RegionField: BitOff %X, Off %X, Gran %X, Region %p\n",
505 				  obj_desc->field.start_field_bit_offset,
506 				  obj_desc->field.base_byte_offset,
507 				  obj_desc->field.access_byte_width,
508 				  obj_desc->field.region_obj));
509 		break;
510 
511 	case ACPI_TYPE_LOCAL_BANK_FIELD:
512 
513 		obj_desc->bank_field.value = info->bank_value;
514 		obj_desc->bank_field.region_obj =
515 		    acpi_ns_get_attached_object(info->region_node);
516 		obj_desc->bank_field.bank_obj =
517 		    acpi_ns_get_attached_object(info->register_node);
518 
519 		/* An additional reference for the attached objects */
520 
521 		acpi_ut_add_reference(obj_desc->bank_field.region_obj);
522 		acpi_ut_add_reference(obj_desc->bank_field.bank_obj);
523 
524 		ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,
525 				  "Bank Field: BitOff %X, Off %X, Gran %X, Region %p, BankReg %p\n",
526 				  obj_desc->bank_field.start_field_bit_offset,
527 				  obj_desc->bank_field.base_byte_offset,
528 				  obj_desc->field.access_byte_width,
529 				  obj_desc->bank_field.region_obj,
530 				  obj_desc->bank_field.bank_obj));
531 
532 		/*
533 		 * Remember location in AML stream of the field unit
534 		 * opcode and operands -- since the bank_value
535 		 * operands must be evaluated.
536 		 */
537 		second_desc = obj_desc->common.next_object;
538 		second_desc->extra.aml_start =
539 		    ACPI_CAST_PTR(union acpi_parse_object,
540 				  info->data_register_node)->named.data;
541 		second_desc->extra.aml_length =
542 		    ACPI_CAST_PTR(union acpi_parse_object,
543 				  info->data_register_node)->named.length;
544 
545 		break;
546 
547 	case ACPI_TYPE_LOCAL_INDEX_FIELD:
548 
549 		/* Get the Index and Data registers */
550 
551 		obj_desc->index_field.index_obj =
552 		    acpi_ns_get_attached_object(info->register_node);
553 		obj_desc->index_field.data_obj =
554 		    acpi_ns_get_attached_object(info->data_register_node);
555 
556 		if (!obj_desc->index_field.data_obj
557 		    || !obj_desc->index_field.index_obj) {
558 			ACPI_ERROR((AE_INFO,
559 				    "Null Index Object during field prep"));
560 			acpi_ut_delete_object_desc(obj_desc);
561 			return_ACPI_STATUS(AE_AML_INTERNAL);
562 		}
563 
564 		/* An additional reference for the attached objects */
565 
566 		acpi_ut_add_reference(obj_desc->index_field.data_obj);
567 		acpi_ut_add_reference(obj_desc->index_field.index_obj);
568 
569 		/*
570 		 * April 2006: Changed to match MS behavior
571 		 *
572 		 * The value written to the Index register is the byte offset of the
573 		 * target field in units of the granularity of the index_field
574 		 *
575 		 * Previously, the value was calculated as an index in terms of the
576 		 * width of the Data register, as below:
577 		 *
578 		 *      obj_desc->index_field.Value = (u32)
579 		 *          (Info->field_bit_position / ACPI_MUL_8 (
580 		 *              obj_desc->Field.access_byte_width));
581 		 *
582 		 * February 2006: Tried value as a byte offset:
583 		 *      obj_desc->index_field.Value = (u32)
584 		 *          ACPI_DIV_8 (Info->field_bit_position);
585 		 */
586 		obj_desc->index_field.value =
587 		    (u32) ACPI_ROUND_DOWN(ACPI_DIV_8(info->field_bit_position),
588 					  obj_desc->index_field.
589 					  access_byte_width);
590 
591 		ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,
592 				  "IndexField: BitOff %X, Off %X, Value %X, Gran %X, Index %p, Data %p\n",
593 				  obj_desc->index_field.start_field_bit_offset,
594 				  obj_desc->index_field.base_byte_offset,
595 				  obj_desc->index_field.value,
596 				  obj_desc->field.access_byte_width,
597 				  obj_desc->index_field.index_obj,
598 				  obj_desc->index_field.data_obj));
599 		break;
600 
601 	default:
602 		/* No other types should get here */
603 		break;
604 	}
605 
606 	/*
607 	 * Store the constructed descriptor (obj_desc) into the parent Node,
608 	 * preserving the current type of that named_obj.
609 	 */
610 	status = acpi_ns_attach_object(info->field_node, obj_desc,
611 				       acpi_ns_get_type(info->field_node));
612 
613 	ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,
614 			  "Set NamedObj %p [%4.4s], ObjDesc %p\n",
615 			  info->field_node,
616 			  acpi_ut_get_node_name(info->field_node), obj_desc));
617 
618 	/* Remove local reference to the object */
619 
620 	acpi_ut_remove_reference(obj_desc);
621 	return_ACPI_STATUS(status);
622 }
623