| blob | d7b3b418fb45739e82efdc20a6a2477270511842 |
1 /******************************************************************************
2 *
3 * Module Name: exfldio - Aml Field I/O
4 *
5 *****************************************************************************/
7 /*
8 * Copyright (C) 2000 - 2008, 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 */
44 #include <acpi/acpi.h>
51 #define _COMPONENT ACPI_EXECUTER
54 /* Local prototypes */
55 static acpi_status
57 u32 field_datum_byte_offset,
60 static u8
62 acpi_integer value);
64 static acpi_status
66 u32 field_datum_byte_offset);
68 /*******************************************************************************
69 *
70 * FUNCTION: acpi_ex_setup_region
71 *
72 * PARAMETERS: obj_desc - Field to be read or written
73 * field_datum_byte_offset - Byte offset of this datum within the
74 * parent field
75 *
76 * RETURN: Status
77 *
78 * DESCRIPTION: Common processing for acpi_ex_extract_from_field and
79 * acpi_ex_insert_into_field. Initialize the Region if necessary and
80 * validate the request.
81 *
82 ******************************************************************************/
84 static acpi_status
86 u32 field_datum_byte_offset)
87 {
95 /* We must have a valid region */
103 }
105 /*
106 * If the Region Address and Length have not been previously evaluated,
107 * evaluate them now and save the results.
108 */
113 }
114 }
116 /* Exit if Address/Length have been disallowed by the host OS */
120 }
122 /*
123 * Exit now for SMBus or IPMI address space, it has a non-linear address space
124 * and the request cannot be directly validated
125 */
129 /* SMBus or IPMI has a non-linear address space */
132 }
133 #ifdef ACPI_UNDER_DEVELOPMENT
134 /*
135 * If the Field access is any_acc, we can now compute the optimal
136 * access (because we know know the length of the parent region)
137 */
141 }
142 }
143 #endif
145 /*
146 * Validate the request. The entire request from the byte offset for a
147 * length of one field datum (access width) must fit within the region.
148 * (Region length is specified in bytes)
149 */
152 field_datum_byte_offset +
155 /*
156 * Slack mode only: We will go ahead and allow access to this
157 * field if it is within the region length rounded up to the next
158 * access width boundary. acpi_size cast for 64-bit compile.
159 */
162 access_byte_width) >=
164 base_byte_offset +
166 field_datum_byte_offset)) {
168 }
169 }
173 /*
174 * This is the case where the access_type (acc_word, etc.) is wider
175 * than the region itself. For example, a region of length one
176 * byte, and a field with Dword access specified.
177 */
184 node),
186 }
188 /*
189 * Offset rounded up to next multiple of field width
190 * exceeds region length, indicate an error
191 */
196 field_datum_byte_offset,
202 }
205 }
207 /*******************************************************************************
208 *
209 * FUNCTION: acpi_ex_access_region
210 *
211 * PARAMETERS: obj_desc - Field to be read
212 * field_datum_byte_offset - Byte offset of this datum within the
213 * parent field
214 * Value - Where to store value (must at least
215 * the size of acpi_integer)
216 * Function - Read or Write flag plus other region-
217 * dependent flags
218 *
219 * RETURN: Status
220 *
221 * DESCRIPTION: Read or Write a single field datum to an Operation Region.
222 *
223 ******************************************************************************/
225 acpi_status
227 u32 field_datum_byte_offset,
229 {
230 acpi_status status;
232 u32 region_offset;
236 /*
237 * Ensure that the region operands are fully evaluated and verify
238 * the validity of the request
239 */
243 }
245 /*
246 * The physical address of this field datum is:
247 *
248 * 1) The base of the region, plus
249 * 2) The base offset of the field, plus
250 * 3) The current offset into the field
251 */
253 region_offset =
260 }
265 space_id),
271 region.
272 address +
273 region_offset))));
275 /* Invoke the appropriate address_space/op_region handler */
277 status =
280 access_byte_width),
281 value);
288 space_id),
294 space_id),
296 }
297 }
300 }
302 /*******************************************************************************
303 *
304 * FUNCTION: acpi_ex_register_overflow
305 *
306 * PARAMETERS: obj_desc - Register(Field) to be written
307 * Value - Value to be stored
308 *
309 * RETURN: TRUE if value overflows the field, FALSE otherwise
310 *
311 * DESCRIPTION: Check if a value is out of range of the field being written.
312 * Used to check if the values written to Index and Bank registers
313 * are out of range. Normally, the value is simply truncated
314 * to fit the field, but this case is most likely a serious
315 * coding error in the ASL.
316 *
317 ******************************************************************************/
319 static u8
321 acpi_integer value)
322 {
325 /*
326 * The field is large enough to hold the maximum integer, so we can
327 * never overflow it.
328 */
330 }
333 /*
334 * The Value is larger than the maximum value that can fit into
335 * the register.
336 */
338 }
340 /* The Value will fit into the field with no truncation */
343 }
345 /*******************************************************************************
346 *
347 * FUNCTION: acpi_ex_field_datum_io
348 *
349 * PARAMETERS: obj_desc - Field to be read
350 * field_datum_byte_offset - Byte offset of this datum within the
351 * parent field
352 * Value - Where to store value (must be 64 bits)
353 * read_write - Read or Write flag
354 *
355 * RETURN: Status
356 *
357 * DESCRIPTION: Read or Write a single datum of a field. The field_type is
358 * demultiplexed here to handle the different types of fields
359 * (buffer_field, region_field, index_field, bank_field)
360 *
361 ******************************************************************************/
363 static acpi_status
365 u32 field_datum_byte_offset,
367 {
368 acpi_status status;
369 acpi_integer local_value;
377 /* To support reads without saving return value */
379 }
381 /* Clear the entire return buffer first, [Very Important!] */
384 }
386 /*
387 * The four types of fields are:
388 *
389 * buffer_field - Read/write from/to a Buffer
390 * region_field - Read/write from/to a Operation Region.
391 * bank_field - Write to a Bank Register, then read/write from/to an
392 * operation_region
393 * index_field - Write to an Index Register, then read/write from/to a
394 * Data Register
395 */
398 /*
399 * If the buffer_field arguments have not been previously evaluated,
400 * evaluate them now and save the results.
401 */
406 }
407 }
410 /*
411 * Copy the data from the source buffer.
412 * Length is the field width in bytes.
413 */
416 pointer +
418 field_datum_byte_offset,
421 /*
422 * Copy the data to the target buffer.
423 * Length is the field width in bytes.
424 */
426 pointer +
430 }
437 /*
438 * Ensure that the bank_value is not beyond the capacity of
439 * the register
440 */
445 }
447 /*
448 * For bank_fields, we must write the bank_value to the bank_register
449 * (itself a region_field) before we can access the data.
450 */
451 status =
455 value));
458 }
460 /*
461 * Now that the Bank has been selected, fall through to the
462 * region_field case and write the datum to the Operation Region
463 */
465 /*lint -fallthrough */
468 /*
469 * For simple region_fields, we just directly access the owning
470 * Operation Region.
471 */
472 status =
479 /*
480 * Ensure that the index_value is not beyond the capacity of
481 * the register
482 */
487 }
489 /* Write the index value to the index_register (itself a region_field) */
495 field_datum_byte_offset));
497 status =
503 }
507 /* Read the datum from the data_register */
512 status =
517 /* Write the datum to the data_register */
523 status =
527 }
536 }
544 access_byte_width));
550 access_byte_width));
551 }
552 }
555 }
557 /*******************************************************************************
558 *
559 * FUNCTION: acpi_ex_write_with_update_rule
560 *
561 * PARAMETERS: obj_desc - Field to be written
562 * Mask - bitmask within field datum
563 * field_value - Value to write
564 * field_datum_byte_offset - Offset of datum within field
565 *
566 * RETURN: Status
567 *
568 * DESCRIPTION: Apply the field update rule to a field write
569 *
570 ******************************************************************************/
572 acpi_status
574 acpi_integer mask,
575 acpi_integer field_value,
576 u32 field_datum_byte_offset)
577 {
579 acpi_integer merged_value;
580 acpi_integer current_value;
584 /* Start with the new bits */
588 /* If the mask is all ones, we don't need to worry about the update rule */
592 /* Decode the update rule */
597 /*
598 * Check if update rule needs to be applied (not if mask is all
599 * ones) The left shift drops the bits we want to ignore.
600 */
604 /*
605 * Read the current contents of the byte/word/dword containing
606 * the field, and merge with the new field value.
607 */
608 status =
610 field_datum_byte_offset,
612 ACPI_READ);
615 }
618 }
623 /* Set positions outside the field to all ones */
630 /* Set positions outside the field to all zeros */
640 field_flags &
641 AML_FIELD_UPDATE_RULE_MASK)));
643 }
644 }
649 field_datum_byte_offset,
654 /* Write the merged value */
660 }
662 /*******************************************************************************
663 *
664 * FUNCTION: acpi_ex_extract_from_field
665 *
666 * PARAMETERS: obj_desc - Field to be read
667 * Buffer - Where to store the field data
668 * buffer_length - Length of Buffer
669 *
670 * RETURN: Status
671 *
672 * DESCRIPTION: Retrieve the current value of the given field
673 *
674 ******************************************************************************/
676 acpi_status
679 {
680 acpi_status status;
681 acpi_integer raw_datum;
682 acpi_integer merged_datum;
685 u32 buffer_tail_bits;
686 u32 datum_count;
687 u32 field_datum_count;
688 u32 i;
692 /* Validate target buffer and clear it */
701 }
704 /* Compute the number of datums (access width data items) */
710 start_field_bit_offset,
712 access_bit_width);
714 /* Priming read from the field */
716 status =
718 ACPI_READ);
721 }
722 merged_datum =
725 /* Read the rest of the field */
729 /* Get next input datum from the field */
736 }
738 /*
739 * Merge with previous datum if necessary.
740 *
741 * Note: Before the shift, check if the shift value will be larger than
742 * the integer size. If so, there is no need to perform the operation.
743 * This avoids the differences in behavior between different compilers
744 * concerning shift values larger than the target data width.
745 */
748 ACPI_INTEGER_BIT_SIZE) {
749 merged_datum |=
751 access_bit_width -
753 start_field_bit_offset);
754 }
758 }
760 /* Write merged datum to target buffer */
767 merged_datum =
769 }
771 /* Mask off any extra bits in the last datum */
777 }
779 /* Write the last datum to the buffer */
786 }
788 /*******************************************************************************
789 *
790 * FUNCTION: acpi_ex_insert_into_field
791 *
792 * PARAMETERS: obj_desc - Field to be written
793 * Buffer - Data to be written
794 * buffer_length - Length of Buffer
795 *
796 * RETURN: Status
797 *
798 * DESCRIPTION: Store the Buffer contents into the given field
799 *
800 ******************************************************************************/
802 acpi_status
805 {
806 acpi_status status;
807 acpi_integer mask;
808 acpi_integer width_mask;
809 acpi_integer merged_datum;
813 u32 buffer_tail_bits;
814 u32 datum_count;
815 u32 field_datum_count;
816 u32 i;
817 u32 required_length;
822 /* Validate input buffer */
825 required_length =
827 /*
828 * We must have a buffer that is at least as long as the field
829 * we are writing to. This is because individual fields are
830 * indivisible and partial writes are not supported -- as per
831 * the ACPI specification.
832 */
835 /* We need to create a new buffer */
840 }
842 /*
843 * Copy the original data to the new buffer, starting
844 * at Byte zero. All unused (upper) bytes of the
845 * buffer will be 0.
846 */
850 }
852 /*
853 * Create the bitmasks used for bit insertion.
854 * Note: This if/else is used to bypass compiler differences with the
855 * shift operator
856 */
860 width_mask =
862 access_bit_width);
863 }
868 /* Compute the number of datums (access width data items) */
875 start_field_bit_offset,
877 access_bit_width);
879 /* Get initial Datum from the input buffer */
885 merged_datum =
888 /* Write the entire field */
892 /* Write merged datum to the target field */
896 merged_datum,
897 field_offset);
900 }
904 /*
905 * Start new output datum by merging with previous input datum
906 * if necessary.
907 *
908 * Note: Before the shift, check if the shift value will be larger than
909 * the integer size. If so, there is no need to perform the operation.
910 * This avoids the differences in behavior between different compilers
911 * concerning shift values larger than the target data width.
912 */
915 ACPI_INTEGER_BIT_SIZE) {
916 merged_datum =
918 access_bit_width -
920 start_field_bit_offset);
923 }
929 }
931 /* Get the next input datum from the buffer */
937 merged_datum |=
939 }
941 /* Mask off any extra bits in the last datum */
948 }
950 /* Write the last datum to the field */
955 field_offset);
957 exit:
958 /* Free temporary buffer if we used one */
962 }
964 }