drivers/acpi/acpica/exmisc.c

   1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
   2 /******************************************************************************
   3  *
   4  * Module Name: exmisc - ACPI AML (p-code) execution - specific opcodes
   5  *
   6  * Copyright (C) 2000 - 2020, Intel Corp.
   7  *
   8  *****************************************************************************/
   9
  10 #include <acpi/acpi.h>
  11 #include "accommon.h"
  12 #include "acinterp.h"
  13 #include "amlcode.h"
  14
  15 #define _COMPONENT          ACPI_EXECUTER
  16 ACPI_MODULE_NAME("exmisc")
  17
  18 /*******************************************************************************
  19  *
  20  * FUNCTION:    acpi_ex_get_object_reference
  21  *
  22  * PARAMETERS:  obj_desc            - Create a reference to this object
  23  *              return_desc         - Where to store the reference
  24  *              walk_state          - Current state
  25  *
  26  * RETURN:      Status
  27  *
  28  * DESCRIPTION: Obtain and return a "reference" to the target object
  29  *              Common code for the ref_of_op and the cond_ref_of_op.
  30  *
  31  ******************************************************************************/
  32 acpi_status
  33 acpi_ex_get_object_reference(union acpi_operand_object *obj_desc,
  34                              union acpi_operand_object **return_desc,
  35                              struct acpi_walk_state *walk_state)
  36 {
  37         union acpi_operand_object *reference_obj;
  38         union acpi_operand_object *referenced_obj;
  39
  40         ACPI_FUNCTION_TRACE_PTR(ex_get_object_reference, obj_desc);
  41
  42         *return_desc = NULL;
  43
  44         switch (ACPI_GET_DESCRIPTOR_TYPE(obj_desc)) {
  45         case ACPI_DESC_TYPE_OPERAND:
  46
  47                 if (obj_desc->common.type != ACPI_TYPE_LOCAL_REFERENCE) {
  48                         return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
  49                 }
  50
  51                 /*
  52                  * Must be a reference to a Local or Arg
  53                  */
  54                 switch (obj_desc->reference.class) {
  55                 case ACPI_REFCLASS_LOCAL:
  56                 case ACPI_REFCLASS_ARG:
  57                 case ACPI_REFCLASS_DEBUG:
  58
  59                         /* The referenced object is the pseudo-node for the local/arg */
  60
  61                         referenced_obj = obj_desc->reference.object;
  62                         break;
  63
  64                 default:
  65
  66                         ACPI_ERROR((AE_INFO, "Invalid Reference Class 0x%2.2X",
  67                                     obj_desc->reference.class));
  68                         return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
  69                 }
  70                 break;
  71
  72         case ACPI_DESC_TYPE_NAMED:
  73                 /*
  74                  * A named reference that has already been resolved to a Node
  75                  */
  76                 referenced_obj = obj_desc;
  77                 break;
  78
  79         default:
  80
  81                 ACPI_ERROR((AE_INFO, "Invalid descriptor type 0x%X",
  82                             ACPI_GET_DESCRIPTOR_TYPE(obj_desc)));
  83                 return_ACPI_STATUS(AE_TYPE);
  84         }
  85
  86         /* Create a new reference object */
  87
  88         reference_obj =
  89             acpi_ut_create_internal_object(ACPI_TYPE_LOCAL_REFERENCE);
  90         if (!reference_obj) {
  91                 return_ACPI_STATUS(AE_NO_MEMORY);
  92         }
  93
  94         reference_obj->reference.class = ACPI_REFCLASS_REFOF;
  95         reference_obj->reference.object = referenced_obj;
  96         *return_desc = reference_obj;
  97
  98         ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
  99                           "Object %p Type [%s], returning Reference %p\n",
 100                           obj_desc, acpi_ut_get_object_type_name(obj_desc),
 101                           *return_desc));
 102
 103         return_ACPI_STATUS(AE_OK);
 104 }
 105
 106 /*******************************************************************************
 107  *
 108  * FUNCTION:    acpi_ex_do_math_op
 109  *
 110  * PARAMETERS:  opcode              - AML opcode
 111  *              integer0            - Integer operand #0
 112  *              integer1            - Integer operand #1
 113  *
 114  * RETURN:      Integer result of the operation
 115  *
 116  * DESCRIPTION: Execute a math AML opcode. The purpose of having all of the
 117  *              math functions here is to prevent a lot of pointer dereferencing
 118  *              to obtain the operands.
 119  *
 120  ******************************************************************************/
 121
 122 u64 acpi_ex_do_math_op(u16 opcode, u64 integer0, u64 integer1)
 123 {
 124
 125         ACPI_FUNCTION_ENTRY();
 126
 127         switch (opcode) {
 128         case AML_ADD_OP:        /* Add (Integer0, Integer1, Result) */
 129
 130                 return (integer0 + integer1);
 131
 132         case AML_BIT_AND_OP:    /* And (Integer0, Integer1, Result) */
 133
 134                 return (integer0 & integer1);
 135
 136         case AML_BIT_NAND_OP:   /* NAnd (Integer0, Integer1, Result) */
 137
 138                 return (~(integer0 & integer1));
 139
 140         case AML_BIT_OR_OP:     /* Or (Integer0, Integer1, Result) */
 141
 142                 return (integer0 | integer1);
 143
 144         case AML_BIT_NOR_OP:    /* NOr (Integer0, Integer1, Result) */
 145
 146                 return (~(integer0 | integer1));
 147
 148         case AML_BIT_XOR_OP:    /* XOr (Integer0, Integer1, Result) */
 149
 150                 return (integer0 ^ integer1);
 151
 152         case AML_MULTIPLY_OP:   /* Multiply (Integer0, Integer1, Result) */
 153
 154                 return (integer0 * integer1);
 155
 156         case AML_SHIFT_LEFT_OP: /* shift_left (Operand, shift_count, Result) */
 157
 158                 /*
 159                  * We need to check if the shiftcount is larger than the integer bit
 160                  * width since the behavior of this is not well-defined in the C language.
 161                  */
 162                 if (integer1 >= acpi_gbl_integer_bit_width) {
 163                         return (0);
 164                 }
 165                 return (integer0 << integer1);
 166
 167         case AML_SHIFT_RIGHT_OP:        /* shift_right (Operand, shift_count, Result) */
 168
 169                 /*
 170                  * We need to check if the shiftcount is larger than the integer bit
 171                  * width since the behavior of this is not well-defined in the C language.
 172                  */
 173                 if (integer1 >= acpi_gbl_integer_bit_width) {
 174                         return (0);
 175                 }
 176                 return (integer0 >> integer1);
 177
 178         case AML_SUBTRACT_OP:   /* Subtract (Integer0, Integer1, Result) */
 179
 180                 return (integer0 - integer1);
 181
 182         default:
 183
 184                 return (0);
 185         }
 186 }
 187
 188 /*******************************************************************************
 189  *
 190  * FUNCTION:    acpi_ex_do_logical_numeric_op
 191  *
 192  * PARAMETERS:  opcode              - AML opcode
 193  *              integer0            - Integer operand #0
 194  *              integer1            - Integer operand #1
 195  *              logical_result      - TRUE/FALSE result of the operation
 196  *
 197  * RETURN:      Status
 198  *
 199  * DESCRIPTION: Execute a logical "Numeric" AML opcode. For these Numeric
 200  *              operators (LAnd and LOr), both operands must be integers.
 201  *
 202  *              Note: cleanest machine code seems to be produced by the code
 203  *              below, rather than using statements of the form:
 204  *                  Result = (Integer0 && Integer1);
 205  *
 206  ******************************************************************************/
 207
 208 acpi_status
 209 acpi_ex_do_logical_numeric_op(u16 opcode,
 210                               u64 integer0, u64 integer1, u8 *logical_result)
 211 {
 212         acpi_status status = AE_OK;
 213         u8 local_result = FALSE;
 214
 215         ACPI_FUNCTION_TRACE(ex_do_logical_numeric_op);
 216
 217         switch (opcode) {
 218         case AML_LOGICAL_AND_OP:        /* LAnd (Integer0, Integer1) */
 219
 220                 if (integer0 && integer1) {
 221                         local_result = TRUE;
 222                 }
 223                 break;
 224
 225         case AML_LOGICAL_OR_OP: /* LOr (Integer0, Integer1) */
 226
 227                 if (integer0 || integer1) {
 228                         local_result = TRUE;
 229                 }
 230                 break;
 231
 232         default:
 233
 234                 ACPI_ERROR((AE_INFO,
 235                             "Invalid numeric logical opcode: %X", opcode));
 236                 status = AE_AML_INTERNAL;
 237                 break;
 238         }
 239
 240         /* Return the logical result and status */
 241
 242         *logical_result = local_result;
 243         return_ACPI_STATUS(status);
 244 }
 245
 246 /*******************************************************************************
 247  *
 248  * FUNCTION:    acpi_ex_do_logical_op
 249  *
 250  * PARAMETERS:  opcode              - AML opcode
 251  *              operand0            - operand #0
 252  *              operand1            - operand #1
 253  *              logical_result      - TRUE/FALSE result of the operation
 254  *
 255  * RETURN:      Status
 256  *
 257  * DESCRIPTION: Execute a logical AML opcode. The purpose of having all of the
 258  *              functions here is to prevent a lot of pointer dereferencing
 259  *              to obtain the operands and to simplify the generation of the
 260  *              logical value. For the Numeric operators (LAnd and LOr), both
 261  *              operands must be integers. For the other logical operators,
 262  *              operands can be any combination of Integer/String/Buffer. The
 263  *              first operand determines the type to which the second operand
 264  *              will be converted.
 265  *
 266  *              Note: cleanest machine code seems to be produced by the code
 267  *              below, rather than using statements of the form:
 268  *                  Result = (Operand0 == Operand1);
 269  *
 270  ******************************************************************************/
 271
 272 acpi_status
 273 acpi_ex_do_logical_op(u16 opcode,
 274                       union acpi_operand_object *operand0,
 275                       union acpi_operand_object *operand1, u8 * logical_result)
 276 {
 277         union acpi_operand_object *local_operand1 = operand1;
 278         u64 integer0;
 279         u64 integer1;
 280         u32 length0;
 281         u32 length1;
 282         acpi_status status = AE_OK;
 283         u8 local_result = FALSE;
 284         int compare;
 285
 286         ACPI_FUNCTION_TRACE(ex_do_logical_op);
 287
 288         /*
 289          * Convert the second operand if necessary. The first operand
 290          * determines the type of the second operand, (See the Data Types
 291          * section of the ACPI 3.0+ specification.)  Both object types are
 292          * guaranteed to be either Integer/String/Buffer by the operand
 293          * resolution mechanism.
 294          */
 295         switch (operand0->common.type) {
 296         case ACPI_TYPE_INTEGER:
 297
 298                 status = acpi_ex_convert_to_integer(operand1, &local_operand1,
 299                                                     ACPI_IMPLICIT_CONVERSION);
 300                 break;
 301
 302         case ACPI_TYPE_STRING:
 303
 304                 status =
 305                     acpi_ex_convert_to_string(operand1, &local_operand1,
 306                                               ACPI_IMPLICIT_CONVERT_HEX);
 307                 break;
 308
 309         case ACPI_TYPE_BUFFER:
 310
 311                 status = acpi_ex_convert_to_buffer(operand1, &local_operand1);
 312                 break;
 313
 314         default:
 315
 316                 ACPI_ERROR((AE_INFO,
 317                             "Invalid object type for logical operator: %X",
 318                             operand0->common.type));
 319                 status = AE_AML_INTERNAL;
 320                 break;
 321         }
 322
 323         if (ACPI_FAILURE(status)) {
 324                 goto cleanup;
 325         }
 326
 327         /*
 328          * Two cases: 1) Both Integers, 2) Both Strings or Buffers
 329          */
 330         if (operand0->common.type == ACPI_TYPE_INTEGER) {
 331                 /*
 332                  * 1) Both operands are of type integer
 333                  *    Note: local_operand1 may have changed above
 334                  */
 335                 integer0 = operand0->integer.value;
 336                 integer1 = local_operand1->integer.value;
 337
 338                 switch (opcode) {
 339                 case AML_LOGICAL_EQUAL_OP:      /* LEqual (Operand0, Operand1) */
 340
 341                         if (integer0 == integer1) {
 342                                 local_result = TRUE;
 343                         }
 344                         break;
 345
 346                 case AML_LOGICAL_GREATER_OP:    /* LGreater (Operand0, Operand1) */
 347
 348                         if (integer0 > integer1) {
 349                                 local_result = TRUE;
 350                         }
 351                         break;
 352
 353                 case AML_LOGICAL_LESS_OP:       /* LLess (Operand0, Operand1) */
 354
 355                         if (integer0 < integer1) {
 356                                 local_result = TRUE;
 357                         }
 358                         break;
 359
 360                 default:
 361
 362                         ACPI_ERROR((AE_INFO,
 363                                     "Invalid comparison opcode: %X", opcode));
 364                         status = AE_AML_INTERNAL;
 365                         break;
 366                 }
 367         } else {
 368                 /*
 369                  * 2) Both operands are Strings or both are Buffers
 370                  *    Note: Code below takes advantage of common Buffer/String
 371                  *          object fields. local_operand1 may have changed above. Use
 372                  *          memcmp to handle nulls in buffers.
 373                  */
 374                 length0 = operand0->buffer.length;
 375                 length1 = local_operand1->buffer.length;
 376
 377                 /* Lexicographic compare: compare the data bytes */
 378
 379                 compare = memcmp(operand0->buffer.pointer,
 380                                  local_operand1->buffer.pointer,
 381                                  (length0 > length1) ? length1 : length0);
 382
 383                 switch (opcode) {
 384                 case AML_LOGICAL_EQUAL_OP:      /* LEqual (Operand0, Operand1) */
 385
 386                         /* Length and all bytes must be equal */
 387
 388                         if ((length0 == length1) && (compare == 0)) {
 389
 390                                 /* Length and all bytes match ==> TRUE */
 391
 392                                 local_result = TRUE;
 393                         }
 394                         break;
 395
 396                 case AML_LOGICAL_GREATER_OP:    /* LGreater (Operand0, Operand1) */
 397
 398                         if (compare > 0) {
 399                                 local_result = TRUE;
 400                                 goto cleanup;   /* TRUE */
 401                         }
 402                         if (compare < 0) {
 403                                 goto cleanup;   /* FALSE */
 404                         }
 405
 406                         /* Bytes match (to shortest length), compare lengths */
 407
 408                         if (length0 > length1) {
 409                                 local_result = TRUE;
 410                         }
 411                         break;
 412
 413                 case AML_LOGICAL_LESS_OP:       /* LLess (Operand0, Operand1) */
 414
 415                         if (compare > 0) {
 416                                 goto cleanup;   /* FALSE */
 417                         }
 418                         if (compare < 0) {
 419                                 local_result = TRUE;
 420                                 goto cleanup;   /* TRUE */
 421                         }
 422
 423                         /* Bytes match (to shortest length), compare lengths */
 424
 425                         if (length0 < length1) {
 426                                 local_result = TRUE;
 427                         }
 428                         break;
 429
 430                 default:
 431
 432                         ACPI_ERROR((AE_INFO,
 433                                     "Invalid comparison opcode: %X", opcode));
 434                         status = AE_AML_INTERNAL;
 435                         break;
 436                 }
 437         }
 438
 439 cleanup:
 440
 441         /* New object was created if implicit conversion performed - delete */
 442
 443         if (local_operand1 != operand1) {
 444                 acpi_ut_remove_reference(local_operand1);
 445         }
 446
 447         /* Return the logical result and status */
 448
 449         *logical_result = local_result;
 450         return_ACPI_STATUS(status);
 451 }