| blob | ade35ff1c7ba5626055866a2e01ba2ae578e3ed9 |
1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
2 /******************************************************************************
3 *
4 * Module Name: exfldio - Aml Field I/O
5 *
6 * Copyright (C) 2000 - 2020, Intel Corp.
7 *
8 *****************************************************************************/
10 #include <acpi/acpi.h>
17 #define _COMPONENT ACPI_EXECUTER
20 /* Local prototypes */
21 static acpi_status
25 static u8
28 static acpi_status
30 u32 field_datum_byte_offset);
32 /*******************************************************************************
33 *
34 * FUNCTION: acpi_ex_setup_region
35 *
36 * PARAMETERS: obj_desc - Field to be read or written
37 * field_datum_byte_offset - Byte offset of this datum within the
38 * parent field
39 *
40 * RETURN: Status
41 *
42 * DESCRIPTION: Common processing for acpi_ex_extract_from_field and
43 * acpi_ex_insert_into_field. Initialize the Region if necessary and
44 * validate the request.
45 *
46 ******************************************************************************/
48 static acpi_status
50 u32 field_datum_byte_offset)
51 {
54 u8 space_id;
60 /* We must have a valid region */
68 }
72 /* Validate the Space ID */
77 space_id));
79 }
81 /*
82 * If the Region Address and Length have not been previously evaluated,
83 * evaluate them now and save the results.
84 */
89 }
90 }
92 /*
93 * Exit now for SMBus, GSBus or IPMI address space, it has a non-linear
94 * address space and the request cannot be directly validated
95 */
100 /* SMBus or IPMI has a non-linear address space */
103 }
104 #ifdef ACPI_UNDER_DEVELOPMENT
105 /*
106 * If the Field access is any_acc, we can now compute the optimal
107 * access (because we know know the length of the parent region)
108 */
112 }
113 }
114 #endif
116 /*
117 * Validate the request. The entire request from the byte offset for a
118 * length of one field datum (access width) must fit within the region.
119 * (Region length is specified in bytes)
120 */
125 /*
126 * Slack mode only: We will go ahead and allow access to this
127 * field if it is within the region length rounded up to the next
128 * access width boundary. acpi_size cast for 64-bit compile.
129 */
132 access_byte_width) >=
134 base_byte_offset +
136 field_datum_byte_offset)) {
138 }
139 }
143 /*
144 * This is the case where the access_type (acc_word, etc.) is wider
145 * than the region itself. For example, a region of length one
146 * byte, and a field with Dword access specified.
147 */
149 "Field [%4.4s] access width (%u bytes) "
155 node),
157 }
159 /*
160 * Offset rounded up to next multiple of field width
161 * exceeds region length, indicate an error
162 */
164 "Field [%4.4s] Base+Offset+Width %u+%u+%u "
168 field_datum_byte_offset,
174 }
177 }
179 /*******************************************************************************
180 *
181 * FUNCTION: acpi_ex_access_region
182 *
183 * PARAMETERS: obj_desc - Field to be read
184 * field_datum_byte_offset - Byte offset of this datum within the
185 * parent field
186 * value - Where to store value (must at least
187 * 64 bits)
188 * function - Read or Write flag plus other region-
189 * dependent flags
190 *
191 * RETURN: Status
192 *
193 * DESCRIPTION: Read or Write a single field datum to an Operation Region.
194 *
195 ******************************************************************************/
197 acpi_status
200 {
201 acpi_status status;
203 u32 region_offset;
207 /*
208 * Ensure that the region operands are fully evaluated and verify
209 * the validity of the request
210 */
214 }
216 /*
217 * The physical address of this field datum is:
218 *
219 * 1) The base of the region, plus
220 * 2) The base offset of the field, plus
221 * 3) The current offset into the field
222 */
224 region_offset =
231 }
236 space_id),
240 field_datum_byte_offset,
242 region_offset)));
244 /* Invoke the appropriate address_space/op_region handler */
249 common_field.
250 access_byte_width),
251 value);
258 space_id),
264 space_id),
266 }
267 }
270 }
272 /*******************************************************************************
273 *
274 * FUNCTION: acpi_ex_register_overflow
275 *
276 * PARAMETERS: obj_desc - Register(Field) to be written
277 * value - Value to be stored
278 *
279 * RETURN: TRUE if value overflows the field, FALSE otherwise
280 *
281 * DESCRIPTION: Check if a value is out of range of the field being written.
282 * Used to check if the values written to Index and Bank registers
283 * are out of range. Normally, the value is simply truncated
284 * to fit the field, but this case is most likely a serious
285 * coding error in the ASL.
286 *
287 ******************************************************************************/
289 static u8
291 {
294 /*
295 * The field is large enough to hold the maximum integer, so we can
296 * never overflow it.
297 */
299 }
302 /*
303 * The Value is larger than the maximum value that can fit into
304 * the register.
305 */
312 }
314 /* The Value will fit into the field with no truncation */
317 }
319 /*******************************************************************************
320 *
321 * FUNCTION: acpi_ex_field_datum_io
322 *
323 * PARAMETERS: obj_desc - Field to be read
324 * field_datum_byte_offset - Byte offset of this datum within the
325 * parent field
326 * value - Where to store value (must be 64 bits)
327 * read_write - Read or Write flag
328 *
329 * RETURN: Status
330 *
331 * DESCRIPTION: Read or Write a single datum of a field. The field_type is
332 * demultiplexed here to handle the different types of fields
333 * (buffer_field, region_field, index_field, bank_field)
334 *
335 ******************************************************************************/
337 static acpi_status
340 {
341 acpi_status status;
342 u64 local_value;
350 /* To support reads without saving return value */
352 }
354 /* Clear the entire return buffer first, [Very Important!] */
357 }
359 /*
360 * The four types of fields are:
361 *
362 * buffer_field - Read/write from/to a Buffer
363 * region_field - Read/write from/to a Operation Region.
364 * bank_field - Write to a Bank Register, then read/write from/to an
365 * operation_region
366 * index_field - Write to an Index Register, then read/write from/to a
367 * Data Register
368 */
371 /*
372 * If the buffer_field arguments have not been previously evaluated,
373 * evaluate them now and save the results.
374 */
379 }
380 }
383 /*
384 * Copy the data from the source buffer.
385 * Length is the field width in bytes.
386 */
389 pointer +
391 field_datum_byte_offset,
394 /*
395 * Copy the data to the target buffer.
396 * Length is the field width in bytes.
397 */
399 pointer +
403 }
409 /*
410 * Ensure that the bank_value is not beyond the capacity of
411 * the register
412 */
415 value)) {
417 }
419 /*
420 * For bank_fields, we must write the bank_value to the bank_register
421 * (itself a region_field) before we can access the data.
422 */
423 status =
427 value));
430 }
432 /*
433 * Now that the Bank has been selected, fall through to the
434 * region_field case and write the datum to the Operation Region
435 */
437 /*lint -fallthrough */
440 /*
441 * For simple region_fields, we just directly access the owning
442 * Operation Region.
443 */
444 status =
450 /*
451 * Ensure that the index_value is not beyond the capacity of
452 * the register
453 */
456 value)) {
458 }
460 /* Write the index value to the index_register (itself a region_field) */
466 field_datum_byte_offset));
468 status =
474 }
478 /* Read the datum from the data_register */
483 status =
488 /* Write the datum to the data_register */
494 status =
498 }
507 }
515 access_byte_width));
521 access_byte_width));
522 }
523 }
526 }
528 /*******************************************************************************
529 *
530 * FUNCTION: acpi_ex_write_with_update_rule
531 *
532 * PARAMETERS: obj_desc - Field to be written
533 * mask - bitmask within field datum
534 * field_value - Value to write
535 * field_datum_byte_offset - Offset of datum within field
536 *
537 * RETURN: Status
538 *
539 * DESCRIPTION: Apply the field update rule to a field write
540 *
541 ******************************************************************************/
543 acpi_status
545 u64 mask,
547 {
549 u64 merged_value;
550 u64 current_value;
554 /* Start with the new bits */
558 /* If the mask is all ones, we don't need to worry about the update rule */
562 /* Decode the update rule */
567 /*
568 * Check if update rule needs to be applied (not if mask is all
569 * ones) The left shift drops the bits we want to ignore.
570 */
574 /*
575 * Read the current contents of the byte/word/dword containing
576 * the field, and merge with the new field value.
577 */
578 status =
580 field_datum_byte_offset,
582 ACPI_READ);
585 }
588 }
593 /* Set positions outside the field to all ones */
600 /* Set positions outside the field to all zeros */
610 AML_FIELD_UPDATE_RULE_MASK)));
612 }
613 }
616 "Mask %8.8X%8.8X, DatumOffset %X, Width %X, "
619 field_datum_byte_offset,
624 /* Write the merged value */
626 status =
631 }
633 /*******************************************************************************
634 *
635 * FUNCTION: acpi_ex_extract_from_field
636 *
637 * PARAMETERS: obj_desc - Field to be read
638 * buffer - Where to store the field data
639 * buffer_length - Length of Buffer
640 *
641 * RETURN: Status
642 *
643 * DESCRIPTION: Retrieve the current value of the given field
644 *
645 ******************************************************************************/
647 acpi_status
650 {
651 acpi_status status;
652 u64 raw_datum;
653 u64 merged_datum;
656 u32 buffer_tail_bits;
657 u32 datum_count;
658 u32 field_datum_count;
659 u32 access_bit_width;
660 u32 i;
664 /* Validate target buffer and clear it */
673 }
678 /* Handle the simple case here */
683 status =
685 ACPI_READ);
687 /* Use raw_datum (u64) to handle buffers < 64 bits */
689 status =
691 ACPI_READ);
693 }
696 }
698 /* TBD: Move to common setup code */
700 /* Field algorithm is limited to sizeof(u64), truncate if needed */
705 }
707 /* Compute the number of datums (access width data items) */
709 datum_count =
711 access_bit_width);
715 start_field_bit_offset,
716 access_bit_width);
718 /* Priming read from the field */
720 status =
722 ACPI_READ);
725 }
726 merged_datum =
729 /* Read the rest of the field */
733 /* Get next input datum from the field */
736 status =
738 ACPI_READ);
741 }
743 /*
744 * Merge with previous datum if necessary.
745 *
746 * Note: Before the shift, check if the shift value will be larger than
747 * the integer size. If so, there is no need to perform the operation.
748 * This avoids the differences in behavior between different compilers
749 * concerning shift values larger than the target data width.
750 */
753 ACPI_INTEGER_BIT_SIZE) {
754 merged_datum |=
757 start_field_bit_offset);
758 }
762 }
764 /* Write merged datum to target buffer */
771 merged_datum =
773 }
775 /* Mask off any extra bits in the last datum */
780 }
782 /* Write the last datum to the buffer */
789 }
791 /*******************************************************************************
792 *
793 * FUNCTION: acpi_ex_insert_into_field
794 *
795 * PARAMETERS: obj_desc - Field to be written
796 * buffer - Data to be written
797 * buffer_length - Length of Buffer
798 *
799 * RETURN: Status
800 *
801 * DESCRIPTION: Store the Buffer contents into the given field
802 *
803 ******************************************************************************/
805 acpi_status
808 {
810 acpi_status status;
811 u64 mask;
812 u64 width_mask;
813 u64 merged_datum;
817 u32 buffer_tail_bits;
818 u32 datum_count;
819 u32 field_datum_count;
820 u32 access_bit_width;
821 u32 required_length;
822 u32 i;
826 /* Validate input buffer */
829 required_length =
832 /*
833 * We must have a buffer that is at least as long as the field
834 * we are writing to. This is because individual fields are
835 * indivisible and partial writes are not supported -- as per
836 * the ACPI specification.
837 */
840 /* We need to create a new buffer */
845 }
847 /*
848 * Copy the original data to the new buffer, starting
849 * at Byte zero. All unused (upper) bytes of the
850 * buffer will be 0.
851 */
855 }
857 /* TBD: Move to common setup code */
859 /* Algo is limited to sizeof(u64), so cut the access_byte_width */
862 }
866 /* Create the bitmasks used for bit insertion */
872 /* Compute the number of datums (access width data items) */
875 access_bit_width);
879 start_field_bit_offset,
880 access_bit_width);
882 /* Get initial Datum from the input buffer */
888 merged_datum =
891 /* Write the entire field */
895 /* Write merged datum to the target field */
898 status =
900 field_offset);
903 }
907 /*
908 * Start new output datum by merging with previous input datum
909 * if necessary.
910 *
911 * Note: Before the shift, check if the shift value will be larger than
912 * the integer size. If so, there is no need to perform the operation.
913 * This avoids the differences in behavior between different compilers
914 * concerning shift values larger than the target data width.
915 */
918 ACPI_INTEGER_BIT_SIZE) {
919 merged_datum =
922 start_field_bit_offset);
925 }
931 }
933 /* Get the next input datum from the buffer */
940 merged_datum |=
942 }
944 /* Mask off any extra bits in the last datum */
948 access_bit_width;
951 }
953 /* Write the last datum to the field */
956 status =
958 field_offset);
960 exit:
961 /* Free temporary buffer if we used one */
965 }
967 }