LCOV - code coverage report
Current view: top level - drivers/acpi/acpica - utpredef.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 12 27 44.4 %
Date: 2022-04-01 14:58:12 Functions: 2 3 66.7 %
Branches: 9 16 56.2 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
       2                 :            : /******************************************************************************
       3                 :            :  *
       4                 :            :  * Module Name: utpredef - support functions for predefined names
       5                 :            :  *
       6                 :            :  * Copyright (C) 2000 - 2020, Intel Corp.
       7                 :            :  *
       8                 :            :  *****************************************************************************/
       9                 :            : 
      10                 :            : #include <acpi/acpi.h>
      11                 :            : #include "accommon.h"
      12                 :            : #include "acpredef.h"
      13                 :            : 
      14                 :            : #define _COMPONENT          ACPI_UTILITIES
      15                 :            : ACPI_MODULE_NAME("utpredef")
      16                 :            : 
      17                 :            : /*
      18                 :            :  * Names for the types that can be returned by the predefined objects.
      19                 :            :  * Used for warning messages. Must be in the same order as the ACPI_RTYPEs
      20                 :            :  */
      21                 :            : static const char *ut_rtype_names[] = {
      22                 :            :         "/Integer",
      23                 :            :         "/String",
      24                 :            :         "/Buffer",
      25                 :            :         "/Package",
      26                 :            :         "/Reference",
      27                 :            : };
      28                 :            : 
      29                 :            : /*******************************************************************************
      30                 :            :  *
      31                 :            :  * FUNCTION:    acpi_ut_get_next_predefined_method
      32                 :            :  *
      33                 :            :  * PARAMETERS:  this_name           - Entry in the predefined method/name table
      34                 :            :  *
      35                 :            :  * RETURN:      Pointer to next entry in predefined table.
      36                 :            :  *
      37                 :            :  * DESCRIPTION: Get the next entry in the predefine method table. Handles the
      38                 :            :  *              cases where a package info entry follows a method name that
      39                 :            :  *              returns a package.
      40                 :            :  *
      41                 :            :  ******************************************************************************/
      42                 :            : 
      43                 :     130689 : const union acpi_predefined_info *acpi_ut_get_next_predefined_method(const union
      44                 :            :                                                                      acpi_predefined_info
      45                 :            :                                                                      *this_name)
      46                 :            : {
      47                 :            : 
      48                 :            :         /*
      49                 :            :          * Skip next entry in the table if this name returns a Package
      50                 :            :          * (next entry contains the package info)
      51                 :            :          */
      52   [ +  +  +  + ]:     130689 :         if ((this_name->info.expected_btypes & ACPI_RTYPE_PACKAGE) &&
      53                 :            :             (this_name->info.expected_btypes != ACPI_RTYPE_ALL)) {
      54                 :      37992 :                 this_name++;
      55                 :            :         }
      56                 :            : 
      57                 :     130689 :         this_name++;
      58                 :     130689 :         return (this_name);
      59                 :            : }
      60                 :            : 
      61                 :            : /*******************************************************************************
      62                 :            :  *
      63                 :            :  * FUNCTION:    acpi_ut_match_predefined_method
      64                 :            :  *
      65                 :            :  * PARAMETERS:  name                - Name to find
      66                 :            :  *
      67                 :            :  * RETURN:      Pointer to entry in predefined table. NULL indicates not found.
      68                 :            :  *
      69                 :            :  * DESCRIPTION: Check an object name against the predefined object list.
      70                 :            :  *
      71                 :            :  ******************************************************************************/
      72                 :            : 
      73                 :       1839 : const union acpi_predefined_info *acpi_ut_match_predefined_method(char *name)
      74                 :            : {
      75                 :       1839 :         const union acpi_predefined_info *this_name;
      76                 :            : 
      77                 :            :         /* Quick check for a predefined name, first character must be underscore */
      78                 :            : 
      79         [ +  + ]:       1839 :         if (name[0] != '_') {
      80                 :            :                 return (NULL);
      81                 :            :         }
      82                 :            : 
      83                 :            :         /* Search info table for a predefined method/object name */
      84                 :            : 
      85                 :            :         this_name = acpi_gbl_predefined_methods;
      86         [ +  - ]:     132519 :         while (this_name->info.name[0]) {
      87         [ +  + ]:     132519 :                 if (ACPI_COMPARE_NAMESEG(name, this_name->info.name)) {
      88                 :       1830 :                         return (this_name);
      89                 :            :                 }
      90                 :            : 
      91                 :     130689 :                 this_name = acpi_ut_get_next_predefined_method(this_name);
      92                 :            :         }
      93                 :            : 
      94                 :            :         return (NULL);          /* Not found */
      95                 :            : }
      96                 :            : 
      97                 :            : /*******************************************************************************
      98                 :            :  *
      99                 :            :  * FUNCTION:    acpi_ut_get_expected_return_types
     100                 :            :  *
     101                 :            :  * PARAMETERS:  buffer              - Where the formatted string is returned
     102                 :            :  *              expected_Btypes     - Bitfield of expected data types
     103                 :            :  *
     104                 :            :  * RETURN:      Formatted string in Buffer.
     105                 :            :  *
     106                 :            :  * DESCRIPTION: Format the expected object types into a printable string.
     107                 :            :  *
     108                 :            :  ******************************************************************************/
     109                 :            : 
     110                 :          0 : void acpi_ut_get_expected_return_types(char *buffer, u32 expected_btypes)
     111                 :            : {
     112                 :          0 :         u32 this_rtype;
     113                 :          0 :         u32 i;
     114                 :          0 :         u32 j;
     115                 :            : 
     116         [ #  # ]:          0 :         if (!expected_btypes) {
     117                 :          0 :                 strcpy(buffer, "NONE");
     118                 :          0 :                 return;
     119                 :            :         }
     120                 :            : 
     121                 :          0 :         j = 1;
     122                 :          0 :         buffer[0] = 0;
     123                 :          0 :         this_rtype = ACPI_RTYPE_INTEGER;
     124                 :            : 
     125         [ #  # ]:          0 :         for (i = 0; i < ACPI_NUM_RTYPES; i++) {
     126                 :            : 
     127                 :            :                 /* If one of the expected types, concatenate the name of this type */
     128                 :            : 
     129         [ #  # ]:          0 :                 if (expected_btypes & this_rtype) {
     130                 :          0 :                         strcat(buffer, &ut_rtype_names[i][j]);
     131                 :          0 :                         j = 0;  /* Use name separator from now on */
     132                 :            :                 }
     133                 :            : 
     134                 :          0 :                 this_rtype <<= 1; /* Next Rtype */
     135                 :            :         }
     136                 :            : }
     137                 :            : 
     138                 :            : /*******************************************************************************
     139                 :            :  *
     140                 :            :  * The remaining functions are used by iASL and acpi_help only
     141                 :            :  *
     142                 :            :  ******************************************************************************/
     143                 :            : 
     144                 :            : #if (defined ACPI_ASL_COMPILER || defined ACPI_HELP_APP)
     145                 :            : 
     146                 :            : /* Local prototypes */
     147                 :            : 
     148                 :            : static u32 acpi_ut_get_argument_types(char *buffer, u16 argument_types);
     149                 :            : 
     150                 :            : /* Types that can be returned externally by a predefined name */
     151                 :            : 
     152                 :            : static const char *ut_external_type_names[] =   /* Indexed by ACPI_TYPE_* */
     153                 :            : {
     154                 :            :         ", UNSUPPORTED-TYPE",
     155                 :            :         ", Integer",
     156                 :            :         ", String",
     157                 :            :         ", Buffer",
     158                 :            :         ", Package"
     159                 :            : };
     160                 :            : 
     161                 :            : /* Bit widths for resource descriptor predefined names */
     162                 :            : 
     163                 :            : static const char *ut_resource_type_names[] = {
     164                 :            :         "/1",
     165                 :            :         "/2",
     166                 :            :         "/3",
     167                 :            :         "/8",
     168                 :            :         "/16",
     169                 :            :         "/32",
     170                 :            :         "/64",
     171                 :            :         "/variable",
     172                 :            : };
     173                 :            : 
     174                 :            : /*******************************************************************************
     175                 :            :  *
     176                 :            :  * FUNCTION:    acpi_ut_match_resource_name
     177                 :            :  *
     178                 :            :  * PARAMETERS:  name                - Name to find
     179                 :            :  *
     180                 :            :  * RETURN:      Pointer to entry in the resource table. NULL indicates not
     181                 :            :  *              found.
     182                 :            :  *
     183                 :            :  * DESCRIPTION: Check an object name against the predefined resource
     184                 :            :  *              descriptor object list.
     185                 :            :  *
     186                 :            :  ******************************************************************************/
     187                 :            : 
     188                 :            : const union acpi_predefined_info *acpi_ut_match_resource_name(char *name)
     189                 :            : {
     190                 :            :         const union acpi_predefined_info *this_name;
     191                 :            : 
     192                 :            :         /*
     193                 :            :          * Quick check for a predefined name, first character must
     194                 :            :          * be underscore
     195                 :            :          */
     196                 :            :         if (name[0] != '_') {
     197                 :            :                 return (NULL);
     198                 :            :         }
     199                 :            : 
     200                 :            :         /* Search info table for a predefined method/object name */
     201                 :            : 
     202                 :            :         this_name = acpi_gbl_resource_names;
     203                 :            :         while (this_name->info.name[0]) {
     204                 :            :                 if (ACPI_COMPARE_NAMESEG(name, this_name->info.name)) {
     205                 :            :                         return (this_name);
     206                 :            :                 }
     207                 :            : 
     208                 :            :                 this_name++;
     209                 :            :         }
     210                 :            : 
     211                 :            :         return (NULL);          /* Not found */
     212                 :            : }
     213                 :            : 
     214                 :            : /*******************************************************************************
     215                 :            :  *
     216                 :            :  * FUNCTION:    acpi_ut_display_predefined_method
     217                 :            :  *
     218                 :            :  * PARAMETERS:  buffer              - Scratch buffer for this function
     219                 :            :  *              this_name           - Entry in the predefined method/name table
     220                 :            :  *              multi_line          - TRUE if output should be on >1 line
     221                 :            :  *
     222                 :            :  * RETURN:      None
     223                 :            :  *
     224                 :            :  * DESCRIPTION: Display information about a predefined method. Number and
     225                 :            :  *              type of the input arguments, and expected type(s) for the
     226                 :            :  *              return value, if any.
     227                 :            :  *
     228                 :            :  ******************************************************************************/
     229                 :            : 
     230                 :            : void
     231                 :            : acpi_ut_display_predefined_method(char *buffer,
     232                 :            :                                   const union acpi_predefined_info *this_name,
     233                 :            :                                   u8 multi_line)
     234                 :            : {
     235                 :            :         u32 arg_count;
     236                 :            : 
     237                 :            :         /*
     238                 :            :          * Get the argument count and the string buffer
     239                 :            :          * containing all argument types
     240                 :            :          */
     241                 :            :         arg_count = acpi_ut_get_argument_types(buffer,
     242                 :            :                                                this_name->info.argument_list);
     243                 :            : 
     244                 :            :         if (multi_line) {
     245                 :            :                 printf("      ");
     246                 :            :         }
     247                 :            : 
     248                 :            :         printf("%4.4s    Requires %s%u argument%s",
     249                 :            :                this_name->info.name,
     250                 :            :                (this_name->info.argument_list & ARG_COUNT_IS_MINIMUM) ?
     251                 :            :                "(at least) " : "", arg_count, arg_count != 1 ? "s" : "");
     252                 :            : 
     253                 :            :         /* Display the types for any arguments */
     254                 :            : 
     255                 :            :         if (arg_count > 0) {
     256                 :            :                 printf(" (%s)", buffer);
     257                 :            :         }
     258                 :            : 
     259                 :            :         if (multi_line) {
     260                 :            :                 printf("\n    ");
     261                 :            :         }
     262                 :            : 
     263                 :            :         /* Get the return value type(s) allowed */
     264                 :            : 
     265                 :            :         if (this_name->info.expected_btypes) {
     266                 :            :                 acpi_ut_get_expected_return_types(buffer,
     267                 :            :                                                   this_name->info.
     268                 :            :                                                   expected_btypes);
     269                 :            :                 printf("  Return value types: %s\n", buffer);
     270                 :            :         } else {
     271                 :            :                 printf("  No return value\n");
     272                 :            :         }
     273                 :            : }
     274                 :            : 
     275                 :            : /*******************************************************************************
     276                 :            :  *
     277                 :            :  * FUNCTION:    acpi_ut_get_argument_types
     278                 :            :  *
     279                 :            :  * PARAMETERS:  buffer              - Where to return the formatted types
     280                 :            :  *              argument_types      - Types field for this method
     281                 :            :  *
     282                 :            :  * RETURN:      count - the number of arguments required for this method
     283                 :            :  *
     284                 :            :  * DESCRIPTION: Format the required data types for this method (Integer,
     285                 :            :  *              String, Buffer, or Package) and return the required argument
     286                 :            :  *              count.
     287                 :            :  *
     288                 :            :  ******************************************************************************/
     289                 :            : 
     290                 :            : static u32 acpi_ut_get_argument_types(char *buffer, u16 argument_types)
     291                 :            : {
     292                 :            :         u16 this_argument_type;
     293                 :            :         u16 sub_index;
     294                 :            :         u16 arg_count;
     295                 :            :         u32 i;
     296                 :            : 
     297                 :            :         *buffer = 0;
     298                 :            :         sub_index = 2;
     299                 :            : 
     300                 :            :         /* First field in the types list is the count of args to follow */
     301                 :            : 
     302                 :            :         arg_count = METHOD_GET_ARG_COUNT(argument_types);
     303                 :            :         if (arg_count > METHOD_PREDEF_ARGS_MAX) {
     304                 :            :                 printf("**** Invalid argument count (%u) "
     305                 :            :                        "in predefined info structure\n", arg_count);
     306                 :            :                 return (arg_count);
     307                 :            :         }
     308                 :            : 
     309                 :            :         /* Get each argument from the list, convert to ascii, store to buffer */
     310                 :            : 
     311                 :            :         for (i = 0; i < arg_count; i++) {
     312                 :            :                 this_argument_type = METHOD_GET_NEXT_TYPE(argument_types);
     313                 :            : 
     314                 :            :                 if (!this_argument_type
     315                 :            :                     || (this_argument_type > METHOD_MAX_ARG_TYPE)) {
     316                 :            :                         printf("**** Invalid argument type (%u) "
     317                 :            :                                "in predefined info structure\n",
     318                 :            :                                this_argument_type);
     319                 :            :                         return (arg_count);
     320                 :            :                 }
     321                 :            : 
     322                 :            :                 strcat(buffer,
     323                 :            :                        ut_external_type_names[this_argument_type] + sub_index);
     324                 :            :                 sub_index = 0;
     325                 :            :         }
     326                 :            : 
     327                 :            :         return (arg_count);
     328                 :            : }
     329                 :            : 
     330                 :            : /*******************************************************************************
     331                 :            :  *
     332                 :            :  * FUNCTION:    acpi_ut_get_resource_bit_width
     333                 :            :  *
     334                 :            :  * PARAMETERS:  buffer              - Where the formatted string is returned
     335                 :            :  *              types               - Bitfield of expected data types
     336                 :            :  *
     337                 :            :  * RETURN:      Count of return types. Formatted string in Buffer.
     338                 :            :  *
     339                 :            :  * DESCRIPTION: Format the resource bit widths into a printable string.
     340                 :            :  *
     341                 :            :  ******************************************************************************/
     342                 :            : 
     343                 :            : u32 acpi_ut_get_resource_bit_width(char *buffer, u16 types)
     344                 :            : {
     345                 :            :         u32 i;
     346                 :            :         u16 sub_index;
     347                 :            :         u32 found;
     348                 :            : 
     349                 :            :         *buffer = 0;
     350                 :            :         sub_index = 1;
     351                 :            :         found = 0;
     352                 :            : 
     353                 :            :         for (i = 0; i < NUM_RESOURCE_WIDTHS; i++) {
     354                 :            :                 if (types & 1) {
     355                 :            :                         strcat(buffer, &(ut_resource_type_names[i][sub_index]));
     356                 :            :                         sub_index = 0;
     357                 :            :                         found++;
     358                 :            :                 }
     359                 :            : 
     360                 :            :                 types >>= 1;
     361                 :            :         }
     362                 :            : 
     363                 :            :         return (found);
     364                 :            : }
     365                 :            : #endif

Generated by: LCOV version 1.14