xref: /openbmc/linux/drivers/acpi/acpica/dsfield.c (revision 4800cd83)
1 /******************************************************************************
2  *
3  * Module Name: dsfield - Dispatcher field routines
4  *
5  *****************************************************************************/
6 
7 /*
8  * Copyright (C) 2000 - 2011, Intel Corp.
9  * All rights reserved.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions, and the following disclaimer,
16  *    without modification.
17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18  *    substantially similar to the "NO WARRANTY" disclaimer below
19  *    ("Disclaimer") and any redistribution must be conditioned upon
20  *    including a substantially similar Disclaimer requirement for further
21  *    binary redistribution.
22  * 3. Neither the names of the above-listed copyright holders nor the names
23  *    of any contributors may be used to endorse or promote products derived
24  *    from this software without specific prior written permission.
25  *
26  * Alternatively, this software may be distributed under the terms of the
27  * GNU General Public License ("GPL") version 2 as published by the Free
28  * Software Foundation.
29  *
30  * NO WARRANTY
31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41  * POSSIBILITY OF SUCH DAMAGES.
42  */
43 
44 #include <acpi/acpi.h>
45 #include "accommon.h"
46 #include "amlcode.h"
47 #include "acdispat.h"
48 #include "acinterp.h"
49 #include "acnamesp.h"
50 #include "acparser.h"
51 
52 #define _COMPONENT          ACPI_DISPATCHER
53 ACPI_MODULE_NAME("dsfield")
54 
55 /* Local prototypes */
56 static acpi_status
57 acpi_ds_get_field_names(struct acpi_create_field_info *info,
58 			struct acpi_walk_state *walk_state,
59 			union acpi_parse_object *arg);
60 
61 /*******************************************************************************
62  *
63  * FUNCTION:    acpi_ds_create_buffer_field
64  *
65  * PARAMETERS:  Op                  - Current parse op (create_xXField)
66  *              walk_state          - Current state
67  *
68  * RETURN:      Status
69  *
70  * DESCRIPTION: Execute the create_field operators:
71  *              create_bit_field_op,
72  *              create_byte_field_op,
73  *              create_word_field_op,
74  *              create_dword_field_op,
75  *              create_qword_field_op,
76  *              create_field_op     (all of which define a field in a buffer)
77  *
78  ******************************************************************************/
79 
80 acpi_status
81 acpi_ds_create_buffer_field(union acpi_parse_object *op,
82 			    struct acpi_walk_state *walk_state)
83 {
84 	union acpi_parse_object *arg;
85 	struct acpi_namespace_node *node;
86 	acpi_status status;
87 	union acpi_operand_object *obj_desc;
88 	union acpi_operand_object *second_desc = NULL;
89 	u32 flags;
90 
91 	ACPI_FUNCTION_TRACE(ds_create_buffer_field);
92 
93 	/*
94 	 * Get the name_string argument (name of the new buffer_field)
95 	 */
96 	if (op->common.aml_opcode == AML_CREATE_FIELD_OP) {
97 
98 		/* For create_field, name is the 4th argument */
99 
100 		arg = acpi_ps_get_arg(op, 3);
101 	} else {
102 		/* For all other create_xXXField operators, name is the 3rd argument */
103 
104 		arg = acpi_ps_get_arg(op, 2);
105 	}
106 
107 	if (!arg) {
108 		return_ACPI_STATUS(AE_AML_NO_OPERAND);
109 	}
110 
111 	if (walk_state->deferred_node) {
112 		node = walk_state->deferred_node;
113 		status = AE_OK;
114 	} else {
115 		/* Execute flag should always be set when this function is entered */
116 
117 		if (!(walk_state->parse_flags & ACPI_PARSE_EXECUTE)) {
118 			return_ACPI_STATUS(AE_AML_INTERNAL);
119 		}
120 
121 		/* Creating new namespace node, should not already exist */
122 
123 		flags = ACPI_NS_NO_UPSEARCH | ACPI_NS_DONT_OPEN_SCOPE |
124 		    ACPI_NS_ERROR_IF_FOUND;
125 
126 		/*
127 		 * Mark node temporary if we are executing a normal control
128 		 * method. (Don't mark if this is a module-level code method)
129 		 */
130 		if (walk_state->method_node &&
131 		    !(walk_state->parse_flags & ACPI_PARSE_MODULE_LEVEL)) {
132 			flags |= ACPI_NS_TEMPORARY;
133 		}
134 
135 		/* Enter the name_string into the namespace */
136 
137 		status =
138 		    acpi_ns_lookup(walk_state->scope_info,
139 				   arg->common.value.string, ACPI_TYPE_ANY,
140 				   ACPI_IMODE_LOAD_PASS1, flags, walk_state,
141 				   &node);
142 		if (ACPI_FAILURE(status)) {
143 			ACPI_ERROR_NAMESPACE(arg->common.value.string, status);
144 			return_ACPI_STATUS(status);
145 		}
146 	}
147 
148 	/*
149 	 * We could put the returned object (Node) on the object stack for later,
150 	 * but for now, we will put it in the "op" object that the parser uses,
151 	 * so we can get it again at the end of this scope.
152 	 */
153 	op->common.node = node;
154 
155 	/*
156 	 * If there is no object attached to the node, this node was just created
157 	 * and we need to create the field object. Otherwise, this was a lookup
158 	 * of an existing node and we don't want to create the field object again.
159 	 */
160 	obj_desc = acpi_ns_get_attached_object(node);
161 	if (obj_desc) {
162 		return_ACPI_STATUS(AE_OK);
163 	}
164 
165 	/*
166 	 * The Field definition is not fully parsed at this time.
167 	 * (We must save the address of the AML for the buffer and index operands)
168 	 */
169 
170 	/* Create the buffer field object */
171 
172 	obj_desc = acpi_ut_create_internal_object(ACPI_TYPE_BUFFER_FIELD);
173 	if (!obj_desc) {
174 		status = AE_NO_MEMORY;
175 		goto cleanup;
176 	}
177 
178 	/*
179 	 * Remember location in AML stream of the field unit opcode and operands --
180 	 * since the buffer and index operands must be evaluated.
181 	 */
182 	second_desc = obj_desc->common.next_object;
183 	second_desc->extra.aml_start = op->named.data;
184 	second_desc->extra.aml_length = op->named.length;
185 	obj_desc->buffer_field.node = node;
186 
187 	/* Attach constructed field descriptors to parent node */
188 
189 	status = acpi_ns_attach_object(node, obj_desc, ACPI_TYPE_BUFFER_FIELD);
190 	if (ACPI_FAILURE(status)) {
191 		goto cleanup;
192 	}
193 
194       cleanup:
195 
196 	/* Remove local reference to the object */
197 
198 	acpi_ut_remove_reference(obj_desc);
199 	return_ACPI_STATUS(status);
200 }
201 
202 /*******************************************************************************
203  *
204  * FUNCTION:    acpi_ds_get_field_names
205  *
206  * PARAMETERS:  Info            - create_field info structure
207  *  `           walk_state      - Current method state
208  *              Arg             - First parser arg for the field name list
209  *
210  * RETURN:      Status
211  *
212  * DESCRIPTION: Process all named fields in a field declaration.  Names are
213  *              entered into the namespace.
214  *
215  ******************************************************************************/
216 
217 static acpi_status
218 acpi_ds_get_field_names(struct acpi_create_field_info *info,
219 			struct acpi_walk_state *walk_state,
220 			union acpi_parse_object *arg)
221 {
222 	acpi_status status;
223 	u64 position;
224 
225 	ACPI_FUNCTION_TRACE_PTR(ds_get_field_names, info);
226 
227 	/* First field starts at bit zero */
228 
229 	info->field_bit_position = 0;
230 
231 	/* Process all elements in the field list (of parse nodes) */
232 
233 	while (arg) {
234 		/*
235 		 * Three types of field elements are handled:
236 		 * 1) Offset - specifies a bit offset
237 		 * 2) access_as - changes the access mode
238 		 * 3) Name - Enters a new named field into the namespace
239 		 */
240 		switch (arg->common.aml_opcode) {
241 		case AML_INT_RESERVEDFIELD_OP:
242 
243 			position = (u64) info->field_bit_position
244 			    + (u64) arg->common.value.size;
245 
246 			if (position > ACPI_UINT32_MAX) {
247 				ACPI_ERROR((AE_INFO,
248 					    "Bit offset within field too large (> 0xFFFFFFFF)"));
249 				return_ACPI_STATUS(AE_SUPPORT);
250 			}
251 
252 			info->field_bit_position = (u32) position;
253 			break;
254 
255 		case AML_INT_ACCESSFIELD_OP:
256 
257 			/*
258 			 * Get a new access_type and access_attribute -- to be used for all
259 			 * field units that follow, until field end or another access_as
260 			 * keyword.
261 			 *
262 			 * In field_flags, preserve the flag bits other than the
263 			 * ACCESS_TYPE bits
264 			 */
265 			info->field_flags = (u8)
266 			    ((info->
267 			      field_flags & ~(AML_FIELD_ACCESS_TYPE_MASK)) |
268 			     ((u8) ((u32) arg->common.value.integer >> 8)));
269 
270 			info->attribute = (u8) (arg->common.value.integer);
271 			break;
272 
273 		case AML_INT_NAMEDFIELD_OP:
274 
275 			/* Lookup the name, it should already exist */
276 
277 			status = acpi_ns_lookup(walk_state->scope_info,
278 						(char *)&arg->named.name,
279 						info->field_type,
280 						ACPI_IMODE_EXECUTE,
281 						ACPI_NS_DONT_OPEN_SCOPE,
282 						walk_state, &info->field_node);
283 			if (ACPI_FAILURE(status)) {
284 				ACPI_ERROR_NAMESPACE((char *)&arg->named.name,
285 						     status);
286 				return_ACPI_STATUS(status);
287 			} else {
288 				arg->common.node = info->field_node;
289 				info->field_bit_length = arg->common.value.size;
290 
291 				/*
292 				 * If there is no object attached to the node, this node was
293 				 * just created and we need to create the field object.
294 				 * Otherwise, this was a lookup of an existing node and we
295 				 * don't want to create the field object again.
296 				 */
297 				if (!acpi_ns_get_attached_object
298 				    (info->field_node)) {
299 					status = acpi_ex_prep_field_value(info);
300 					if (ACPI_FAILURE(status)) {
301 						return_ACPI_STATUS(status);
302 					}
303 				}
304 			}
305 
306 			/* Keep track of bit position for the next field */
307 
308 			position = (u64) info->field_bit_position
309 			    + (u64) arg->common.value.size;
310 
311 			if (position > ACPI_UINT32_MAX) {
312 				ACPI_ERROR((AE_INFO,
313 					    "Field [%4.4s] bit offset too large (> 0xFFFFFFFF)",
314 					    ACPI_CAST_PTR(char,
315 							  &info->field_node->
316 							  name)));
317 				return_ACPI_STATUS(AE_SUPPORT);
318 			}
319 
320 			info->field_bit_position += info->field_bit_length;
321 			break;
322 
323 		default:
324 
325 			ACPI_ERROR((AE_INFO,
326 				    "Invalid opcode in field list: 0x%X",
327 				    arg->common.aml_opcode));
328 			return_ACPI_STATUS(AE_AML_BAD_OPCODE);
329 		}
330 
331 		arg = arg->common.next;
332 	}
333 
334 	return_ACPI_STATUS(AE_OK);
335 }
336 
337 /*******************************************************************************
338  *
339  * FUNCTION:    acpi_ds_create_field
340  *
341  * PARAMETERS:  Op              - Op containing the Field definition and args
342  *              region_node     - Object for the containing Operation Region
343  *  `           walk_state      - Current method state
344  *
345  * RETURN:      Status
346  *
347  * DESCRIPTION: Create a new field in the specified operation region
348  *
349  ******************************************************************************/
350 
351 acpi_status
352 acpi_ds_create_field(union acpi_parse_object *op,
353 		     struct acpi_namespace_node *region_node,
354 		     struct acpi_walk_state *walk_state)
355 {
356 	acpi_status status;
357 	union acpi_parse_object *arg;
358 	struct acpi_create_field_info info;
359 
360 	ACPI_FUNCTION_TRACE_PTR(ds_create_field, op);
361 
362 	/* First arg is the name of the parent op_region (must already exist) */
363 
364 	arg = op->common.value.arg;
365 	if (!region_node) {
366 		status =
367 		    acpi_ns_lookup(walk_state->scope_info,
368 				   arg->common.value.name, ACPI_TYPE_REGION,
369 				   ACPI_IMODE_EXECUTE, ACPI_NS_SEARCH_PARENT,
370 				   walk_state, &region_node);
371 		if (ACPI_FAILURE(status)) {
372 			ACPI_ERROR_NAMESPACE(arg->common.value.name, status);
373 			return_ACPI_STATUS(status);
374 		}
375 	}
376 
377 	/* Second arg is the field flags */
378 
379 	arg = arg->common.next;
380 	info.field_flags = (u8) arg->common.value.integer;
381 	info.attribute = 0;
382 
383 	/* Each remaining arg is a Named Field */
384 
385 	info.field_type = ACPI_TYPE_LOCAL_REGION_FIELD;
386 	info.region_node = region_node;
387 
388 	status = acpi_ds_get_field_names(&info, walk_state, arg->common.next);
389 
390 	return_ACPI_STATUS(status);
391 }
392 
393 /*******************************************************************************
394  *
395  * FUNCTION:    acpi_ds_init_field_objects
396  *
397  * PARAMETERS:  Op              - Op containing the Field definition and args
398  *  `           walk_state      - Current method state
399  *
400  * RETURN:      Status
401  *
402  * DESCRIPTION: For each "Field Unit" name in the argument list that is
403  *              part of the field declaration, enter the name into the
404  *              namespace.
405  *
406  ******************************************************************************/
407 
408 acpi_status
409 acpi_ds_init_field_objects(union acpi_parse_object *op,
410 			   struct acpi_walk_state *walk_state)
411 {
412 	acpi_status status;
413 	union acpi_parse_object *arg = NULL;
414 	struct acpi_namespace_node *node;
415 	u8 type = 0;
416 	u32 flags;
417 
418 	ACPI_FUNCTION_TRACE_PTR(ds_init_field_objects, op);
419 
420 	/* Execute flag should always be set when this function is entered */
421 
422 	if (!(walk_state->parse_flags & ACPI_PARSE_EXECUTE)) {
423 		if (walk_state->parse_flags & ACPI_PARSE_DEFERRED_OP) {
424 
425 			/* bank_field Op is deferred, just return OK */
426 
427 			return_ACPI_STATUS(AE_OK);
428 		}
429 
430 		return_ACPI_STATUS(AE_AML_INTERNAL);
431 	}
432 
433 	/*
434 	 * Get the field_list argument for this opcode. This is the start of the
435 	 * list of field elements.
436 	 */
437 	switch (walk_state->opcode) {
438 	case AML_FIELD_OP:
439 		arg = acpi_ps_get_arg(op, 2);
440 		type = ACPI_TYPE_LOCAL_REGION_FIELD;
441 		break;
442 
443 	case AML_BANK_FIELD_OP:
444 		arg = acpi_ps_get_arg(op, 4);
445 		type = ACPI_TYPE_LOCAL_BANK_FIELD;
446 		break;
447 
448 	case AML_INDEX_FIELD_OP:
449 		arg = acpi_ps_get_arg(op, 3);
450 		type = ACPI_TYPE_LOCAL_INDEX_FIELD;
451 		break;
452 
453 	default:
454 		return_ACPI_STATUS(AE_BAD_PARAMETER);
455 	}
456 
457 	/* Creating new namespace node(s), should not already exist */
458 
459 	flags = ACPI_NS_NO_UPSEARCH | ACPI_NS_DONT_OPEN_SCOPE |
460 	    ACPI_NS_ERROR_IF_FOUND;
461 
462 	/*
463 	 * Mark node(s) temporary if we are executing a normal control
464 	 * method. (Don't mark if this is a module-level code method)
465 	 */
466 	if (walk_state->method_node &&
467 	    !(walk_state->parse_flags & ACPI_PARSE_MODULE_LEVEL)) {
468 		flags |= ACPI_NS_TEMPORARY;
469 	}
470 
471 	/*
472 	 * Walk the list of entries in the field_list
473 	 * Note: field_list can be of zero length. In this case, Arg will be NULL.
474 	 */
475 	while (arg) {
476 		/*
477 		 * Ignore OFFSET and ACCESSAS terms here; we are only interested in the
478 		 * field names in order to enter them into the namespace.
479 		 */
480 		if (arg->common.aml_opcode == AML_INT_NAMEDFIELD_OP) {
481 			status = acpi_ns_lookup(walk_state->scope_info,
482 						(char *)&arg->named.name, type,
483 						ACPI_IMODE_LOAD_PASS1, flags,
484 						walk_state, &node);
485 			if (ACPI_FAILURE(status)) {
486 				ACPI_ERROR_NAMESPACE((char *)&arg->named.name,
487 						     status);
488 				if (status != AE_ALREADY_EXISTS) {
489 					return_ACPI_STATUS(status);
490 				}
491 
492 				/* Name already exists, just ignore this error */
493 
494 				status = AE_OK;
495 			}
496 
497 			arg->common.node = node;
498 		}
499 
500 		/* Get the next field element in the list */
501 
502 		arg = arg->common.next;
503 	}
504 
505 	return_ACPI_STATUS(AE_OK);
506 }
507 
508 /*******************************************************************************
509  *
510  * FUNCTION:    acpi_ds_create_bank_field
511  *
512  * PARAMETERS:  Op              - Op containing the Field definition and args
513  *              region_node     - Object for the containing Operation Region
514  *              walk_state      - Current method state
515  *
516  * RETURN:      Status
517  *
518  * DESCRIPTION: Create a new bank field in the specified operation region
519  *
520  ******************************************************************************/
521 
522 acpi_status
523 acpi_ds_create_bank_field(union acpi_parse_object *op,
524 			  struct acpi_namespace_node *region_node,
525 			  struct acpi_walk_state *walk_state)
526 {
527 	acpi_status status;
528 	union acpi_parse_object *arg;
529 	struct acpi_create_field_info info;
530 
531 	ACPI_FUNCTION_TRACE_PTR(ds_create_bank_field, op);
532 
533 	/* First arg is the name of the parent op_region (must already exist) */
534 
535 	arg = op->common.value.arg;
536 	if (!region_node) {
537 		status =
538 		    acpi_ns_lookup(walk_state->scope_info,
539 				   arg->common.value.name, ACPI_TYPE_REGION,
540 				   ACPI_IMODE_EXECUTE, ACPI_NS_SEARCH_PARENT,
541 				   walk_state, &region_node);
542 		if (ACPI_FAILURE(status)) {
543 			ACPI_ERROR_NAMESPACE(arg->common.value.name, status);
544 			return_ACPI_STATUS(status);
545 		}
546 	}
547 
548 	/* Second arg is the Bank Register (Field) (must already exist) */
549 
550 	arg = arg->common.next;
551 	status =
552 	    acpi_ns_lookup(walk_state->scope_info, arg->common.value.string,
553 			   ACPI_TYPE_ANY, ACPI_IMODE_EXECUTE,
554 			   ACPI_NS_SEARCH_PARENT, walk_state,
555 			   &info.register_node);
556 	if (ACPI_FAILURE(status)) {
557 		ACPI_ERROR_NAMESPACE(arg->common.value.string, status);
558 		return_ACPI_STATUS(status);
559 	}
560 
561 	/*
562 	 * Third arg is the bank_value
563 	 * This arg is a term_arg, not a constant
564 	 * It will be evaluated later, by acpi_ds_eval_bank_field_operands
565 	 */
566 	arg = arg->common.next;
567 
568 	/* Fourth arg is the field flags */
569 
570 	arg = arg->common.next;
571 	info.field_flags = (u8) arg->common.value.integer;
572 
573 	/* Each remaining arg is a Named Field */
574 
575 	info.field_type = ACPI_TYPE_LOCAL_BANK_FIELD;
576 	info.region_node = region_node;
577 
578 	/*
579 	 * Use Info.data_register_node to store bank_field Op
580 	 * It's safe because data_register_node will never be used when create bank field
581 	 * We store aml_start and aml_length in the bank_field Op for late evaluation
582 	 * Used in acpi_ex_prep_field_value(Info)
583 	 *
584 	 * TBD: Or, should we add a field in struct acpi_create_field_info, like "void *ParentOp"?
585 	 */
586 	info.data_register_node = (struct acpi_namespace_node *)op;
587 
588 	status = acpi_ds_get_field_names(&info, walk_state, arg->common.next);
589 	return_ACPI_STATUS(status);
590 }
591 
592 /*******************************************************************************
593  *
594  * FUNCTION:    acpi_ds_create_index_field
595  *
596  * PARAMETERS:  Op              - Op containing the Field definition and args
597  *              region_node     - Object for the containing Operation Region
598  *  `           walk_state      - Current method state
599  *
600  * RETURN:      Status
601  *
602  * DESCRIPTION: Create a new index field in the specified operation region
603  *
604  ******************************************************************************/
605 
606 acpi_status
607 acpi_ds_create_index_field(union acpi_parse_object *op,
608 			   struct acpi_namespace_node *region_node,
609 			   struct acpi_walk_state *walk_state)
610 {
611 	acpi_status status;
612 	union acpi_parse_object *arg;
613 	struct acpi_create_field_info info;
614 
615 	ACPI_FUNCTION_TRACE_PTR(ds_create_index_field, op);
616 
617 	/* First arg is the name of the Index register (must already exist) */
618 
619 	arg = op->common.value.arg;
620 	status =
621 	    acpi_ns_lookup(walk_state->scope_info, arg->common.value.string,
622 			   ACPI_TYPE_ANY, ACPI_IMODE_EXECUTE,
623 			   ACPI_NS_SEARCH_PARENT, walk_state,
624 			   &info.register_node);
625 	if (ACPI_FAILURE(status)) {
626 		ACPI_ERROR_NAMESPACE(arg->common.value.string, status);
627 		return_ACPI_STATUS(status);
628 	}
629 
630 	/* Second arg is the data register (must already exist) */
631 
632 	arg = arg->common.next;
633 	status =
634 	    acpi_ns_lookup(walk_state->scope_info, arg->common.value.string,
635 			   ACPI_TYPE_ANY, ACPI_IMODE_EXECUTE,
636 			   ACPI_NS_SEARCH_PARENT, walk_state,
637 			   &info.data_register_node);
638 	if (ACPI_FAILURE(status)) {
639 		ACPI_ERROR_NAMESPACE(arg->common.value.string, status);
640 		return_ACPI_STATUS(status);
641 	}
642 
643 	/* Next arg is the field flags */
644 
645 	arg = arg->common.next;
646 	info.field_flags = (u8) arg->common.value.integer;
647 
648 	/* Each remaining arg is a Named Field */
649 
650 	info.field_type = ACPI_TYPE_LOCAL_INDEX_FIELD;
651 	info.region_node = region_node;
652 
653 	status = acpi_ds_get_field_names(&info, walk_state, arg->common.next);
654 
655 	return_ACPI_STATUS(status);
656 }
657