1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
2 /******************************************************************************
4 * Module Name: dsfield - Dispatcher field routines
6 * Copyright (C) 2000 - 2023, Intel Corp.
8 *****************************************************************************/
10 #include <acpi/acpi.h>
22 #define _COMPONENT ACPI_DISPATCHER
23 ACPI_MODULE_NAME("dsfield")
25 /* Local prototypes */
26 #ifdef ACPI_ASL_COMPILER
29 acpi_ds_create_external_region(acpi_status lookup_status,
30 union acpi_parse_object *op,
32 struct acpi_walk_state *walk_state,
33 struct acpi_namespace_node **node);
37 acpi_ds_get_field_names(struct acpi_create_field_info *info,
38 struct acpi_walk_state *walk_state,
39 union acpi_parse_object *arg);
41 #ifdef ACPI_ASL_COMPILER
42 /*******************************************************************************
44 * FUNCTION: acpi_ds_create_external_region (iASL Disassembler only)
46 * PARAMETERS: lookup_status - Status from ns_lookup operation
47 * op - Op containing the Field definition and args
48 * path - Pathname of the region
49 * ` walk_state - Current method state
50 * node - Where the new region node is returned
54 * DESCRIPTION: Add region to the external list if NOT_FOUND. Create a new
57 ******************************************************************************/
60 acpi_ds_create_external_region(acpi_status lookup_status,
61 union acpi_parse_object *op,
63 struct acpi_walk_state *walk_state,
64 struct acpi_namespace_node **node)
67 union acpi_operand_object *obj_desc;
69 if (lookup_status != AE_NOT_FOUND) {
70 return (lookup_status);
75 * operation_region not found. Generate an External for it, and
76 * insert the name into the namespace.
78 acpi_dm_add_op_to_external_list(op, path, ACPI_TYPE_REGION, 0, 0);
80 status = acpi_ns_lookup(walk_state->scope_info, path, ACPI_TYPE_REGION,
81 ACPI_IMODE_LOAD_PASS1, ACPI_NS_SEARCH_PARENT,
83 if (ACPI_FAILURE(status)) {
87 /* Must create and install a region object for the new node */
89 obj_desc = acpi_ut_create_internal_object(ACPI_TYPE_REGION);
91 return (AE_NO_MEMORY);
94 obj_desc->region.node = *node;
95 status = acpi_ns_attach_object(*node, obj_desc, ACPI_TYPE_REGION);
100 /*******************************************************************************
102 * FUNCTION: acpi_ds_create_buffer_field
104 * PARAMETERS: op - Current parse op (create_XXField)
105 * walk_state - Current state
109 * DESCRIPTION: Execute the create_field operators:
110 * create_bit_field_op,
111 * create_byte_field_op,
112 * create_word_field_op,
113 * create_dword_field_op,
114 * create_qword_field_op,
115 * create_field_op (all of which define a field in a buffer)
117 ******************************************************************************/
120 acpi_ds_create_buffer_field(union acpi_parse_object *op,
121 struct acpi_walk_state *walk_state)
123 union acpi_parse_object *arg;
124 struct acpi_namespace_node *node;
126 union acpi_operand_object *obj_desc;
127 union acpi_operand_object *second_desc = NULL;
130 ACPI_FUNCTION_TRACE(ds_create_buffer_field);
133 * Get the name_string argument (name of the new buffer_field)
135 if (op->common.aml_opcode == AML_CREATE_FIELD_OP) {
137 /* For create_field, name is the 4th argument */
139 arg = acpi_ps_get_arg(op, 3);
141 /* For all other create_XXXField operators, name is the 3rd argument */
143 arg = acpi_ps_get_arg(op, 2);
147 return_ACPI_STATUS(AE_AML_NO_OPERAND);
150 if (walk_state->deferred_node) {
151 node = walk_state->deferred_node;
153 /* Execute flag should always be set when this function is entered */
155 if (!(walk_state->parse_flags & ACPI_PARSE_EXECUTE)) {
156 ACPI_ERROR((AE_INFO, "Parse execute mode is not set"));
157 return_ACPI_STATUS(AE_AML_INTERNAL);
160 /* Creating new namespace node, should not already exist */
162 flags = ACPI_NS_NO_UPSEARCH | ACPI_NS_DONT_OPEN_SCOPE |
163 ACPI_NS_ERROR_IF_FOUND;
166 * Mark node temporary if we are executing a normal control
167 * method. (Don't mark if this is a module-level code method)
169 if (walk_state->method_node &&
170 !(walk_state->parse_flags & ACPI_PARSE_MODULE_LEVEL)) {
171 flags |= ACPI_NS_TEMPORARY;
174 /* Enter the name_string into the namespace */
176 status = acpi_ns_lookup(walk_state->scope_info,
177 arg->common.value.string, ACPI_TYPE_ANY,
178 ACPI_IMODE_LOAD_PASS1, flags,
180 if ((walk_state->parse_flags & ACPI_PARSE_DISASSEMBLE)
181 && status == AE_ALREADY_EXISTS) {
183 } else if (ACPI_FAILURE(status)) {
184 ACPI_ERROR_NAMESPACE(walk_state->scope_info,
185 arg->common.value.string, status);
186 return_ACPI_STATUS(status);
191 * We could put the returned object (Node) on the object stack for later,
192 * but for now, we will put it in the "op" object that the parser uses,
193 * so we can get it again at the end of this scope.
195 op->common.node = node;
198 * If there is no object attached to the node, this node was just created
199 * and we need to create the field object. Otherwise, this was a lookup
200 * of an existing node and we don't want to create the field object again.
202 obj_desc = acpi_ns_get_attached_object(node);
204 return_ACPI_STATUS(AE_OK);
208 * The Field definition is not fully parsed at this time.
209 * (We must save the address of the AML for the buffer and index operands)
212 /* Create the buffer field object */
214 obj_desc = acpi_ut_create_internal_object(ACPI_TYPE_BUFFER_FIELD);
216 status = AE_NO_MEMORY;
221 * Remember location in AML stream of the field unit opcode and operands
222 * -- since the buffer and index operands must be evaluated.
224 second_desc = obj_desc->common.next_object;
225 second_desc->extra.aml_start = op->named.data;
226 second_desc->extra.aml_length = op->named.length;
227 obj_desc->buffer_field.node = node;
229 /* Attach constructed field descriptors to parent node */
231 status = acpi_ns_attach_object(node, obj_desc, ACPI_TYPE_BUFFER_FIELD);
232 if (ACPI_FAILURE(status)) {
238 /* Remove local reference to the object */
240 acpi_ut_remove_reference(obj_desc);
241 return_ACPI_STATUS(status);
244 /*******************************************************************************
246 * FUNCTION: acpi_ds_get_field_names
248 * PARAMETERS: info - create_field info structure
249 * walk_state - Current method state
250 * arg - First parser arg for the field name list
254 * DESCRIPTION: Process all named fields in a field declaration. Names are
255 * entered into the namespace.
257 ******************************************************************************/
260 acpi_ds_get_field_names(struct acpi_create_field_info *info,
261 struct acpi_walk_state *walk_state,
262 union acpi_parse_object *arg)
266 union acpi_parse_object *child;
269 union acpi_operand_object *result_desc;
270 union acpi_operand_object *obj_desc;
274 ACPI_FUNCTION_TRACE_PTR(ds_get_field_names, info);
276 /* First field starts at bit zero */
278 info->field_bit_position = 0;
280 /* Process all elements in the field list (of parse nodes) */
284 * Four types of field elements are handled:
285 * 1) name - Enters a new named field into the namespace
286 * 2) offset - specifies a bit offset
287 * 3) access_as - changes the access mode/attributes
288 * 4) connection - Associate a resource template with the field
290 switch (arg->common.aml_opcode) {
291 case AML_INT_RESERVEDFIELD_OP:
293 position = (u64)info->field_bit_position +
294 (u64)arg->common.value.size;
296 if (position > ACPI_UINT32_MAX) {
298 "Bit offset within field too large (> 0xFFFFFFFF)"));
299 return_ACPI_STATUS(AE_SUPPORT);
302 info->field_bit_position = (u32) position;
305 case AML_INT_ACCESSFIELD_OP:
306 case AML_INT_EXTACCESSFIELD_OP:
308 * Get new access_type, access_attribute, and access_length fields
309 * -- to be used for all field units that follow, until the
310 * end-of-field or another access_as keyword is encountered.
311 * NOTE. These three bytes are encoded in the integer value
312 * of the parseop for convenience.
314 * In field_flags, preserve the flag bits other than the
318 /* access_type (byte_acc, word_acc, etc.) */
320 info->field_flags = (u8)
322 field_flags & ~(AML_FIELD_ACCESS_TYPE_MASK)) |
323 ((u8)((u32)(arg->common.value.integer & 0x07))));
325 /* access_attribute (attrib_quick, attrib_byte, etc.) */
327 info->attribute = (u8)
328 ((arg->common.value.integer >> 8) & 0xFF);
330 /* access_length (for serial/buffer protocols) */
332 info->access_length = (u8)
333 ((arg->common.value.integer >> 16) & 0xFF);
336 case AML_INT_CONNECTION_OP:
338 * Clear any previous connection. New connection is used for all
339 * fields that follow, similar to access_as
341 info->resource_buffer = NULL;
342 info->connection_node = NULL;
343 info->pin_number_index = 0;
346 * A Connection() is either an actual resource descriptor (buffer)
347 * or a named reference to a resource template
349 child = arg->common.value.arg;
350 if (child->common.aml_opcode == AML_INT_BYTELIST_OP) {
351 info->resource_buffer = child->named.data;
352 info->resource_length =
353 (u16)child->named.value.integer;
355 /* Lookup the Connection() namepath, it should already exist */
357 status = acpi_ns_lookup(walk_state->scope_info,
361 ACPI_NS_DONT_OPEN_SCOPE,
363 &info->connection_node);
364 if (ACPI_FAILURE(status)) {
365 ACPI_ERROR_NAMESPACE(walk_state->
370 return_ACPI_STATUS(status);
375 case AML_INT_NAMEDFIELD_OP:
377 /* Lookup the name, it should already exist */
379 status = acpi_ns_lookup(walk_state->scope_info,
380 (char *)&arg->named.name,
383 ACPI_NS_DONT_OPEN_SCOPE,
384 walk_state, &info->field_node);
385 if (ACPI_FAILURE(status)) {
386 ACPI_ERROR_NAMESPACE(walk_state->scope_info,
387 (char *)&arg->named.name,
389 return_ACPI_STATUS(status);
391 arg->common.node = info->field_node;
392 info->field_bit_length = arg->common.value.size;
395 * If there is no object attached to the node, this node was
396 * just created and we need to create the field object.
397 * Otherwise, this was a lookup of an existing node and we
398 * don't want to create the field object again.
400 if (!acpi_ns_get_attached_object
401 (info->field_node)) {
402 status = acpi_ex_prep_field_value(info);
403 if (ACPI_FAILURE(status)) {
404 return_ACPI_STATUS(status);
408 acpi_ns_get_external_pathname(info->
411 (ae_lookup_init_file_entry
412 (name_path, &obj_desc))) {
413 acpi_ex_write_data_to_field
415 acpi_ns_get_attached_object
418 acpi_ut_remove_reference
421 ACPI_FREE(name_path);
426 /* Keep track of bit position for the next field */
428 position = (u64)info->field_bit_position +
429 (u64)arg->common.value.size;
431 if (position > ACPI_UINT32_MAX) {
433 "Field [%4.4s] bit offset too large (> 0xFFFFFFFF)",
437 return_ACPI_STATUS(AE_SUPPORT);
440 info->field_bit_position += info->field_bit_length;
441 info->pin_number_index++; /* Index relative to previous Connection() */
447 "Invalid opcode in field list: 0x%X",
448 arg->common.aml_opcode));
449 return_ACPI_STATUS(AE_AML_BAD_OPCODE);
452 arg = arg->common.next;
455 return_ACPI_STATUS(AE_OK);
458 /*******************************************************************************
460 * FUNCTION: acpi_ds_create_field
462 * PARAMETERS: op - Op containing the Field definition and args
463 * region_node - Object for the containing Operation Region
464 * ` walk_state - Current method state
468 * DESCRIPTION: Create a new field in the specified operation region
470 ******************************************************************************/
473 acpi_ds_create_field(union acpi_parse_object *op,
474 struct acpi_namespace_node *region_node,
475 struct acpi_walk_state *walk_state)
478 union acpi_parse_object *arg;
479 struct acpi_create_field_info info;
481 ACPI_FUNCTION_TRACE_PTR(ds_create_field, op);
483 /* First arg is the name of the parent op_region (must already exist) */
485 arg = op->common.value.arg;
489 acpi_ns_lookup(walk_state->scope_info,
490 arg->common.value.name, ACPI_TYPE_REGION,
491 ACPI_IMODE_EXECUTE, ACPI_NS_SEARCH_PARENT,
492 walk_state, ®ion_node);
493 #ifdef ACPI_ASL_COMPILER
494 status = acpi_ds_create_external_region(status, arg,
495 arg->common.value.name,
499 if (ACPI_FAILURE(status)) {
500 ACPI_ERROR_NAMESPACE(walk_state->scope_info,
501 arg->common.value.name, status);
502 return_ACPI_STATUS(status);
506 memset(&info, 0, sizeof(struct acpi_create_field_info));
508 /* Second arg is the field flags */
510 arg = arg->common.next;
511 info.field_flags = (u8) arg->common.value.integer;
514 /* Each remaining arg is a Named Field */
516 info.field_type = ACPI_TYPE_LOCAL_REGION_FIELD;
517 info.region_node = region_node;
519 status = acpi_ds_get_field_names(&info, walk_state, arg->common.next);
520 if (ACPI_FAILURE(status)) {
521 return_ACPI_STATUS(status);
524 if (info.region_node->object->region.space_id ==
525 ACPI_ADR_SPACE_PLATFORM_COMM) {
526 region_node->object->field.internal_pcc_buffer =
527 ACPI_ALLOCATE_ZEROED(info.region_node->object->region.
529 if (!region_node->object->field.internal_pcc_buffer) {
530 return_ACPI_STATUS(AE_NO_MEMORY);
534 return_ACPI_STATUS(status);
537 /*******************************************************************************
539 * FUNCTION: acpi_ds_init_field_objects
541 * PARAMETERS: op - Op containing the Field definition and args
542 * ` walk_state - Current method state
546 * DESCRIPTION: For each "Field Unit" name in the argument list that is
547 * part of the field declaration, enter the name into the
550 ******************************************************************************/
553 acpi_ds_init_field_objects(union acpi_parse_object *op,
554 struct acpi_walk_state *walk_state)
557 union acpi_parse_object *arg = NULL;
558 struct acpi_namespace_node *node;
562 ACPI_FUNCTION_TRACE_PTR(ds_init_field_objects, op);
564 /* Execute flag should always be set when this function is entered */
566 if (!(walk_state->parse_flags & ACPI_PARSE_EXECUTE)) {
567 if (walk_state->parse_flags & ACPI_PARSE_DEFERRED_OP) {
569 /* bank_field Op is deferred, just return OK */
571 return_ACPI_STATUS(AE_OK);
574 ACPI_ERROR((AE_INFO, "Parse deferred mode is not set"));
575 return_ACPI_STATUS(AE_AML_INTERNAL);
579 * Get the field_list argument for this opcode. This is the start of the
580 * list of field elements.
582 switch (walk_state->opcode) {
585 arg = acpi_ps_get_arg(op, 2);
586 type = ACPI_TYPE_LOCAL_REGION_FIELD;
589 case AML_BANK_FIELD_OP:
591 arg = acpi_ps_get_arg(op, 4);
592 type = ACPI_TYPE_LOCAL_BANK_FIELD;
595 case AML_INDEX_FIELD_OP:
597 arg = acpi_ps_get_arg(op, 3);
598 type = ACPI_TYPE_LOCAL_INDEX_FIELD;
603 return_ACPI_STATUS(AE_BAD_PARAMETER);
606 /* Creating new namespace node(s), should not already exist */
608 flags = ACPI_NS_NO_UPSEARCH | ACPI_NS_DONT_OPEN_SCOPE |
609 ACPI_NS_ERROR_IF_FOUND;
612 * Mark node(s) temporary if we are executing a normal control
613 * method. (Don't mark if this is a module-level code method)
615 if (walk_state->method_node &&
616 !(walk_state->parse_flags & ACPI_PARSE_MODULE_LEVEL)) {
617 flags |= ACPI_NS_TEMPORARY;
620 flags |= ACPI_NS_OVERRIDE_IF_FOUND;
623 * Walk the list of entries in the field_list
624 * Note: field_list can be of zero length. In this case, Arg will be NULL.
628 * Ignore OFFSET/ACCESSAS/CONNECTION terms here; we are only interested
629 * in the field names in order to enter them into the namespace.
631 if (arg->common.aml_opcode == AML_INT_NAMEDFIELD_OP) {
632 status = acpi_ns_lookup(walk_state->scope_info,
633 (char *)&arg->named.name, type,
634 ACPI_IMODE_LOAD_PASS1, flags,
636 if (ACPI_FAILURE(status)) {
637 ACPI_ERROR_NAMESPACE(walk_state->scope_info,
638 (char *)&arg->named.name,
640 if (status != AE_ALREADY_EXISTS) {
641 return_ACPI_STATUS(status);
644 /* Name already exists, just ignore this error */
647 arg->common.node = node;
650 /* Get the next field element in the list */
652 arg = arg->common.next;
655 return_ACPI_STATUS(AE_OK);
658 /*******************************************************************************
660 * FUNCTION: acpi_ds_create_bank_field
662 * PARAMETERS: op - Op containing the Field definition and args
663 * region_node - Object for the containing Operation Region
664 * walk_state - Current method state
668 * DESCRIPTION: Create a new bank field in the specified operation region
670 ******************************************************************************/
673 acpi_ds_create_bank_field(union acpi_parse_object *op,
674 struct acpi_namespace_node *region_node,
675 struct acpi_walk_state *walk_state)
678 union acpi_parse_object *arg;
679 struct acpi_create_field_info info;
681 ACPI_FUNCTION_TRACE_PTR(ds_create_bank_field, op);
683 /* First arg is the name of the parent op_region (must already exist) */
685 arg = op->common.value.arg;
688 acpi_ns_lookup(walk_state->scope_info,
689 arg->common.value.name, ACPI_TYPE_REGION,
690 ACPI_IMODE_EXECUTE, ACPI_NS_SEARCH_PARENT,
691 walk_state, ®ion_node);
692 #ifdef ACPI_ASL_COMPILER
693 status = acpi_ds_create_external_region(status, arg,
694 arg->common.value.name,
698 if (ACPI_FAILURE(status)) {
699 ACPI_ERROR_NAMESPACE(walk_state->scope_info,
700 arg->common.value.name, status);
701 return_ACPI_STATUS(status);
705 /* Second arg is the Bank Register (Field) (must already exist) */
707 arg = arg->common.next;
709 acpi_ns_lookup(walk_state->scope_info, arg->common.value.string,
710 ACPI_TYPE_ANY, ACPI_IMODE_EXECUTE,
711 ACPI_NS_SEARCH_PARENT, walk_state,
712 &info.register_node);
713 if (ACPI_FAILURE(status)) {
714 ACPI_ERROR_NAMESPACE(walk_state->scope_info,
715 arg->common.value.string, status);
716 return_ACPI_STATUS(status);
720 * Third arg is the bank_value
721 * This arg is a term_arg, not a constant
722 * It will be evaluated later, by acpi_ds_eval_bank_field_operands
724 arg = arg->common.next;
726 /* Fourth arg is the field flags */
728 arg = arg->common.next;
729 info.field_flags = (u8) arg->common.value.integer;
731 /* Each remaining arg is a Named Field */
733 info.field_type = ACPI_TYPE_LOCAL_BANK_FIELD;
734 info.region_node = region_node;
737 * Use Info.data_register_node to store bank_field Op
738 * It's safe because data_register_node will never be used when create
739 * bank field \we store aml_start and aml_length in the bank_field Op for
740 * late evaluation. Used in acpi_ex_prep_field_value(Info)
742 * TBD: Or, should we add a field in struct acpi_create_field_info, like
745 info.data_register_node = (struct acpi_namespace_node *)op;
747 status = acpi_ds_get_field_names(&info, walk_state, arg->common.next);
748 return_ACPI_STATUS(status);
751 /*******************************************************************************
753 * FUNCTION: acpi_ds_create_index_field
755 * PARAMETERS: op - Op containing the Field definition and args
756 * region_node - Object for the containing Operation Region
757 * ` walk_state - Current method state
761 * DESCRIPTION: Create a new index field in the specified operation region
763 ******************************************************************************/
766 acpi_ds_create_index_field(union acpi_parse_object *op,
767 struct acpi_namespace_node *region_node,
768 struct acpi_walk_state *walk_state)
771 union acpi_parse_object *arg;
772 struct acpi_create_field_info info;
774 ACPI_FUNCTION_TRACE_PTR(ds_create_index_field, op);
776 /* First arg is the name of the Index register (must already exist) */
778 arg = op->common.value.arg;
780 acpi_ns_lookup(walk_state->scope_info, arg->common.value.string,
781 ACPI_TYPE_ANY, ACPI_IMODE_EXECUTE,
782 ACPI_NS_SEARCH_PARENT, walk_state,
783 &info.register_node);
784 if (ACPI_FAILURE(status)) {
785 ACPI_ERROR_NAMESPACE(walk_state->scope_info,
786 arg->common.value.string, status);
787 return_ACPI_STATUS(status);
790 /* Second arg is the data register (must already exist) */
792 arg = arg->common.next;
794 acpi_ns_lookup(walk_state->scope_info, arg->common.value.string,
795 ACPI_TYPE_ANY, ACPI_IMODE_EXECUTE,
796 ACPI_NS_SEARCH_PARENT, walk_state,
797 &info.data_register_node);
798 if (ACPI_FAILURE(status)) {
799 ACPI_ERROR_NAMESPACE(walk_state->scope_info,
800 arg->common.value.string, status);
801 return_ACPI_STATUS(status);
804 /* Next arg is the field flags */
806 arg = arg->common.next;
807 info.field_flags = (u8) arg->common.value.integer;
809 /* Each remaining arg is a Named Field */
811 info.field_type = ACPI_TYPE_LOCAL_INDEX_FIELD;
812 info.region_node = region_node;
814 status = acpi_ds_get_field_names(&info, walk_state, arg->common.next);
815 return_ACPI_STATUS(status);