LXR linux/drivers/acpi/acpica/exfield.c

   1// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
   2/******************************************************************************
   3 *
   4 * Module Name: exfield - AML execution - field_unit read/write
   5 *
   6 * Copyright (C) 2000 - 2021, Intel Corp.
   7 *
   8 *****************************************************************************/
   9
  10#include <acpi/acpi.h>
  11#include "accommon.h"
  12#include "acdispat.h"
  13#include "acinterp.h"
  14#include "amlcode.h"
  15
  16#define _COMPONENT          ACPI_EXECUTER
  17ACPI_MODULE_NAME("exfield")
  18
  19/*
  20 * This table maps the various Attrib protocols to the byte transfer
  21 * length. Used for the generic serial bus.
  22 */
  23#define ACPI_INVALID_PROTOCOL_ID        0x80
  24#define ACPI_MAX_PROTOCOL_ID            0x0F
  25static const u8 acpi_protocol_lengths[] = {
  26        ACPI_INVALID_PROTOCOL_ID,       /* 0 - reserved */
  27        ACPI_INVALID_PROTOCOL_ID,       /* 1 - reserved */
  28        0x00,                   /* 2 - ATTRIB_QUICK */
  29        ACPI_INVALID_PROTOCOL_ID,       /* 3 - reserved */
  30        0x01,                   /* 4 - ATTRIB_SEND_RECEIVE */
  31        ACPI_INVALID_PROTOCOL_ID,       /* 5 - reserved */
  32        0x01,                   /* 6 - ATTRIB_BYTE */
  33        ACPI_INVALID_PROTOCOL_ID,       /* 7 - reserved */
  34        0x02,                   /* 8 - ATTRIB_WORD */
  35        ACPI_INVALID_PROTOCOL_ID,       /* 9 - reserved */
  36        0xFF,                   /* A - ATTRIB_BLOCK  */
  37        0xFF,                   /* B - ATTRIB_BYTES */
  38        0x02,                   /* C - ATTRIB_PROCESS_CALL */
  39        0xFF,                   /* D - ATTRIB_BLOCK_PROCESS_CALL */
  40        0xFF,                   /* E - ATTRIB_RAW_BYTES */
  41        0xFF                    /* F - ATTRIB_RAW_PROCESS_BYTES */
  42};
  43
  44#define PCC_MASTER_SUBSPACE     3
  45
  46/*
  47 * The following macros determine a given offset is a COMD field.
  48 * According to the specification, generic subspaces (types 0-2) contains a
  49 * 2-byte COMD field at offset 4 and master subspaces (type 3) contains a 4-byte
  50 * COMD field starting at offset 12.
  51 */
  52#define GENERIC_SUBSPACE_COMMAND(a)     (4 == a || a == 5)
  53#define MASTER_SUBSPACE_COMMAND(a)      (12 <= a && a <= 15)
  54
  55/*******************************************************************************
  56 *
  57 * FUNCTION:    acpi_ex_get_protocol_buffer_length
  58 *
  59 * PARAMETERS:  protocol_id     - The type of the protocol indicated by region
  60 *                                field access attributes
  61 *              return_length   - Where the protocol byte transfer length is
  62 *                                returned
  63 *
  64 * RETURN:      Status and decoded byte transfer length
  65 *
  66 * DESCRIPTION: This routine returns the length of the generic_serial_bus
  67 *              protocol bytes
  68 *
  69 ******************************************************************************/
  70
  71acpi_status
  72acpi_ex_get_protocol_buffer_length(u32 protocol_id, u32 *return_length)
  73{
  74
  75        if ((protocol_id > ACPI_MAX_PROTOCOL_ID) ||
  76            (acpi_protocol_lengths[protocol_id] == ACPI_INVALID_PROTOCOL_ID)) {
  77                ACPI_ERROR((AE_INFO,
  78                            "Invalid Field/AccessAs protocol ID: 0x%4.4X",
  79                            protocol_id));
  80
  81                return (AE_AML_PROTOCOL);
  82        }
  83
  84        *return_length = acpi_protocol_lengths[protocol_id];
  85        return (AE_OK);
  86}
  87
  88/*******************************************************************************
  89 *
  90 * FUNCTION:    acpi_ex_read_data_from_field
  91 *
  92 * PARAMETERS:  walk_state          - Current execution state
  93 *              obj_desc            - The named field
  94 *              ret_buffer_desc     - Where the return data object is stored
  95 *
  96 * RETURN:      Status
  97 *
  98 * DESCRIPTION: Read from a named field. Returns either an Integer or a
  99 *              Buffer, depending on the size of the field and whether if a
 100 *              field is created by the create_field() operator.
 101 *
 102 ******************************************************************************/
 103
 104acpi_status
 105acpi_ex_read_data_from_field(struct acpi_walk_state *walk_state,
 106                             union acpi_operand_object *obj_desc,
 107                             union acpi_operand_object **ret_buffer_desc)
 108{
 109        acpi_status status;
 110        union acpi_operand_object *buffer_desc;
 111        void *buffer;
 112        u32 buffer_length;
 113
 114        ACPI_FUNCTION_TRACE_PTR(ex_read_data_from_field, obj_desc);
 115
 116        /* Parameter validation */
 117
 118        if (!obj_desc) {
 119                return_ACPI_STATUS(AE_AML_NO_OPERAND);
 120        }
 121        if (!ret_buffer_desc) {
 122                return_ACPI_STATUS(AE_BAD_PARAMETER);
 123        }
 124
 125        if (obj_desc->common.type == ACPI_TYPE_BUFFER_FIELD) {
 126                /*
 127                 * If the buffer_field arguments have not been previously evaluated,
 128                 * evaluate them now and save the results.
 129                 */
 130                if (!(obj_desc->common.flags & AOPOBJ_DATA_VALID)) {
 131                        status = acpi_ds_get_buffer_field_arguments(obj_desc);
 132                        if (ACPI_FAILURE(status)) {
 133                                return_ACPI_STATUS(status);
 134                        }
 135                }
 136        } else if ((obj_desc->common.type == ACPI_TYPE_LOCAL_REGION_FIELD) &&
 137                   (obj_desc->field.region_obj->region.space_id ==
 138                    ACPI_ADR_SPACE_SMBUS
 139                    || obj_desc->field.region_obj->region.space_id ==
 140                    ACPI_ADR_SPACE_GSBUS
 141                    || obj_desc->field.region_obj->region.space_id ==
 142                    ACPI_ADR_SPACE_IPMI
 143                    || obj_desc->field.region_obj->region.space_id ==
 144                    ACPI_ADR_SPACE_PLATFORM_RT)) {
 145
 146                /* SMBus, GSBus, IPMI serial */
 147
 148                status = acpi_ex_read_serial_bus(obj_desc, ret_buffer_desc);
 149                return_ACPI_STATUS(status);
 150        }
 151
 152        /*
 153         * Allocate a buffer for the contents of the field.
 154         *
 155         * If the field is larger than the current integer width, create
 156         * a BUFFER to hold it. Otherwise, use an INTEGER. This allows
 157         * the use of arithmetic operators on the returned value if the
 158         * field size is equal or smaller than an Integer.
 159         *
 160         * However, all buffer fields created by create_field operator needs to
 161         * remain as a buffer to match other AML interpreter implementations.
 162         *
 163         * Note: Field.length is in bits.
 164         */
 165        buffer_length =
 166            (acpi_size)ACPI_ROUND_BITS_UP_TO_BYTES(obj_desc->field.bit_length);
 167
 168        if (buffer_length > acpi_gbl_integer_byte_width ||
 169            (obj_desc->common.type == ACPI_TYPE_BUFFER_FIELD &&
 170             obj_desc->buffer_field.is_create_field)) {
 171
 172                /* Field is too large for an Integer, create a Buffer instead */
 173
 174                buffer_desc = acpi_ut_create_buffer_object(buffer_length);
 175                if (!buffer_desc) {
 176                        return_ACPI_STATUS(AE_NO_MEMORY);
 177                }
 178                buffer = buffer_desc->buffer.pointer;
 179        } else {
 180                /* Field will fit within an Integer (normal case) */
 181
 182                buffer_desc = acpi_ut_create_integer_object((u64) 0);
 183                if (!buffer_desc) {
 184                        return_ACPI_STATUS(AE_NO_MEMORY);
 185                }
 186
 187                buffer_length = acpi_gbl_integer_byte_width;
 188                buffer = &buffer_desc->integer.value;
 189        }
 190
 191        if ((obj_desc->common.type == ACPI_TYPE_LOCAL_REGION_FIELD) &&
 192            (obj_desc->field.region_obj->region.space_id ==
 193             ACPI_ADR_SPACE_GPIO)) {
 194
 195                /* General Purpose I/O */
 196
 197                status = acpi_ex_read_gpio(obj_desc, buffer);
 198                goto exit;
 199        } else if ((obj_desc->common.type == ACPI_TYPE_LOCAL_REGION_FIELD) &&
 200                   (obj_desc->field.region_obj->region.space_id ==
 201                    ACPI_ADR_SPACE_PLATFORM_COMM)) {
 202                /*
 203                 * Reading from a PCC field unit does not require the handler because
 204                 * it only requires reading from the internal_pcc_buffer.
 205                 */
 206                ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,
 207                                  "PCC FieldRead bits %u\n",
 208                                  obj_desc->field.bit_length));
 209
 210                memcpy(buffer,
 211                       obj_desc->field.region_obj->field.internal_pcc_buffer +
 212                       obj_desc->field.base_byte_offset,
 213                       (acpi_size)ACPI_ROUND_BITS_UP_TO_BYTES(obj_desc->field.
 214                                                              bit_length));
 215
 216                *ret_buffer_desc = buffer_desc;
 217                return AE_OK;
 218        }
 219
 220        ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,
 221                          "FieldRead [TO]:   Obj %p, Type %X, Buf %p, ByteLen %X\n",
 222                          obj_desc, obj_desc->common.type, buffer,
 223                          buffer_length));
 224        ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,
 225                          "FieldRead [FROM]: BitLen %X, BitOff %X, ByteOff %X\n",
 226                          obj_desc->common_field.bit_length,
 227                          obj_desc->common_field.start_field_bit_offset,
 228                          obj_desc->common_field.base_byte_offset));
 229
 230        /* Lock entire transaction if requested */
 231
 232        acpi_ex_acquire_global_lock(obj_desc->common_field.field_flags);
 233
 234        /* Read from the field */
 235
 236        status = acpi_ex_extract_from_field(obj_desc, buffer, buffer_length);
 237        acpi_ex_release_global_lock(obj_desc->common_field.field_flags);
 238
 239exit:
 240        if (ACPI_FAILURE(status)) {
 241                acpi_ut_remove_reference(buffer_desc);
 242        } else {
 243                *ret_buffer_desc = buffer_desc;
 244        }
 245
 246        return_ACPI_STATUS(status);
 247}
 248
 249/*******************************************************************************
 250 *
 251 * FUNCTION:    acpi_ex_write_data_to_field
 252 *
 253 * PARAMETERS:  source_desc         - Contains data to write
 254 *              obj_desc            - The named field
 255 *              result_desc         - Where the return value is returned, if any
 256 *
 257 * RETURN:      Status
 258 *
 259 * DESCRIPTION: Write to a named field
 260 *
 261 ******************************************************************************/
 262
 263acpi_status
 264acpi_ex_write_data_to_field(union acpi_operand_object *source_desc,
 265                            union acpi_operand_object *obj_desc,
 266                            union acpi_operand_object **result_desc)
 267{
 268        acpi_status status;
 269        u32 buffer_length;
 270        u32 data_length;
 271        void *buffer;
 272
 273        ACPI_FUNCTION_TRACE_PTR(ex_write_data_to_field, obj_desc);
 274
 275        /* Parameter validation */
 276
 277        if (!source_desc || !obj_desc) {
 278                return_ACPI_STATUS(AE_AML_NO_OPERAND);
 279        }
 280
 281        if (obj_desc->common.type == ACPI_TYPE_BUFFER_FIELD) {
 282                /*
 283                 * If the buffer_field arguments have not been previously evaluated,
 284                 * evaluate them now and save the results.
 285                 */
 286                if (!(obj_desc->common.flags & AOPOBJ_DATA_VALID)) {
 287                        status = acpi_ds_get_buffer_field_arguments(obj_desc);
 288                        if (ACPI_FAILURE(status)) {
 289                                return_ACPI_STATUS(status);
 290                        }
 291                }
 292        } else if ((obj_desc->common.type == ACPI_TYPE_LOCAL_REGION_FIELD) &&
 293                   (obj_desc->field.region_obj->region.space_id ==
 294                    ACPI_ADR_SPACE_GPIO)) {
 295
 296                /* General Purpose I/O */
 297
 298                status = acpi_ex_write_gpio(source_desc, obj_desc, result_desc);
 299                return_ACPI_STATUS(status);
 300        } else if ((obj_desc->common.type == ACPI_TYPE_LOCAL_REGION_FIELD) &&
 301                   (obj_desc->field.region_obj->region.space_id ==
 302                    ACPI_ADR_SPACE_SMBUS
 303                    || obj_desc->field.region_obj->region.space_id ==
 304                    ACPI_ADR_SPACE_GSBUS
 305                    || obj_desc->field.region_obj->region.space_id ==
 306                    ACPI_ADR_SPACE_IPMI
 307                    || obj_desc->field.region_obj->region.space_id ==
 308                    ACPI_ADR_SPACE_PLATFORM_RT)) {
 309
 310                /* SMBus, GSBus, IPMI serial */
 311
 312                status =
 313                    acpi_ex_write_serial_bus(source_desc, obj_desc,
 314                                             result_desc);
 315                return_ACPI_STATUS(status);
 316        } else if ((obj_desc->common.type == ACPI_TYPE_LOCAL_REGION_FIELD) &&
 317                   (obj_desc->field.region_obj->region.space_id ==
 318                    ACPI_ADR_SPACE_PLATFORM_COMM)) {
 319                /*
 320                 * According to the spec a write to the COMD field will invoke the
 321                 * region handler. Otherwise, write to the pcc_internal buffer. This
 322                 * implementation will use the offsets specified rather than the name
 323                 * of the field. This is considered safer because some firmware tools
 324                 * are known to obfiscate named objects.
 325                 */
 326                data_length =
 327                    (acpi_size)ACPI_ROUND_BITS_UP_TO_BYTES(obj_desc->field.
 328                                                           bit_length);
 329                memcpy(obj_desc->field.region_obj->field.internal_pcc_buffer +
 330                       obj_desc->field.base_byte_offset,
 331                       source_desc->buffer.pointer, data_length);
 332
 333                if ((obj_desc->field.region_obj->region.address ==
 334                     PCC_MASTER_SUBSPACE
 335                     && MASTER_SUBSPACE_COMMAND(obj_desc->field.
 336                                                base_byte_offset))
 337                    || GENERIC_SUBSPACE_COMMAND(obj_desc->field.
 338                                                base_byte_offset)) {
 339
 340                        /* Perform the write */
 341
 342                        ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,
 343                                          "PCC COMD field has been written. Invoking PCC handler now.\n"));
 344
 345                        status =
 346                            acpi_ex_access_region(obj_desc, 0,
 347                                                  (u64 *)obj_desc->field.
 348                                                  region_obj->field.
 349                                                  internal_pcc_buffer,
 350                                                  ACPI_WRITE);
 351                        return_ACPI_STATUS(status);
 352                }
 353                return (AE_OK);
 354        }
 355
 356        /* Get a pointer to the data to be written */
 357
 358        switch (source_desc->common.type) {
 359        case ACPI_TYPE_INTEGER:
 360
 361                buffer = &source_desc->integer.value;
 362                buffer_length = sizeof(source_desc->integer.value);
 363                break;
 364
 365        case ACPI_TYPE_BUFFER:
 366
 367                buffer = source_desc->buffer.pointer;
 368                buffer_length = source_desc->buffer.length;
 369                break;
 370
 371        case ACPI_TYPE_STRING:
 372
 373                buffer = source_desc->string.pointer;
 374                buffer_length = source_desc->string.length;
 375                break;
 376
 377        default:
 378                return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
 379        }
 380
 381        ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,
 382                          "FieldWrite [FROM]: Obj %p (%s:%X), Buf %p, ByteLen %X\n",
 383                          source_desc,
 384                          acpi_ut_get_type_name(source_desc->common.type),
 385                          source_desc->common.type, buffer, buffer_length));
 386
 387        ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,
 388                          "FieldWrite [TO]:   Obj %p (%s:%X), BitLen %X, BitOff %X, ByteOff %X\n",
 389                          obj_desc,
 390                          acpi_ut_get_type_name(obj_desc->common.type),
 391                          obj_desc->common.type,
 392                          obj_desc->common_field.bit_length,
 393                          obj_desc->common_field.start_field_bit_offset,
 394                          obj_desc->common_field.base_byte_offset));
 395
 396        /* Lock entire transaction if requested */
 397
 398        acpi_ex_acquire_global_lock(obj_desc->common_field.field_flags);
 399
 400        /* Write to the field */
 401
 402        status = acpi_ex_insert_into_field(obj_desc, buffer, buffer_length);
 403        acpi_ex_release_global_lock(obj_desc->common_field.field_flags);
 404        return_ACPI_STATUS(status);
 405}
 406