| blob | d4075b8210217ecc5c503b54b4831aabe7ad83c2 |
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 /*
117 * Exit now for SMBus address space, it has a non-linear address space
118 * and the request cannot be directly validated
119 */
122 /* SMBus has a non-linear address space */
125 }
126 #ifdef ACPI_UNDER_DEVELOPMENT
127 /*
128 * If the Field access is any_acc, we can now compute the optimal
129 * access (because we know know the length of the parent region)
130 */
134 }
135 }
136 #endif
138 /*
139 * Validate the request. The entire request from the byte offset for a
140 * length of one field datum (access width) must fit within the region.
141 * (Region length is specified in bytes)
142 */
145 field_datum_byte_offset +
148 /*
149 * Slack mode only: We will go ahead and allow access to this
150 * field if it is within the region length rounded up to the next
151 * access width boundary. acpi_size cast for 64-bit compile.
152 */
155 access_byte_width) >=
157 base_byte_offset +
159 field_datum_byte_offset)) {
161 }
162 }
166 /*
167 * This is the case where the access_type (acc_word, etc.) is wider
168 * than the region itself. For example, a region of length one
169 * byte, and a field with Dword access specified.
170 */
177 node),
179 }
181 /*
182 * Offset rounded up to next multiple of field width
183 * exceeds region length, indicate an error
184 */
189 field_datum_byte_offset,
195 }
198 }
200 /*******************************************************************************
201 *
202 * FUNCTION: acpi_ex_access_region
203 *
204 * PARAMETERS: obj_desc - Field to be read
205 * field_datum_byte_offset - Byte offset of this datum within the
206 * parent field
207 * Value - Where to store value (must at least
208 * the size of acpi_integer)
209 * Function - Read or Write flag plus other region-
210 * dependent flags
211 *
212 * RETURN: Status
213 *
214 * DESCRIPTION: Read or Write a single field datum to an Operation Region.
215 *
216 ******************************************************************************/
218 acpi_status
220 u32 field_datum_byte_offset,
222 {
223 acpi_status status;
225 u32 region_offset;
229 /*
230 * Ensure that the region operands are fully evaluated and verify
231 * the validity of the request
232 */
236 }
238 /*
239 * The physical address of this field datum is:
240 *
241 * 1) The base of the region, plus
242 * 2) The base offset of the field, plus
243 * 3) The current offset into the field
244 */
246 region_offset =
253 }
258 space_id),
264 region.
265 address +
266 region_offset))));
268 /* Invoke the appropriate address_space/op_region handler */
270 status =
273 access_byte_width),
274 value);
281 space_id),
287 space_id),
289 }
290 }
293 }
295 /*******************************************************************************
296 *
297 * FUNCTION: acpi_ex_register_overflow
298 *
299 * PARAMETERS: obj_desc - Register(Field) to be written
300 * Value - Value to be stored
301 *
302 * RETURN: TRUE if value overflows the field, FALSE otherwise
303 *
304 * DESCRIPTION: Check if a value is out of range of the field being written.
305 * Used to check if the values written to Index and Bank registers
306 * are out of range. Normally, the value is simply truncated
307 * to fit the field, but this case is most likely a serious
308 * coding error in the ASL.
309 *
310 ******************************************************************************/
312 static u8
314 acpi_integer value)
315 {
318 /*
319 * The field is large enough to hold the maximum integer, so we can
320 * never overflow it.
321 */
323 }
326 /*
327 * The Value is larger than the maximum value that can fit into
328 * the register.
329 */
331 }
333 /* The Value will fit into the field with no truncation */
336 }
338 /*******************************************************************************
339 *
340 * FUNCTION: acpi_ex_field_datum_io
341 *
342 * PARAMETERS: obj_desc - Field to be read
343 * field_datum_byte_offset - Byte offset of this datum within the
344 * parent field
345 * Value - Where to store value (must be 64 bits)
346 * read_write - Read or Write flag
347 *
348 * RETURN: Status
349 *
350 * DESCRIPTION: Read or Write a single datum of a field. The field_type is
351 * demultiplexed here to handle the different types of fields
352 * (buffer_field, region_field, index_field, bank_field)
353 *
354 ******************************************************************************/
356 static acpi_status
358 u32 field_datum_byte_offset,
360 {
361 acpi_status status;
362 acpi_integer local_value;
370 /* To support reads without saving return value */
372 }
374 /* Clear the entire return buffer first, [Very Important!] */
377 }
379 /*
380 * The four types of fields are:
381 *
382 * buffer_field - Read/write from/to a Buffer
383 * region_field - Read/write from/to a Operation Region.
384 * bank_field - Write to a Bank Register, then read/write from/to an
385 * operation_region
386 * index_field - Write to an Index Register, then read/write from/to a
387 * Data Register
388 */
391 /*
392 * If the buffer_field arguments have not been previously evaluated,
393 * evaluate them now and save the results.
394 */
399 }
400 }
403 /*
404 * Copy the data from the source buffer.
405 * Length is the field width in bytes.
406 */
409 pointer +
411 field_datum_byte_offset,
414 /*
415 * Copy the data to the target buffer.
416 * Length is the field width in bytes.
417 */
419 pointer +
423 }
430 /*
431 * Ensure that the bank_value is not beyond the capacity of
432 * the register
433 */
438 }
440 /*
441 * For bank_fields, we must write the bank_value to the bank_register
442 * (itself a region_field) before we can access the data.
443 */
444 status =
448 value));
451 }
453 /*
454 * Now that the Bank has been selected, fall through to the
455 * region_field case and write the datum to the Operation Region
456 */
458 /*lint -fallthrough */
461 /*
462 * For simple region_fields, we just directly access the owning
463 * Operation Region.
464 */
465 status =
472 /*
473 * Ensure that the index_value is not beyond the capacity of
474 * the register
475 */
480 }
482 /* Write the index value to the index_register (itself a region_field) */
488 field_datum_byte_offset));
490 status =
496 }
500 /* Read the datum from the data_register */
505 status =
510 /* Write the datum to the data_register */
516 status =
520 }
529 }
537 access_byte_width));
543 access_byte_width));
544 }
545 }
548 }
550 /*******************************************************************************
551 *
552 * FUNCTION: acpi_ex_write_with_update_rule
553 *
554 * PARAMETERS: obj_desc - Field to be written
555 * Mask - bitmask within field datum
556 * field_value - Value to write
557 * field_datum_byte_offset - Offset of datum within field
558 *
559 * RETURN: Status
560 *
561 * DESCRIPTION: Apply the field update rule to a field write
562 *
563 ******************************************************************************/
565 acpi_status
567 acpi_integer mask,
568 acpi_integer field_value,
569 u32 field_datum_byte_offset)
570 {
572 acpi_integer merged_value;
573 acpi_integer current_value;
577 /* Start with the new bits */
581 /* If the mask is all ones, we don't need to worry about the update rule */
585 /* Decode the update rule */
590 /*
591 * Check if update rule needs to be applied (not if mask is all
592 * ones) The left shift drops the bits we want to ignore.
593 */
597 /*
598 * Read the current contents of the byte/word/dword containing
599 * the field, and merge with the new field value.
600 */
601 status =
603 field_datum_byte_offset,
605 ACPI_READ);
608 }
611 }
616 /* Set positions outside the field to all ones */
623 /* Set positions outside the field to all zeros */
633 field_flags &
634 AML_FIELD_UPDATE_RULE_MASK)));
636 }
637 }
642 field_datum_byte_offset,
647 /* Write the merged value */
653 }
655 /*******************************************************************************
656 *
657 * FUNCTION: acpi_ex_extract_from_field
658 *
659 * PARAMETERS: obj_desc - Field to be read
660 * Buffer - Where to store the field data
661 * buffer_length - Length of Buffer
662 *
663 * RETURN: Status
664 *
665 * DESCRIPTION: Retrieve the current value of the given field
666 *
667 ******************************************************************************/
669 acpi_status
672 {
673 acpi_status status;
674 acpi_integer raw_datum;
675 acpi_integer merged_datum;
678 u32 buffer_tail_bits;
679 u32 datum_count;
680 u32 field_datum_count;
681 u32 i;
685 /* Validate target buffer and clear it */
694 }
697 /* Compute the number of datums (access width data items) */
703 start_field_bit_offset,
705 access_bit_width);
707 /* Priming read from the field */
709 status =
711 ACPI_READ);
714 }
715 merged_datum =
718 /* Read the rest of the field */
722 /* Get next input datum from the field */
729 }
731 /*
732 * Merge with previous datum if necessary.
733 *
734 * Note: Before the shift, check if the shift value will be larger than
735 * the integer size. If so, there is no need to perform the operation.
736 * This avoids the differences in behavior between different compilers
737 * concerning shift values larger than the target data width.
738 */
741 ACPI_INTEGER_BIT_SIZE) {
742 merged_datum |=
744 access_bit_width -
746 start_field_bit_offset);
747 }
751 }
753 /* Write merged datum to target buffer */
760 merged_datum =
762 }
764 /* Mask off any extra bits in the last datum */
770 }
772 /* Write the last datum to the buffer */
779 }
781 /*******************************************************************************
782 *
783 * FUNCTION: acpi_ex_insert_into_field
784 *
785 * PARAMETERS: obj_desc - Field to be written
786 * Buffer - Data to be written
787 * buffer_length - Length of Buffer
788 *
789 * RETURN: Status
790 *
791 * DESCRIPTION: Store the Buffer contents into the given field
792 *
793 ******************************************************************************/
795 acpi_status
798 {
799 acpi_status status;
800 acpi_integer mask;
801 acpi_integer width_mask;
802 acpi_integer merged_datum;
806 u32 buffer_tail_bits;
807 u32 datum_count;
808 u32 field_datum_count;
809 u32 i;
810 u32 required_length;
815 /* Validate input buffer */
818 required_length =
820 /*
821 * We must have a buffer that is at least as long as the field
822 * we are writing to. This is because individual fields are
823 * indivisible and partial writes are not supported -- as per
824 * the ACPI specification.
825 */
828 /* We need to create a new buffer */
833 }
835 /*
836 * Copy the original data to the new buffer, starting
837 * at Byte zero. All unused (upper) bytes of the
838 * buffer will be 0.
839 */
843 }
845 /*
846 * Create the bitmasks used for bit insertion.
847 * Note: This if/else is used to bypass compiler differences with the
848 * shift operator
849 */
853 width_mask =
855 access_bit_width);
856 }
861 /* Compute the number of datums (access width data items) */
868 start_field_bit_offset,
870 access_bit_width);
872 /* Get initial Datum from the input buffer */
878 merged_datum =
881 /* Write the entire field */
885 /* Write merged datum to the target field */
889 merged_datum,
890 field_offset);
893 }
897 /*
898 * Start new output datum by merging with previous input datum
899 * if necessary.
900 *
901 * Note: Before the shift, check if the shift value will be larger than
902 * the integer size. If so, there is no need to perform the operation.
903 * This avoids the differences in behavior between different compilers
904 * concerning shift values larger than the target data width.
905 */
908 ACPI_INTEGER_BIT_SIZE) {
909 merged_datum =
911 access_bit_width -
913 start_field_bit_offset);
916 }
922 }
924 /* Get the next input datum from the buffer */
930 merged_datum |=
932 }
934 /* Mask off any extra bits in the last datum */
941 }
943 /* Write the last datum to the field */
948 field_offset);
950 exit:
951 /* Free temporary buffer if we used one */
955 }
957 }