| blob | 38293fd3e088bd008fd5f9855ff72b15766bdb35 |
1 /******************************************************************************
2 *
3 * Module Name: exfldio - Aml Field I/O
4 *
5 *****************************************************************************/
7 /*
8 * Copyright (C) 2000 - 2010, 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
63 static acpi_status
65 u32 field_datum_byte_offset);
67 /*******************************************************************************
68 *
69 * FUNCTION: acpi_ex_setup_region
70 *
71 * PARAMETERS: obj_desc - Field to be read or written
72 * field_datum_byte_offset - Byte offset of this datum within the
73 * parent field
74 *
75 * RETURN: Status
76 *
77 * DESCRIPTION: Common processing for acpi_ex_extract_from_field and
78 * acpi_ex_insert_into_field. Initialize the Region if necessary and
79 * validate the request.
80 *
81 ******************************************************************************/
83 static acpi_status
85 u32 field_datum_byte_offset)
86 {
94 /* We must have a valid region */
102 }
104 /*
105 * If the Region Address and Length have not been previously evaluated,
106 * evaluate them now and save the results.
107 */
112 }
113 }
115 /* Exit if Address/Length have been disallowed by the host OS */
119 }
121 /*
122 * Exit now for SMBus or IPMI address space, it has a non-linear
123 * address space and the request cannot be directly validated
124 */
128 /* SMBus or IPMI has a non-linear address space */
131 }
132 #ifdef ACPI_UNDER_DEVELOPMENT
133 /*
134 * If the Field access is any_acc, we can now compute the optimal
135 * access (because we know know the length of the parent region)
136 */
140 }
141 }
142 #endif
144 /*
145 * Validate the request. The entire request from the byte offset for a
146 * length of one field datum (access width) must fit within the region.
147 * (Region length is specified in bytes)
148 */
153 /*
154 * Slack mode only: We will go ahead and allow access to this
155 * field if it is within the region length rounded up to the next
156 * access width boundary. acpi_size cast for 64-bit compile.
157 */
160 access_byte_width) >=
162 base_byte_offset +
164 field_datum_byte_offset)) {
166 }
167 }
171 /*
172 * This is the case where the access_type (acc_word, etc.) is wider
173 * than the region itself. For example, a region of length one
174 * byte, and a field with Dword access specified.
175 */
182 node),
184 }
186 /*
187 * Offset rounded up to next multiple of field width
188 * exceeds region length, indicate an error
189 */
194 field_datum_byte_offset,
200 }
203 }
205 /*******************************************************************************
206 *
207 * FUNCTION: acpi_ex_access_region
208 *
209 * PARAMETERS: obj_desc - Field to be read
210 * field_datum_byte_offset - Byte offset of this datum within the
211 * parent field
212 * Value - Where to store value (must at least
213 * 64 bits)
214 * Function - Read or Write flag plus other region-
215 * dependent flags
216 *
217 * RETURN: Status
218 *
219 * DESCRIPTION: Read or Write a single field datum to an Operation Region.
220 *
221 ******************************************************************************/
223 acpi_status
226 {
227 acpi_status status;
229 u32 region_offset;
233 /*
234 * Ensure that the region operands are fully evaluated and verify
235 * the validity of the request
236 */
240 }
242 /*
243 * The physical address of this field datum is:
244 *
245 * 1) The base of the region, plus
246 * 2) The base offset of the field, plus
247 * 3) The current offset into the field
248 */
250 region_offset =
257 }
262 space_id),
268 region.
269 address +
270 region_offset))));
272 /* Invoke the appropriate address_space/op_region handler */
274 status =
277 access_byte_width),
278 value);
285 space_id),
291 space_id),
293 }
294 }
297 }
299 /*******************************************************************************
300 *
301 * FUNCTION: acpi_ex_register_overflow
302 *
303 * PARAMETERS: obj_desc - Register(Field) to be written
304 * Value - Value to be stored
305 *
306 * RETURN: TRUE if value overflows the field, FALSE otherwise
307 *
308 * DESCRIPTION: Check if a value is out of range of the field being written.
309 * Used to check if the values written to Index and Bank registers
310 * are out of range. Normally, the value is simply truncated
311 * to fit the field, but this case is most likely a serious
312 * coding error in the ASL.
313 *
314 ******************************************************************************/
316 static u8
318 {
321 /*
322 * The field is large enough to hold the maximum integer, so we can
323 * never overflow it.
324 */
326 }
329 /*
330 * The Value is larger than the maximum value that can fit into
331 * the register.
332 */
334 }
336 /* The Value will fit into the field with no truncation */
339 }
341 /*******************************************************************************
342 *
343 * FUNCTION: acpi_ex_field_datum_io
344 *
345 * PARAMETERS: obj_desc - Field to be read
346 * field_datum_byte_offset - Byte offset of this datum within the
347 * parent field
348 * Value - Where to store value (must be 64 bits)
349 * read_write - Read or Write flag
350 *
351 * RETURN: Status
352 *
353 * DESCRIPTION: Read or Write a single datum of a field. The field_type is
354 * demultiplexed here to handle the different types of fields
355 * (buffer_field, region_field, index_field, bank_field)
356 *
357 ******************************************************************************/
359 static acpi_status
362 {
363 acpi_status status;
364 u64 local_value;
372 /* To support reads without saving return value */
374 }
376 /* Clear the entire return buffer first, [Very Important!] */
379 }
381 /*
382 * The four types of fields are:
383 *
384 * buffer_field - Read/write from/to a Buffer
385 * region_field - Read/write from/to a Operation Region.
386 * bank_field - Write to a Bank Register, then read/write from/to an
387 * operation_region
388 * index_field - Write to an Index Register, then read/write from/to a
389 * Data Register
390 */
393 /*
394 * If the buffer_field arguments have not been previously evaluated,
395 * evaluate them now and save the results.
396 */
401 }
402 }
405 /*
406 * Copy the data from the source buffer.
407 * Length is the field width in bytes.
408 */
411 pointer +
413 field_datum_byte_offset,
416 /*
417 * Copy the data to the target buffer.
418 * Length is the field width in bytes.
419 */
421 pointer +
425 }
432 /*
433 * Ensure that the bank_value is not beyond the capacity of
434 * the register
435 */
438 value)) {
440 }
442 /*
443 * For bank_fields, we must write the bank_value to the bank_register
444 * (itself a region_field) before we can access the data.
445 */
446 status =
450 value));
453 }
455 /*
456 * Now that the Bank has been selected, fall through to the
457 * region_field case and write the datum to the Operation Region
458 */
460 /*lint -fallthrough */
463 /*
464 * For simple region_fields, we just directly access the owning
465 * Operation Region.
466 */
467 status =
474 /*
475 * Ensure that the index_value is not beyond the capacity of
476 * the register
477 */
480 value)) {
482 }
484 /* Write the index value to the index_register (itself a region_field) */
490 field_datum_byte_offset));
492 status =
498 }
502 /* Read the datum from the data_register */
507 status =
512 /* Write the datum to the data_register */
518 status =
522 }
531 }
539 access_byte_width));
545 access_byte_width));
546 }
547 }
550 }
552 /*******************************************************************************
553 *
554 * FUNCTION: acpi_ex_write_with_update_rule
555 *
556 * PARAMETERS: obj_desc - Field to be written
557 * Mask - bitmask within field datum
558 * field_value - Value to write
559 * field_datum_byte_offset - Offset of datum within field
560 *
561 * RETURN: Status
562 *
563 * DESCRIPTION: Apply the field update rule to a field write
564 *
565 ******************************************************************************/
567 acpi_status
569 u64 mask,
571 {
573 u64 merged_value;
574 u64 current_value;
578 /* Start with the new bits */
582 /* If the mask is all ones, we don't need to worry about the update rule */
586 /* Decode the update rule */
591 /*
592 * Check if update rule needs to be applied (not if mask is all
593 * ones) The left shift drops the bits we want to ignore.
594 */
598 /*
599 * Read the current contents of the byte/word/dword containing
600 * the field, and merge with the new field value.
601 */
602 status =
604 field_datum_byte_offset,
606 ACPI_READ);
609 }
612 }
617 /* Set positions outside the field to all ones */
624 /* Set positions outside the field to all zeros */
634 field_flags &
635 AML_FIELD_UPDATE_RULE_MASK)));
637 }
638 }
643 field_datum_byte_offset,
648 /* Write the merged value */
654 }
656 /*******************************************************************************
657 *
658 * FUNCTION: acpi_ex_extract_from_field
659 *
660 * PARAMETERS: obj_desc - Field to be read
661 * Buffer - Where to store the field data
662 * buffer_length - Length of Buffer
663 *
664 * RETURN: Status
665 *
666 * DESCRIPTION: Retrieve the current value of the given field
667 *
668 ******************************************************************************/
670 acpi_status
673 {
674 acpi_status status;
675 u64 raw_datum;
676 u64 merged_datum;
679 u32 buffer_tail_bits;
680 u32 datum_count;
681 u32 field_datum_count;
682 u32 access_bit_width;
683 u32 i;
687 /* Validate target buffer and clear it */
696 }
701 /* Handle the simple case here */
707 }
709 /* TBD: Move to common setup code */
711 /* Field algorithm is limited to sizeof(u64), truncate if needed */
716 }
718 /* Compute the number of datums (access width data items) */
720 datum_count =
722 access_bit_width);
726 start_field_bit_offset,
727 access_bit_width);
729 /* Priming read from the field */
731 status =
733 ACPI_READ);
736 }
737 merged_datum =
740 /* Read the rest of the field */
744 /* Get next input datum from the field */
751 }
753 /*
754 * Merge with previous datum if necessary.
755 *
756 * Note: Before the shift, check if the shift value will be larger than
757 * the integer size. If so, there is no need to perform the operation.
758 * This avoids the differences in behavior between different compilers
759 * concerning shift values larger than the target data width.
760 */
763 ACPI_INTEGER_BIT_SIZE) {
764 merged_datum |=
767 start_field_bit_offset);
768 }
772 }
774 /* Write merged datum to target buffer */
781 merged_datum =
783 }
785 /* Mask off any extra bits in the last datum */
790 }
792 /* Write the last datum to the buffer */
799 }
801 /*******************************************************************************
802 *
803 * FUNCTION: acpi_ex_insert_into_field
804 *
805 * PARAMETERS: obj_desc - Field to be written
806 * Buffer - Data to be written
807 * buffer_length - Length of Buffer
808 *
809 * RETURN: Status
810 *
811 * DESCRIPTION: Store the Buffer contents into the given field
812 *
813 ******************************************************************************/
815 acpi_status
818 {
820 acpi_status status;
821 u64 mask;
822 u64 width_mask;
823 u64 merged_datum;
827 u32 buffer_tail_bits;
828 u32 datum_count;
829 u32 field_datum_count;
830 u32 access_bit_width;
831 u32 required_length;
832 u32 i;
836 /* Validate input buffer */
839 required_length =
841 /*
842 * We must have a buffer that is at least as long as the field
843 * we are writing to. This is because individual fields are
844 * indivisible and partial writes are not supported -- as per
845 * the ACPI specification.
846 */
849 /* We need to create a new buffer */
854 }
856 /*
857 * Copy the original data to the new buffer, starting
858 * at Byte zero. All unused (upper) bytes of the
859 * buffer will be 0.
860 */
864 }
866 /* TBD: Move to common setup code */
868 /* Algo is limited to sizeof(u64), so cut the access_byte_width */
871 }
875 /*
876 * Create the bitmasks used for bit insertion.
877 * Note: This if/else is used to bypass compiler differences with the
878 * shift operator
879 */
884 }
889 /* Compute the number of datums (access width data items) */
892 access_bit_width);
896 start_field_bit_offset,
897 access_bit_width);
899 /* Get initial Datum from the input buffer */
905 merged_datum =
908 /* Write the entire field */
912 /* Write merged datum to the target field */
916 merged_datum,
917 field_offset);
920 }
924 /*
925 * Start new output datum by merging with previous input datum
926 * if necessary.
927 *
928 * Note: Before the shift, check if the shift value will be larger than
929 * the integer size. If so, there is no need to perform the operation.
930 * This avoids the differences in behavior between different compilers
931 * concerning shift values larger than the target data width.
932 */
935 ACPI_INTEGER_BIT_SIZE) {
936 merged_datum =
939 start_field_bit_offset);
942 }
948 }
950 /* Get the next input datum from the buffer */
957 merged_datum |=
959 }
961 /* Mask off any extra bits in the last datum */
965 access_bit_width;
968 }
970 /* Write the last datum to the field */
975 field_offset);
977 exit:
978 /* Free temporary buffer if we used one */
982 }
984 }