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 - 2023, Intel Corp. |
7 | * |
8 | *****************************************************************************/ |
9 | |
10 | #include <acpi/acpi.h> |
11 | #include "accommon.h" |
12 | #include "acinterp.h" |
13 | #include "amlcode.h" |
14 | #include "acevents.h" |
15 | #include "acdispat.h" |
16 | |
17 | #define _COMPONENT ACPI_EXECUTER |
18 | ACPI_MODULE_NAME("exfldio" ) |
19 | |
20 | /* Local prototypes */ |
21 | static acpi_status |
22 | acpi_ex_field_datum_io(union acpi_operand_object *obj_desc, |
23 | u32 field_datum_byte_offset, u64 *value, u32 read_write); |
24 | |
25 | static u8 |
26 | acpi_ex_register_overflow(union acpi_operand_object *obj_desc, u64 value); |
27 | |
28 | static acpi_status |
29 | acpi_ex_setup_region(union acpi_operand_object *obj_desc, |
30 | u32 field_datum_byte_offset); |
31 | |
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 | ******************************************************************************/ |
47 | |
48 | static acpi_status |
49 | acpi_ex_setup_region(union acpi_operand_object *obj_desc, |
50 | u32 field_datum_byte_offset) |
51 | { |
52 | acpi_status status = AE_OK; |
53 | union acpi_operand_object *rgn_desc; |
54 | u8 space_id; |
55 | |
56 | ACPI_FUNCTION_TRACE_U32(ex_setup_region, field_datum_byte_offset); |
57 | |
58 | rgn_desc = obj_desc->common_field.region_obj; |
59 | |
60 | /* We must have a valid region */ |
61 | |
62 | if (rgn_desc->common.type != ACPI_TYPE_REGION) { |
63 | ACPI_ERROR((AE_INFO, "Needed Region, found type 0x%X (%s)" , |
64 | rgn_desc->common.type, |
65 | acpi_ut_get_object_type_name(rgn_desc))); |
66 | |
67 | return_ACPI_STATUS(AE_AML_OPERAND_TYPE); |
68 | } |
69 | |
70 | space_id = rgn_desc->region.space_id; |
71 | |
72 | /* Validate the Space ID */ |
73 | |
74 | if (!acpi_is_valid_space_id(space_id)) { |
75 | ACPI_ERROR((AE_INFO, |
76 | "Invalid/unknown Address Space ID: 0x%2.2X" , |
77 | space_id)); |
78 | return_ACPI_STATUS(AE_AML_INVALID_SPACE_ID); |
79 | } |
80 | |
81 | /* |
82 | * If the Region Address and Length have not been previously evaluated, |
83 | * evaluate them now and save the results. |
84 | */ |
85 | if (!(rgn_desc->common.flags & AOPOBJ_DATA_VALID)) { |
86 | status = acpi_ds_get_region_arguments(rgn_desc); |
87 | if (ACPI_FAILURE(status)) { |
88 | return_ACPI_STATUS(status); |
89 | } |
90 | } |
91 | |
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 | */ |
96 | if (space_id == ACPI_ADR_SPACE_SMBUS || |
97 | space_id == ACPI_ADR_SPACE_GSBUS || |
98 | space_id == ACPI_ADR_SPACE_IPMI) { |
99 | |
100 | /* SMBus or IPMI has a non-linear address space */ |
101 | |
102 | return_ACPI_STATUS(AE_OK); |
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 the length of the parent region) |
108 | */ |
109 | if (!(obj_desc->common.flags & AOPOBJ_DATA_VALID)) { |
110 | if (ACPI_FAILURE(status)) { |
111 | return_ACPI_STATUS(status); |
112 | } |
113 | } |
114 | #endif |
115 | |
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 | */ |
121 | if (rgn_desc->region.length < |
122 | (obj_desc->common_field.base_byte_offset + field_datum_byte_offset + |
123 | obj_desc->common_field.access_byte_width)) { |
124 | if (acpi_gbl_enable_interpreter_slack) { |
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 | */ |
130 | if (ACPI_ROUND_UP(rgn_desc->region.length, |
131 | obj_desc->common_field. |
132 | access_byte_width) >= |
133 | ((acpi_size)obj_desc->common_field. |
134 | base_byte_offset + |
135 | obj_desc->common_field.access_byte_width + |
136 | field_datum_byte_offset)) { |
137 | return_ACPI_STATUS(AE_OK); |
138 | } |
139 | } |
140 | |
141 | if (rgn_desc->region.length < |
142 | obj_desc->common_field.access_byte_width) { |
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 | */ |
148 | ACPI_ERROR((AE_INFO, |
149 | "Field [%4.4s] access width (%u bytes) " |
150 | "too large for region [%4.4s] (length %u)" , |
151 | acpi_ut_get_node_name(obj_desc-> |
152 | common_field.node), |
153 | obj_desc->common_field.access_byte_width, |
154 | acpi_ut_get_node_name(rgn_desc->region. |
155 | node), |
156 | rgn_desc->region.length)); |
157 | } |
158 | |
159 | /* |
160 | * Offset rounded up to next multiple of field width |
161 | * exceeds region length, indicate an error |
162 | */ |
163 | ACPI_ERROR((AE_INFO, |
164 | "Field [%4.4s] Base+Offset+Width %u+%u+%u " |
165 | "is beyond end of region [%4.4s] (length %u)" , |
166 | acpi_ut_get_node_name(obj_desc->common_field.node), |
167 | obj_desc->common_field.base_byte_offset, |
168 | field_datum_byte_offset, |
169 | obj_desc->common_field.access_byte_width, |
170 | acpi_ut_get_node_name(rgn_desc->region.node), |
171 | rgn_desc->region.length)); |
172 | |
173 | return_ACPI_STATUS(AE_AML_REGION_LIMIT); |
174 | } |
175 | |
176 | return_ACPI_STATUS(AE_OK); |
177 | } |
178 | |
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 | ******************************************************************************/ |
196 | |
197 | acpi_status |
198 | acpi_ex_access_region(union acpi_operand_object *obj_desc, |
199 | u32 field_datum_byte_offset, u64 *value, u32 function) |
200 | { |
201 | acpi_status status; |
202 | union acpi_operand_object *rgn_desc; |
203 | u32 region_offset; |
204 | |
205 | ACPI_FUNCTION_TRACE(ex_access_region); |
206 | |
207 | /* |
208 | * Ensure that the region operands are fully evaluated and verify |
209 | * the validity of the request |
210 | */ |
211 | status = acpi_ex_setup_region(obj_desc, field_datum_byte_offset); |
212 | if (ACPI_FAILURE(status)) { |
213 | return_ACPI_STATUS(status); |
214 | } |
215 | |
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 | */ |
223 | rgn_desc = obj_desc->common_field.region_obj; |
224 | region_offset = |
225 | obj_desc->common_field.base_byte_offset + field_datum_byte_offset; |
226 | |
227 | if ((function & ACPI_IO_MASK) == ACPI_READ) { |
228 | ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, "[READ]" )); |
229 | } else { |
230 | ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, "[WRITE]" )); |
231 | } |
232 | |
233 | ACPI_DEBUG_PRINT_RAW((ACPI_DB_BFIELD, |
234 | " Region [%s:%X], Width %X, ByteBase %X, Offset %X at %8.8X%8.8X\n" , |
235 | acpi_ut_get_region_name(rgn_desc->region. |
236 | space_id), |
237 | rgn_desc->region.space_id, |
238 | obj_desc->common_field.access_byte_width, |
239 | obj_desc->common_field.base_byte_offset, |
240 | field_datum_byte_offset, |
241 | ACPI_FORMAT_UINT64(rgn_desc->region.address + |
242 | region_offset))); |
243 | |
244 | /* Invoke the appropriate address_space/op_region handler */ |
245 | |
246 | status = acpi_ev_address_space_dispatch(region_obj: rgn_desc, field_obj: obj_desc, |
247 | function, region_offset, |
248 | ACPI_MUL_8(obj_desc-> |
249 | common_field. |
250 | access_byte_width), |
251 | value); |
252 | |
253 | if (ACPI_FAILURE(status)) { |
254 | if (status == AE_NOT_IMPLEMENTED) { |
255 | ACPI_ERROR((AE_INFO, |
256 | "Region %s (ID=%u) not implemented" , |
257 | acpi_ut_get_region_name(rgn_desc->region. |
258 | space_id), |
259 | rgn_desc->region.space_id)); |
260 | } else if (status == AE_NOT_EXIST) { |
261 | ACPI_ERROR((AE_INFO, |
262 | "Region %s (ID=%u) has no handler" , |
263 | acpi_ut_get_region_name(rgn_desc->region. |
264 | space_id), |
265 | rgn_desc->region.space_id)); |
266 | } |
267 | } |
268 | |
269 | return_ACPI_STATUS(status); |
270 | } |
271 | |
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 | ******************************************************************************/ |
288 | |
289 | static u8 |
290 | acpi_ex_register_overflow(union acpi_operand_object *obj_desc, u64 value) |
291 | { |
292 | |
293 | if (obj_desc->common_field.bit_length >= ACPI_INTEGER_BIT_SIZE) { |
294 | /* |
295 | * The field is large enough to hold the maximum integer, so we can |
296 | * never overflow it. |
297 | */ |
298 | return (FALSE); |
299 | } |
300 | |
301 | if (value >= ((u64) 1 << obj_desc->common_field.bit_length)) { |
302 | /* |
303 | * The Value is larger than the maximum value that can fit into |
304 | * the register. |
305 | */ |
306 | ACPI_ERROR((AE_INFO, |
307 | "Index value 0x%8.8X%8.8X overflows field width 0x%X" , |
308 | ACPI_FORMAT_UINT64(value), |
309 | obj_desc->common_field.bit_length)); |
310 | |
311 | return (TRUE); |
312 | } |
313 | |
314 | /* The Value will fit into the field with no truncation */ |
315 | |
316 | return (FALSE); |
317 | } |
318 | |
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 | ******************************************************************************/ |
336 | |
337 | static acpi_status |
338 | acpi_ex_field_datum_io(union acpi_operand_object *obj_desc, |
339 | u32 field_datum_byte_offset, u64 *value, u32 read_write) |
340 | { |
341 | acpi_status status; |
342 | u64 local_value; |
343 | |
344 | ACPI_FUNCTION_TRACE_U32(ex_field_datum_io, field_datum_byte_offset); |
345 | |
346 | if (read_write == ACPI_READ) { |
347 | if (!value) { |
348 | local_value = 0; |
349 | |
350 | /* To support reads without saving return value */ |
351 | value = &local_value; |
352 | } |
353 | |
354 | /* Clear the entire return buffer first, [Very Important!] */ |
355 | |
356 | *value = 0; |
357 | } |
358 | |
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 | */ |
369 | switch (obj_desc->common.type) { |
370 | case ACPI_TYPE_BUFFER_FIELD: |
371 | /* |
372 | * If the buffer_field arguments have not been previously evaluated, |
373 | * evaluate them now and save the results. |
374 | */ |
375 | if (!(obj_desc->common.flags & AOPOBJ_DATA_VALID)) { |
376 | status = acpi_ds_get_buffer_field_arguments(obj_desc); |
377 | if (ACPI_FAILURE(status)) { |
378 | return_ACPI_STATUS(status); |
379 | } |
380 | } |
381 | |
382 | if (read_write == ACPI_READ) { |
383 | /* |
384 | * Copy the data from the source buffer. |
385 | * Length is the field width in bytes. |
386 | */ |
387 | memcpy(value, |
388 | (obj_desc->buffer_field.buffer_obj)->buffer. |
389 | pointer + |
390 | obj_desc->buffer_field.base_byte_offset + |
391 | field_datum_byte_offset, |
392 | obj_desc->common_field.access_byte_width); |
393 | } else { |
394 | /* |
395 | * Copy the data to the target buffer. |
396 | * Length is the field width in bytes. |
397 | */ |
398 | memcpy((obj_desc->buffer_field.buffer_obj)->buffer. |
399 | pointer + |
400 | obj_desc->buffer_field.base_byte_offset + |
401 | field_datum_byte_offset, value, |
402 | obj_desc->common_field.access_byte_width); |
403 | } |
404 | |
405 | status = AE_OK; |
406 | break; |
407 | |
408 | case ACPI_TYPE_LOCAL_BANK_FIELD: |
409 | /* |
410 | * Ensure that the bank_value is not beyond the capacity of |
411 | * the register |
412 | */ |
413 | if (acpi_ex_register_overflow(obj_desc: obj_desc->bank_field.bank_obj, |
414 | value: (u64) obj_desc->bank_field. |
415 | value)) { |
416 | return_ACPI_STATUS(AE_AML_REGISTER_LIMIT); |
417 | } |
418 | |
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 = |
424 | acpi_ex_insert_into_field(obj_desc: obj_desc->bank_field.bank_obj, |
425 | buffer: &obj_desc->bank_field.value, |
426 | buffer_length: sizeof(obj_desc->bank_field. |
427 | value)); |
428 | if (ACPI_FAILURE(status)) { |
429 | return_ACPI_STATUS(status); |
430 | } |
431 | |
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 | */ |
436 | |
437 | ACPI_FALLTHROUGH; |
438 | |
439 | case ACPI_TYPE_LOCAL_REGION_FIELD: |
440 | /* |
441 | * For simple region_fields, we just directly access the owning |
442 | * Operation Region. |
443 | */ |
444 | status = |
445 | acpi_ex_access_region(obj_desc, field_datum_byte_offset, |
446 | value, function: read_write); |
447 | break; |
448 | |
449 | case ACPI_TYPE_LOCAL_INDEX_FIELD: |
450 | /* |
451 | * Ensure that the index_value is not beyond the capacity of |
452 | * the register |
453 | */ |
454 | if (acpi_ex_register_overflow(obj_desc: obj_desc->index_field.index_obj, |
455 | value: (u64) obj_desc->index_field. |
456 | value)) { |
457 | return_ACPI_STATUS(AE_AML_REGISTER_LIMIT); |
458 | } |
459 | |
460 | /* Write the index value to the index_register (itself a region_field) */ |
461 | |
462 | field_datum_byte_offset += obj_desc->index_field.value; |
463 | |
464 | ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, |
465 | "Write to Index Register: Value %8.8X\n" , |
466 | field_datum_byte_offset)); |
467 | |
468 | status = |
469 | acpi_ex_insert_into_field(obj_desc: obj_desc->index_field.index_obj, |
470 | buffer: &field_datum_byte_offset, |
471 | buffer_length: sizeof(field_datum_byte_offset)); |
472 | if (ACPI_FAILURE(status)) { |
473 | return_ACPI_STATUS(status); |
474 | } |
475 | |
476 | if (read_write == ACPI_READ) { |
477 | |
478 | /* Read the datum from the data_register */ |
479 | |
480 | ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, |
481 | "Read from Data Register\n" )); |
482 | |
483 | status = |
484 | acpi_ex_extract_from_field(obj_desc: obj_desc->index_field. |
485 | data_obj, buffer: value, |
486 | buffer_length: sizeof(u64)); |
487 | } else { |
488 | /* Write the datum to the data_register */ |
489 | |
490 | ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, |
491 | "Write to Data Register: Value %8.8X%8.8X\n" , |
492 | ACPI_FORMAT_UINT64(*value))); |
493 | |
494 | status = |
495 | acpi_ex_insert_into_field(obj_desc: obj_desc->index_field. |
496 | data_obj, buffer: value, |
497 | buffer_length: sizeof(u64)); |
498 | } |
499 | break; |
500 | |
501 | default: |
502 | |
503 | ACPI_ERROR((AE_INFO, "Wrong object type in field I/O %u" , |
504 | obj_desc->common.type)); |
505 | status = AE_AML_INTERNAL; |
506 | break; |
507 | } |
508 | |
509 | if (ACPI_SUCCESS(status)) { |
510 | if (read_write == ACPI_READ) { |
511 | ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, |
512 | "Value Read %8.8X%8.8X, Width %u\n" , |
513 | ACPI_FORMAT_UINT64(*value), |
514 | obj_desc->common_field. |
515 | access_byte_width)); |
516 | } else { |
517 | ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, |
518 | "Value Written %8.8X%8.8X, Width %u\n" , |
519 | ACPI_FORMAT_UINT64(*value), |
520 | obj_desc->common_field. |
521 | access_byte_width)); |
522 | } |
523 | } |
524 | |
525 | return_ACPI_STATUS(status); |
526 | } |
527 | |
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 | ******************************************************************************/ |
542 | |
543 | acpi_status |
544 | acpi_ex_write_with_update_rule(union acpi_operand_object *obj_desc, |
545 | u64 mask, |
546 | u64 field_value, u32 field_datum_byte_offset) |
547 | { |
548 | acpi_status status = AE_OK; |
549 | u64 merged_value; |
550 | u64 current_value; |
551 | |
552 | ACPI_FUNCTION_TRACE_U32(ex_write_with_update_rule, mask); |
553 | |
554 | /* Start with the new bits */ |
555 | |
556 | merged_value = field_value; |
557 | |
558 | /* If the mask is all ones, we don't need to worry about the update rule */ |
559 | |
560 | if (mask != ACPI_UINT64_MAX) { |
561 | |
562 | /* Decode the update rule */ |
563 | |
564 | switch (obj_desc->common_field. |
565 | field_flags & AML_FIELD_UPDATE_RULE_MASK) { |
566 | case AML_FIELD_UPDATE_PRESERVE: |
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 | */ |
571 | if ((~mask << (ACPI_MUL_8(sizeof(mask)) - |
572 | ACPI_MUL_8(obj_desc->common_field. |
573 | access_byte_width))) != 0) { |
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 = |
579 | acpi_ex_field_datum_io(obj_desc, |
580 | field_datum_byte_offset, |
581 | value: ¤t_value, |
582 | ACPI_READ); |
583 | if (ACPI_FAILURE(status)) { |
584 | return_ACPI_STATUS(status); |
585 | } |
586 | |
587 | merged_value |= (current_value & ~mask); |
588 | } |
589 | break; |
590 | |
591 | case AML_FIELD_UPDATE_WRITE_AS_ONES: |
592 | |
593 | /* Set positions outside the field to all ones */ |
594 | |
595 | merged_value |= ~mask; |
596 | break; |
597 | |
598 | case AML_FIELD_UPDATE_WRITE_AS_ZEROS: |
599 | |
600 | /* Set positions outside the field to all zeros */ |
601 | |
602 | merged_value &= mask; |
603 | break; |
604 | |
605 | default: |
606 | |
607 | ACPI_ERROR((AE_INFO, |
608 | "Unknown UpdateRule value: 0x%X" , |
609 | (obj_desc->common_field.field_flags & |
610 | AML_FIELD_UPDATE_RULE_MASK))); |
611 | return_ACPI_STATUS(AE_AML_OPERAND_VALUE); |
612 | } |
613 | } |
614 | |
615 | ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, |
616 | "Mask %8.8X%8.8X, DatumOffset %X, Width %X, " |
617 | "Value %8.8X%8.8X, MergedValue %8.8X%8.8X\n" , |
618 | ACPI_FORMAT_UINT64(mask), |
619 | field_datum_byte_offset, |
620 | obj_desc->common_field.access_byte_width, |
621 | ACPI_FORMAT_UINT64(field_value), |
622 | ACPI_FORMAT_UINT64(merged_value))); |
623 | |
624 | /* Write the merged value */ |
625 | |
626 | status = |
627 | acpi_ex_field_datum_io(obj_desc, field_datum_byte_offset, |
628 | value: &merged_value, ACPI_WRITE); |
629 | |
630 | return_ACPI_STATUS(status); |
631 | } |
632 | |
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 | ******************************************************************************/ |
646 | |
647 | acpi_status |
648 | (union acpi_operand_object *obj_desc, |
649 | void *buffer, u32 buffer_length) |
650 | { |
651 | acpi_status status; |
652 | u64 raw_datum; |
653 | u64 merged_datum; |
654 | u32 field_offset = 0; |
655 | u32 buffer_offset = 0; |
656 | u32 buffer_tail_bits; |
657 | u32 datum_count; |
658 | u32 field_datum_count; |
659 | u32 access_bit_width; |
660 | u32 i; |
661 | |
662 | ACPI_FUNCTION_TRACE(ex_extract_from_field); |
663 | |
664 | /* Validate target buffer and clear it */ |
665 | |
666 | if (buffer_length < |
667 | ACPI_ROUND_BITS_UP_TO_BYTES(obj_desc->common_field.bit_length)) { |
668 | ACPI_ERROR((AE_INFO, |
669 | "Field size %u (bits) is too large for buffer (%u)" , |
670 | obj_desc->common_field.bit_length, buffer_length)); |
671 | |
672 | return_ACPI_STATUS(AE_BUFFER_OVERFLOW); |
673 | } |
674 | |
675 | memset(buffer, 0, buffer_length); |
676 | access_bit_width = ACPI_MUL_8(obj_desc->common_field.access_byte_width); |
677 | |
678 | /* Handle the simple case here */ |
679 | |
680 | if ((obj_desc->common_field.start_field_bit_offset == 0) && |
681 | (obj_desc->common_field.bit_length == access_bit_width)) { |
682 | if (buffer_length >= sizeof(u64)) { |
683 | status = |
684 | acpi_ex_field_datum_io(obj_desc, field_datum_byte_offset: 0, value: buffer, |
685 | ACPI_READ); |
686 | } else { |
687 | /* Use raw_datum (u64) to handle buffers < 64 bits */ |
688 | |
689 | status = |
690 | acpi_ex_field_datum_io(obj_desc, field_datum_byte_offset: 0, value: &raw_datum, |
691 | ACPI_READ); |
692 | memcpy(buffer, &raw_datum, buffer_length); |
693 | } |
694 | |
695 | return_ACPI_STATUS(status); |
696 | } |
697 | |
698 | /* TBD: Move to common setup code */ |
699 | |
700 | /* Field algorithm is limited to sizeof(u64), truncate if needed */ |
701 | |
702 | if (obj_desc->common_field.access_byte_width > sizeof(u64)) { |
703 | obj_desc->common_field.access_byte_width = sizeof(u64); |
704 | access_bit_width = sizeof(u64) * 8; |
705 | } |
706 | |
707 | /* Compute the number of datums (access width data items) */ |
708 | |
709 | datum_count = |
710 | ACPI_ROUND_UP_TO(obj_desc->common_field.bit_length, |
711 | access_bit_width); |
712 | |
713 | field_datum_count = ACPI_ROUND_UP_TO(obj_desc->common_field.bit_length + |
714 | obj_desc->common_field. |
715 | start_field_bit_offset, |
716 | access_bit_width); |
717 | |
718 | /* Priming read from the field */ |
719 | |
720 | status = |
721 | acpi_ex_field_datum_io(obj_desc, field_datum_byte_offset: field_offset, value: &raw_datum, |
722 | ACPI_READ); |
723 | if (ACPI_FAILURE(status)) { |
724 | return_ACPI_STATUS(status); |
725 | } |
726 | merged_datum = |
727 | raw_datum >> obj_desc->common_field.start_field_bit_offset; |
728 | |
729 | /* Read the rest of the field */ |
730 | |
731 | for (i = 1; i < field_datum_count; i++) { |
732 | |
733 | /* Get next input datum from the field */ |
734 | |
735 | field_offset += obj_desc->common_field.access_byte_width; |
736 | status = |
737 | acpi_ex_field_datum_io(obj_desc, field_datum_byte_offset: field_offset, value: &raw_datum, |
738 | ACPI_READ); |
739 | if (ACPI_FAILURE(status)) { |
740 | return_ACPI_STATUS(status); |
741 | } |
742 | |
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 | */ |
751 | if (access_bit_width - |
752 | obj_desc->common_field.start_field_bit_offset < |
753 | ACPI_INTEGER_BIT_SIZE) { |
754 | merged_datum |= |
755 | raw_datum << (access_bit_width - |
756 | obj_desc->common_field. |
757 | start_field_bit_offset); |
758 | } |
759 | |
760 | if (i == datum_count) { |
761 | break; |
762 | } |
763 | |
764 | /* Write merged datum to target buffer */ |
765 | |
766 | memcpy(((char *)buffer) + buffer_offset, &merged_datum, |
767 | ACPI_MIN(obj_desc->common_field.access_byte_width, |
768 | buffer_length - buffer_offset)); |
769 | |
770 | buffer_offset += obj_desc->common_field.access_byte_width; |
771 | merged_datum = |
772 | raw_datum >> obj_desc->common_field.start_field_bit_offset; |
773 | } |
774 | |
775 | /* Mask off any extra bits in the last datum */ |
776 | |
777 | buffer_tail_bits = obj_desc->common_field.bit_length % access_bit_width; |
778 | if (buffer_tail_bits) { |
779 | merged_datum &= ACPI_MASK_BITS_ABOVE(buffer_tail_bits); |
780 | } |
781 | |
782 | /* Write the last datum to the buffer */ |
783 | |
784 | memcpy(((char *)buffer) + buffer_offset, &merged_datum, |
785 | ACPI_MIN(obj_desc->common_field.access_byte_width, |
786 | buffer_length - buffer_offset)); |
787 | |
788 | return_ACPI_STATUS(AE_OK); |
789 | } |
790 | |
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 | ******************************************************************************/ |
804 | |
805 | acpi_status |
806 | acpi_ex_insert_into_field(union acpi_operand_object *obj_desc, |
807 | void *buffer, u32 buffer_length) |
808 | { |
809 | void *new_buffer; |
810 | acpi_status status; |
811 | u64 mask; |
812 | u64 width_mask; |
813 | u64 merged_datum; |
814 | u64 raw_datum = 0; |
815 | u32 field_offset = 0; |
816 | u32 buffer_offset = 0; |
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; |
823 | |
824 | ACPI_FUNCTION_TRACE(ex_insert_into_field); |
825 | |
826 | /* Validate input buffer */ |
827 | |
828 | new_buffer = NULL; |
829 | required_length = |
830 | ACPI_ROUND_BITS_UP_TO_BYTES(obj_desc->common_field.bit_length); |
831 | |
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 | */ |
838 | if (buffer_length < required_length) { |
839 | |
840 | /* We need to create a new buffer */ |
841 | |
842 | new_buffer = ACPI_ALLOCATE_ZEROED(required_length); |
843 | if (!new_buffer) { |
844 | return_ACPI_STATUS(AE_NO_MEMORY); |
845 | } |
846 | |
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 | */ |
852 | memcpy((char *)new_buffer, (char *)buffer, buffer_length); |
853 | buffer = new_buffer; |
854 | buffer_length = required_length; |
855 | } |
856 | |
857 | /* TBD: Move to common setup code */ |
858 | |
859 | /* Algo is limited to sizeof(u64), so cut the access_byte_width */ |
860 | if (obj_desc->common_field.access_byte_width > sizeof(u64)) { |
861 | obj_desc->common_field.access_byte_width = sizeof(u64); |
862 | } |
863 | |
864 | access_bit_width = ACPI_MUL_8(obj_desc->common_field.access_byte_width); |
865 | |
866 | /* Create the bitmasks used for bit insertion */ |
867 | |
868 | width_mask = ACPI_MASK_BITS_ABOVE_64(access_bit_width); |
869 | mask = width_mask & |
870 | ACPI_MASK_BITS_BELOW(obj_desc->common_field.start_field_bit_offset); |
871 | |
872 | /* Compute the number of datums (access width data items) */ |
873 | |
874 | datum_count = ACPI_ROUND_UP_TO(obj_desc->common_field.bit_length, |
875 | access_bit_width); |
876 | |
877 | field_datum_count = ACPI_ROUND_UP_TO(obj_desc->common_field.bit_length + |
878 | obj_desc->common_field. |
879 | start_field_bit_offset, |
880 | access_bit_width); |
881 | |
882 | /* Get initial Datum from the input buffer */ |
883 | |
884 | memcpy(&raw_datum, buffer, |
885 | ACPI_MIN(obj_desc->common_field.access_byte_width, |
886 | buffer_length - buffer_offset)); |
887 | |
888 | merged_datum = |
889 | raw_datum << obj_desc->common_field.start_field_bit_offset; |
890 | |
891 | /* Write the entire field */ |
892 | |
893 | for (i = 1; i < field_datum_count; i++) { |
894 | |
895 | /* Write merged datum to the target field */ |
896 | |
897 | merged_datum &= mask; |
898 | status = |
899 | acpi_ex_write_with_update_rule(obj_desc, mask, field_value: merged_datum, |
900 | field_datum_byte_offset: field_offset); |
901 | if (ACPI_FAILURE(status)) { |
902 | goto exit; |
903 | } |
904 | |
905 | field_offset += obj_desc->common_field.access_byte_width; |
906 | |
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 | */ |
916 | if ((access_bit_width - |
917 | obj_desc->common_field.start_field_bit_offset) < |
918 | ACPI_INTEGER_BIT_SIZE) { |
919 | merged_datum = |
920 | raw_datum >> (access_bit_width - |
921 | obj_desc->common_field. |
922 | start_field_bit_offset); |
923 | } else { |
924 | merged_datum = 0; |
925 | } |
926 | |
927 | mask = width_mask; |
928 | |
929 | if (i == datum_count) { |
930 | break; |
931 | } |
932 | |
933 | /* Get the next input datum from the buffer */ |
934 | |
935 | buffer_offset += obj_desc->common_field.access_byte_width; |
936 | memcpy(&raw_datum, ((char *)buffer) + buffer_offset, |
937 | ACPI_MIN(obj_desc->common_field.access_byte_width, |
938 | buffer_length - buffer_offset)); |
939 | |
940 | merged_datum |= |
941 | raw_datum << obj_desc->common_field.start_field_bit_offset; |
942 | } |
943 | |
944 | /* Mask off any extra bits in the last datum */ |
945 | |
946 | buffer_tail_bits = (obj_desc->common_field.bit_length + |
947 | obj_desc->common_field.start_field_bit_offset) % |
948 | access_bit_width; |
949 | if (buffer_tail_bits) { |
950 | mask &= ACPI_MASK_BITS_ABOVE(buffer_tail_bits); |
951 | } |
952 | |
953 | /* Write the last datum to the field */ |
954 | |
955 | merged_datum &= mask; |
956 | status = |
957 | acpi_ex_write_with_update_rule(obj_desc, mask, field_value: merged_datum, |
958 | field_datum_byte_offset: field_offset); |
959 | |
960 | exit: |
961 | /* Free temporary buffer if we used one */ |
962 | |
963 | if (new_buffer) { |
964 | ACPI_FREE(new_buffer); |
965 | } |
966 | return_ACPI_STATUS(status); |
967 | } |
968 | |