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 - 2022, 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(rgn_desc, 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->bank_field.bank_obj, 414 (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->bank_field.bank_obj, 425 &obj_desc->bank_field.value, 426 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, 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->index_field.index_obj, 455 (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->index_field.index_obj, 470 &field_datum_byte_offset, 471 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->index_field. 485 data_obj, value, 486 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->index_field. 496 data_obj, value, 497 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 ¤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 &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 acpi_ex_extract_from_field(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, 0, 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, 0, &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_offset, &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_offset, &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, merged_datum, 900 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, merged_datum, 958 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