util/amdfwtool/data_parse.c

   1 /* SPDX-License-Identifier: GPL-2.0-only */
   2
   3 #include <stdio.h>
   4 #include <regex.h>
   5 #include <string.h>
   6 #include <stdlib.h>
   7 #include <stdint.h>
   8 #include <assert.h>
   9
  10 #include "amdfwtool.h"
  11
  12 /* TODO: a empty line does not matched. */
  13 static const char blank_or_comment_regex[] =
  14         /* a blank line */
  15         "(^[[:space:]]*$)"
  16         "|"     /* or ... */
  17         /* a line consisting of: optional whitespace followed by */
  18         "(^[[:space:]]*"
  19         /* a '#' character and optionally, additional characters */
  20         "#.*$)";
  21 static regex_t blank_or_comment_expr;
  22
  23 static const char entries_line_regex[] =
  24         /* optional whitespace */
  25         "^[[:space:]]*"
  26         /* followed by a chunk of nonwhitespace for macro field */
  27         "([^[:space:]]+)"
  28         /* followed by one or more whitespace characters */
  29         "[[:space:]]+"
  30         /* followed by a chunk of nonwhitespace for filename field */
  31         "([^[:space:]]+)"
  32         /* followed by optional whitespace */
  33         "[[:space:]]*$";
  34 static regex_t entries_line_expr;
  35
  36 static const char entries_lvl_line_regex[] =
  37         /* optional whitespace */
  38         "^[[:space:]]*"
  39         /* followed by a chunk of nonwhitespace for macro field */
  40         "([^[:space:]]+)"
  41         /* followed by one or more whitespace characters */
  42         "[[:space:]]+"
  43         /* followed by a chunk of nonwhitespace for filename field */
  44         "([^[:space:]]+)"
  45         /* followed by one or more whitespace characters */
  46         "[[:space:]]+"
  47         /* followed by a chunk of nonwhitespace for level field
  48            1st char L: Indicator of field "level"
  49            2nd char:
  50               Directory level to be dropped in.
  51               1: Level 1
  52               2: Level 2
  53               b: Level both 1&2
  54               x: use default value hardcoded in table
  55            3rd char:
  56               For A/B recovery. Defined same as 2nd char.
  57
  58            Examples:
  59               L2: Level 2 for normal mode
  60               L12: Level 1 for normal mode, level 2 for A/B mode
  61               Lx1: Use default value for normal mode, level 1 for A/B mode
  62          */
  63         "([Ll][12bxBX]{1,2})"
  64         /* followed by optional whitespace */
  65         "[[:space:]]*$";
  66 static regex_t entries_lvl_line_expr;
  67
  68 void compile_reg_expr(int cflags, const char *expr, regex_t *reg)
  69 {
  70         static const size_t ERROR_BUF_SIZE = 256;
  71         char error_msg[ERROR_BUF_SIZE];
  72         int result;
  73
  74         result = regcomp(reg, expr, cflags);
  75         if (result != 0) {
  76                 regerror(result, reg, error_msg, ERROR_BUF_SIZE);
  77                 fprintf(stderr, "%s\n", error_msg);
  78         }
  79 }
  80
  81 #define SET_LEVEL(tableptr, l, TABLE, ab)     \
  82         do {                                             \
  83                 switch ((l)) {                           \
  84                 case '1':                                \
  85                         (tableptr)->level = ab ? TABLE##_LVL1_AB : TABLE##_LVL1; \
  86                         break;                           \
  87                 case '2':                                \
  88                         (tableptr)->level = ab ? TABLE##_LVL2_AB : TABLE##_LVL2; \
  89                         break;                           \
  90                 case 'b':                                \
  91                 case 'B':                                \
  92                         (tableptr)->level = ab ? TABLE##_BOTH_AB : TABLE##_BOTH; \
  93                         break;                           \
  94                 default:                                 \
  95                         /* use default value */          \
  96                         break;                           \
  97                 }                                        \
  98         } while (0)
  99
 100 extern amd_fw_entry amd_psp_fw_table[];
 101 extern amd_bios_entry amd_bios_table[];
 102
 103 static uint8_t find_register_fw_filename_psp_dir(char *fw_name, char *filename,
 104                 char level_to_set, amd_cb_config *cb_config)
 105 {
 106         amd_fw_type fw_type = AMD_FW_INVALID;
 107         amd_fw_entry *psp_tableptr;
 108         uint8_t subprog;
 109
 110         if (strcmp(fw_name, "PSPBTLDR_WL_FILE") == 0) {
 111                 if (cb_config->have_whitelist) {
 112                         fw_type = AMD_FW_PSP_BOOTLOADER_AB;
 113                         subprog = 0;
 114                 } else {
 115                         fw_type = AMD_FW_SKIP;
 116                 }
 117         } else if (strcmp(fw_name, "PSPBTLDR_AB_STAGE1_FILE") == 0) {
 118                 if (cb_config->recovery_ab) {
 119                         fw_type = AMD_FW_PSP_BOOTLOADER;
 120                         subprog = 0;
 121                 } else {
 122                         fw_type = AMD_FW_SKIP;
 123                 }
 124         } else if (strcmp(fw_name, "PSPBTLDR_FILE") == 0) {
 125                 if (!cb_config->recovery_ab) {
 126                         fw_type = AMD_FW_PSP_BOOTLOADER;
 127                         subprog = 0;
 128                 } else {
 129                         fw_type = AMD_FW_SKIP;
 130                 }
 131         } else if (strcmp(fw_name, "AMD_PUBKEY_FILE") == 0) {
 132                 fw_type = AMD_FW_PSP_PUBKEY;
 133                 subprog = 0;
 134         } else if (strcmp(fw_name, "PSPRCVR_FILE") == 0) {
 135                 fw_type = AMD_FW_PSP_RECOVERY;
 136                 subprog = 0;
 137         } else if (strcmp(fw_name, "PUBSIGNEDKEY_FILE") == 0) {
 138                 fw_type = AMD_FW_PSP_RTM_PUBKEY;
 139                 subprog = 0;
 140         } else if (strcmp(fw_name, "PSPNVRAM_FILE") == 0) {
 141                 fw_type = AMD_FW_PSP_NVRAM;
 142                 subprog = 0;
 143         } else if (strcmp(fw_name, "SMUSCS_FILE") == 0) {
 144                 fw_type = AMD_FW_PSP_SMUSCS;
 145                 subprog = 0;
 146         } else if (strcmp(fw_name, "PSPTRUSTLETS_FILE") == 0) {
 147                 fw_type = AMD_FW_PSP_TRUSTLETS;
 148                 subprog = 0;
 149         } else if (strcmp(fw_name, "PSPSECUREDEBUG_FILE") == 0) {
 150                 fw_type = AMD_FW_PSP_SECURED_DEBUG;
 151                 subprog = 0;
 152         } else if (strcmp(fw_name, "PSP_SMUFW1_SUB0_FILE") == 0) {
 153                 fw_type = AMD_FW_PSP_SMU_FIRMWARE;
 154                 subprog = 0;
 155         } else if (strcmp(fw_name, "PSP_HW_IPCFG_FILE") == 0) {
 156                 fw_type = AMD_HW_IPCFG;
 157                 subprog = 0;
 158         } else if (strcmp(fw_name, "PSP_SMUFW1_SUB1_FILE") == 0) {
 159                 fw_type = AMD_FW_PSP_SMU_FIRMWARE;
 160                 subprog = 1;
 161         } else if (strcmp(fw_name, "PSP_SMUFW1_SUB2_FILE") == 0) {
 162                 fw_type = AMD_FW_PSP_SMU_FIRMWARE;
 163                 subprog = 2;
 164         } else if (strcmp(fw_name, "PSP_SMUFW2_SUB0_FILE") == 0) {
 165                 fw_type = AMD_FW_PSP_SMU_FIRMWARE2;
 166                 subprog = 0;
 167         } else if (strcmp(fw_name, "PSP_SMUFW2_SUB1_FILE") == 0) {
 168                 fw_type = AMD_FW_PSP_SMU_FIRMWARE2;
 169                 subprog = 1;
 170         } else if (strcmp(fw_name, "PSP_SMUFW2_SUB2_FILE") == 0) {
 171                 fw_type = AMD_FW_PSP_SMU_FIRMWARE2;
 172                 subprog = 2;
 173         } else if (strcmp(fw_name, "PSP_SEC_DBG_KEY_FILE") == 0) {
 174                 if (cb_config->unlock_secure) {
 175                         fw_type = AMD_FW_PSP_SECURED_DEBUG;
 176                         subprog = 0;
 177                 } else {
 178                         fw_type = AMD_FW_SKIP;
 179                 }
 180         } else if (strcmp(fw_name, "PSP_SEC_DEBUG_FILE") == 0) {
 181                 if (cb_config->unlock_secure) {
 182                         fw_type = AMD_DEBUG_UNLOCK;
 183                         subprog = 0;
 184                 } else {
 185                         fw_type = AMD_FW_SKIP;
 186                 }
 187         } else if (strcmp(fw_name, "PSP_ABL0_FILE") == 0) {
 188                 fw_type = AMD_ABL0;
 189                 subprog = 0;
 190         } else if (strcmp(fw_name, "PSP_ABL1_FILE") == 0) {
 191                 fw_type = AMD_ABL1;
 192                 subprog = 0;
 193         } else if (strcmp(fw_name, "PSP_ABL2_FILE") == 0) {
 194                 fw_type = AMD_ABL2;
 195                 subprog = 0;
 196         } else if (strcmp(fw_name, "PSP_ABL3_FILE") == 0) {
 197                 fw_type = AMD_ABL3;
 198                 subprog = 0;
 199         } else if (strcmp(fw_name, "PSP_ABL4_FILE") == 0) {
 200                 fw_type = AMD_ABL4;
 201                 subprog = 0;
 202         } else if (strcmp(fw_name, "PSP_ABL5_FILE") == 0) {
 203                 fw_type = AMD_ABL5;
 204                 subprog = 0;
 205         } else if (strcmp(fw_name, "PSP_ABL6_FILE") == 0) {
 206                 fw_type = AMD_ABL6;
 207                 subprog = 0;
 208         } else if (strcmp(fw_name, "PSP_ABL7_FILE") == 0) {
 209                 fw_type = AMD_ABL7;
 210                 subprog = 0;
 211         } else if (strcmp(fw_name, "PSPSECUREOS_FILE") == 0) {
 212                 if (cb_config->use_secureos) {
 213                         fw_type = AMD_FW_PSP_SECURED_OS;
 214                         subprog = 0;
 215                 } else {
 216                         fw_type = AMD_FW_SKIP;
 217                 }
 218         } else if (strcmp(fw_name, "PSPTRUSTLETS_FILE") == 0) {
 219                 if (cb_config->use_secureos) {
 220                         fw_type = AMD_FW_PSP_TRUSTLETS;
 221                         subprog = 0;
 222                 } else {
 223                         fw_type = AMD_FW_SKIP;
 224                 }
 225         } else if (strcmp(fw_name, "TRUSTLETKEY_FILE") == 0) {
 226                 if (cb_config->use_secureos) {
 227                         fw_type = AMD_FW_PSP_TRUSTLETKEY;
 228                         subprog = 0;
 229                 } else {
 230                         fw_type = AMD_FW_SKIP;
 231                 }
 232         } else if (strcmp(fw_name, "PSP_IKEK_FILE") == 0) {
 233                 fw_type = AMD_WRAPPED_IKEK;
 234                 subprog = 0;
 235         } else if (strcmp(fw_name, "PSP_SECG0_FILE") == 0) {
 236                 fw_type = AMD_SEC_GASKET;
 237                 subprog = 0;
 238         } else if (strcmp(fw_name, "PSP_SECG1_FILE") == 0) {
 239                 fw_type = AMD_SEC_GASKET;
 240                 subprog = 1;
 241         } else if (strcmp(fw_name, "PSP_SECG2_FILE") == 0) {
 242                 fw_type = AMD_SEC_GASKET;
 243                 subprog = 2;
 244         } else if (strcmp(fw_name, "PSP_MP2FW0_FILE") == 0) {
 245                 if (cb_config->load_mp2_fw) {
 246                         fw_type = AMD_MP2_FW;
 247                         subprog = 0;
 248                 } else {
 249                         fw_type = AMD_FW_SKIP;
 250                 }
 251         } else if (strcmp(fw_name, "PSP_MP2FW1_FILE") == 0) {
 252                 if (cb_config->load_mp2_fw) {
 253                         fw_type = AMD_MP2_FW;
 254                         subprog = 1;
 255                 } else {
 256                         fw_type = AMD_FW_SKIP;
 257                 }
 258         } else if (strcmp(fw_name, "PSP_MP2FW2_FILE") == 0) {
 259                 if (cb_config->load_mp2_fw) {
 260                         fw_type = AMD_MP2_FW;
 261                         subprog = 2;
 262                 } else {
 263                         fw_type = AMD_FW_SKIP;
 264                 }
 265         } else if (strcmp(fw_name, "PSP_DRIVERS_FILE") == 0) {
 266                 fw_type = AMD_DRIVER_ENTRIES;
 267                 subprog = 0;
 268         } else if (strcmp(fw_name, "PSP_S0I3_FILE") == 0) {
 269                 if (cb_config->s0i3) {
 270                         fw_type = AMD_S0I3_DRIVER;
 271                         subprog = 0;
 272                 } else {
 273                         fw_type = AMD_FW_SKIP;
 274                 }
 275         } else if (strcmp(fw_name, "AMD_DRIVER_ENTRIES") == 0) {
 276                 fw_type = AMD_DRIVER_ENTRIES;
 277                 subprog = 0;
 278         } else if (strcmp(fw_name, "VBIOS_BTLOADER_FILE") == 0) {
 279                 fw_type = AMD_VBIOS_BTLOADER;
 280                 subprog = 0;
 281         } else if (strcmp(fw_name, "SECURE_POLICY_L1_FILE") == 0) {
 282                 fw_type = AMD_FW_TOS_SEC_POLICY;
 283                 subprog = 0;
 284         } else if (strcmp(fw_name, "UNIFIEDUSB_FILE") == 0) {
 285                 fw_type = AMD_FW_USB_PHY;
 286                 subprog = 0;
 287         } else if (strcmp(fw_name, "DRTMTA_FILE") == 0) {
 288                 fw_type = AMD_FW_DRTM_TA;
 289                 subprog = 0;
 290         } else if (strcmp(fw_name, "KEYDBBL_FILE") == 0) {
 291                 fw_type = AMD_FW_KEYDB_BL;
 292                 subprog = 0;
 293         } else if (strcmp(fw_name, "KEYDB_TOS_FILE") == 0) {
 294                 fw_type = AMD_FW_KEYDB_TOS;
 295                 subprog = 0;
 296         } else if (strcmp(fw_name, "SPL_TABLE_FILE") == 0) {
 297                 if (cb_config->have_mb_spl) {
 298                         fw_type = AMD_FW_SKIP;
 299                 } else {
 300                         fw_type = AMD_FW_SPL;
 301                         subprog = 0;
 302                 }
 303         } else if (strcmp(fw_name, "DMCUERAMDCN21_FILE") == 0) {
 304                 fw_type = AMD_FW_DMCU_ERAM;
 305                 subprog = 0;
 306         } else if (strcmp(fw_name, "DMCUINTVECTORSDCN21_FILE") == 0) {
 307                 fw_type = AMD_FW_DMCU_ISR;
 308                 subprog = 0;
 309         } else if (strcmp(fw_name, "MSMU_FILE") == 0) {
 310                 fw_type = AMD_FW_MSMU;
 311                 subprog = 0;
 312         } else if (strcmp(fw_name, "DMCUB_FILE") == 0) {
 313                 fw_type = AMD_FW_DMCUB;
 314                 subprog = 0;
 315         } else if (strcmp(fw_name, "SPIROM_CONFIG_FILE") == 0) {
 316                 fw_type = AMD_FW_SPIROM_CFG;
 317                 subprog = 0;
 318         } else if (strcmp(fw_name, "PSP_KVM_ENGINE_DUMMY_FILE") == 0) {
 319                 fw_type = AMD_FW_KVM_IMAGE;
 320                 subprog = 0;
 321         } else if (strcmp(fw_name, "RPMC_FILE") == 0) {
 322                 fw_type = AMD_RPMC_NVRAM;
 323                 subprog = 0;
 324         } else if (strcmp(fw_name, "PSPBTLDR_AB_FILE") == 0) {
 325                 if (!cb_config->have_whitelist || cb_config->recovery_ab) {
 326                         fw_type = AMD_FW_PSP_BOOTLOADER_AB;
 327                         subprog = 0;
 328                 } else {
 329                         fw_type = AMD_FW_SKIP;
 330                 }
 331         } else if (strcmp(fw_name, "TA_IKEK_FILE") == 0) {
 332                 fw_type = AMD_TA_IKEK;
 333                 subprog = 0;
 334         } else {
 335                 fw_type = AMD_FW_INVALID;
 336                 /* TODO: Add more */
 337         }
 338
 339         /* Search and fill the filename */
 340         psp_tableptr = &amd_psp_fw_table[0];
 341         if (fw_type != AMD_FW_SKIP && fw_type != AMD_FW_INVALID) {
 342                 while (psp_tableptr->type != AMD_FW_INVALID) {
 343                         /* instance are not used in PSP table */
 344                         if (psp_tableptr->type == fw_type && psp_tableptr->subprog == subprog) {
 345                                 psp_tableptr->filename = filename;
 346                                 SET_LEVEL(psp_tableptr, level_to_set, PSP,
 347                                         cb_config->recovery_ab);
 348                                 break;
 349                         }
 350                         psp_tableptr++;
 351                 }
 352         }
 353         if (fw_type == AMD_FW_INVALID)
 354                 return 0;
 355         else
 356                 return 1;
 357 }
 358 #define PMUI_STR_BASE   "PSP_PMUI_FILE"
 359 #define PMUD_STR_BASE   "PSP_PMUD_FILE"
 360 #define PMU_STR_BASE_LEN strlen(PMUI_STR_BASE)
 361 #define PMU_STR_SUB_INDEX strlen(PMUI_STR_BASE"_SUB")
 362 #define PMU_STR_INS_INDEX strlen(PMUI_STR_BASE"_SUBx_INS")
 363 #define PMU_STR_ALL_LEN  strlen(PMUI_STR_BASE"_SUBx_INSx")
 364
 365 static uint8_t find_register_fw_filename_bios_dir(char *fw_name, char *filename,
 366                 char level_to_set, amd_cb_config *cb_config)
 367 {
 368         amd_bios_type fw_type = AMD_BIOS_INVALID;
 369         amd_bios_entry *bhd_tableptr;
 370         uint8_t subprog = 0;
 371         uint8_t instance = 0;
 372
 373         (void) (cb_config);     /* Remove warning and reserved for future. */
 374
 375         if (strncmp(fw_name, PMUI_STR_BASE, PMU_STR_BASE_LEN) == 0) {
 376                 assert(strlen(fw_name) == PMU_STR_ALL_LEN);
 377                 fw_type = AMD_BIOS_PMUI;
 378                 subprog = fw_name[PMU_STR_SUB_INDEX] - '0';
 379                 instance = fw_name[PMU_STR_INS_INDEX] - '0';
 380         } else if (strncmp(fw_name, PMUD_STR_BASE, PMU_STR_BASE_LEN) == 0) {
 381                 assert(strlen(fw_name) == PMU_STR_ALL_LEN);
 382                 fw_type = AMD_BIOS_PMUD;
 383                 subprog = fw_name[PMU_STR_SUB_INDEX] - '0';
 384                 instance = fw_name[PMU_STR_INS_INDEX] - '0';
 385         } else if (strcmp(fw_name, "RTM_PUBKEY_FILE") == 0) {
 386                 fw_type = AMD_BIOS_RTM_PUBKEY;
 387                 subprog = 0;
 388                 instance = 0;
 389         } else if (strcmp(fw_name, "PSP_MP2CFG_FILE") == 0) {
 390                 if (cb_config->load_mp2_fw) {
 391                         fw_type = AMD_BIOS_MP2_CFG;
 392                         subprog = 0;
 393                 } else {
 394                         fw_type = AMD_BIOS_SKIP;
 395                 }
 396         } else {
 397                 fw_type = AMD_BIOS_INVALID;
 398         }
 399
 400         bhd_tableptr = amd_bios_table;
 401
 402         if (fw_type != AMD_BIOS_INVALID && fw_type != AMD_BIOS_SKIP) {
 403                 while (bhd_tableptr->type != AMD_BIOS_INVALID) {
 404                         if (bhd_tableptr->type == fw_type &&
 405                                         bhd_tableptr->subpr == subprog &&
 406                                         bhd_tableptr->inst  == instance) {
 407                                 bhd_tableptr->filename = filename;
 408                                 SET_LEVEL(bhd_tableptr, level_to_set, BDT,
 409                                         cb_config->recovery_ab);
 410                                 break;
 411                         }
 412                         bhd_tableptr++;
 413                 }
 414         }
 415         if (fw_type == AMD_BIOS_INVALID)
 416                 return 0;
 417         else
 418                 return 1;
 419 }
 420
 421 #define MAX_LINE_SIZE 1024
 422
 423 int get_input_file_line(FILE *f, char line[], int line_buf_size)
 424 {
 425         if (fgets(line, line_buf_size, f) == NULL)
 426                 return LINE_EOF;
 427
 428         /* If the file contains a line that is too long, then it's best
 429          * to let the user know right away rather than passing back a
 430          * truncated result that will lead to problems later on.
 431          */
 432         line[strlen(line) - 1] = '\0';
 433
 434         if (strlen(line) == ((size_t) (line_buf_size - 1))) {
 435                 fprintf(stderr, "The line size in config file should be lower than %d bytes.\n",
 436                         MAX_LINE_SIZE);
 437                 exit(1);
 438         }
 439
 440         return OK;
 441 }
 442
 443 #define N_MATCHES 4
 444 static int is_valid_entry(char *oneline, regmatch_t match[N_MATCHES])
 445 {
 446         int retval, index;
 447
 448         for (index = 0; index < N_MATCHES; index++) {
 449                 match[index].rm_so = -1;
 450                 match[index].rm_eo = -1;
 451         }
 452         if (regexec(&entries_line_expr, oneline, 3, match, 0) == 0) {
 453                 oneline[match[1].rm_eo] = '\0';
 454                 oneline[match[2].rm_eo] = '\0';
 455                 retval = 1;
 456         } else if (regexec(&entries_lvl_line_expr, oneline, 4, match, 0) == 0) {
 457                 /* match[1]: FW type
 458                    match[2]: FW filename
 459                    match[3]: Directory level to be dropped
 460                  */
 461                 oneline[match[1].rm_eo] = '\0';
 462                 oneline[match[2].rm_eo] = '\0';
 463                 oneline[match[3].rm_eo] = '\0';
 464                 retval = 1;
 465         } else {
 466                 retval = 0;
 467         }
 468
 469         return retval;
 470 }
 471
 472 static int skip_comment_blank_line(char *oneline)
 473 {
 474         int retval;
 475
 476         if (regexec(&blank_or_comment_expr, oneline, 0, NULL, 0) == 0) {
 477                 /* skip comment and blank */
 478                 retval = 1;
 479         } else {
 480                 /* no match */
 481                 retval = 0;
 482         }
 483
 484         return retval;
 485 }
 486
 487 char get_level_from_config(char *line, regoff_t level_index, amd_cb_config *cb_config)
 488 {
 489         char lvl = 'x';
 490         /* If the optional level field is present,
 491            extract the level char. */
 492         if (level_index != -1) {
 493                 if (cb_config->recovery_ab == 0)
 494                         lvl = line[level_index + 1];
 495                 else if (strlen(&line[level_index]) >= 3)
 496                         lvl = line[level_index + 2];
 497         }
 498
 499         assert(lvl == 'x' || lvl == 'X' ||
 500                 lvl == 'b' || lvl == 'B' ||
 501                 lvl == '1' || lvl == '2');
 502
 503         return lvl;
 504 }
 505
 506 /*
 507   return value:
 508         0: The config file can not be parsed correctly.
 509         1: The config file can be parsed correctly.
 510  */
 511 uint8_t process_config(FILE *config, amd_cb_config *cb_config, uint8_t print_deps)
 512 {
 513         char oneline[MAX_LINE_SIZE], *path_filename;
 514         regmatch_t match[N_MATCHES];
 515         char dir[MAX_LINE_SIZE] = {'\0'};
 516         uint32_t dir_len;
 517         int index;
 518
 519         for (index = 0; index < N_MATCHES; index++) {
 520                 match[index].rm_so = -1;
 521                 match[index].rm_eo = -1;
 522         }
 523
 524         compile_reg_expr(REG_EXTENDED | REG_NEWLINE,
 525                 blank_or_comment_regex, &blank_or_comment_expr);
 526         compile_reg_expr(REG_EXTENDED | REG_NEWLINE,
 527                 entries_line_regex, &entries_line_expr);
 528         compile_reg_expr(REG_EXTENDED | REG_NEWLINE,
 529                 entries_lvl_line_regex, &entries_lvl_line_expr);
 530
 531         /* Get a line */
 532         /* Get FIRMWARE_LOCATION in the first loop */
 533         while (get_input_file_line(config, oneline, MAX_LINE_SIZE) == OK) {
 534                 /* get a line */
 535                 if (skip_comment_blank_line(oneline))
 536                         continue;
 537                 if (is_valid_entry(oneline, match)) {
 538                         if (strcmp(&(oneline[match[1].rm_so]), "FIRMWARE_LOCATION") == 0) {
 539                                 dir_len = match[2].rm_eo - match[2].rm_so;
 540                                 assert(dir_len < MAX_LINE_SIZE);
 541                                 snprintf(dir, MAX_LINE_SIZE, "%.*s", dir_len,
 542                                         &(oneline[match[2].rm_so]));
 543                                 break;
 544                         }
 545                 }
 546         }
 547
 548         if (dir[0] == '\0') {
 549                 fprintf(stderr, "No line with FIRMWARE_LOCATION\n");
 550                 return 0;
 551         }
 552
 553         fseek(config, 0, SEEK_SET);
 554         /* Get a line */
 555         while (get_input_file_line(config, oneline, MAX_LINE_SIZE) == OK) {
 556                 /* get a line */
 557                 if (skip_comment_blank_line(oneline))
 558                         continue;
 559                 if (is_valid_entry(oneline, match)) {
 560                         if (strcmp(&(oneline[match[1].rm_so]), "FIRMWARE_LOCATION") == 0) {
 561                                 continue;
 562                         } else {
 563                                 char ch_lvl = 'x';
 564                                 path_filename = malloc(MAX_LINE_SIZE * 2 + 2);
 565                                 snprintf(path_filename, MAX_LINE_SIZE * 2 + 2, "%.*s/%.*s",
 566                                         MAX_LINE_SIZE, dir, MAX_LINE_SIZE,
 567                                         &(oneline[match[2].rm_so]));
 568
 569                                 /* If the optional level field is present,
 570                                    extract the level char. */
 571                                 ch_lvl = get_level_from_config(oneline,
 572                                                 match[3].rm_so, cb_config);
 573
 574                                 if (find_register_fw_filename_psp_dir(
 575                                                 &(oneline[match[1].rm_so]),
 576                                                 path_filename, ch_lvl, cb_config) == 0) {
 577                                         if (find_register_fw_filename_bios_dir(
 578                                                         &(oneline[match[1].rm_so]),
 579                                                         path_filename, ch_lvl, cb_config)
 580                                                         == 0) {
 581                                                 fprintf(stderr, "Module's name \"%s\" is not valid\n", oneline);
 582                                                 return 0; /* Stop parsing. */
 583                                         } else {
 584                                                 if (print_deps)
 585                                                         printf(" %s ", path_filename);
 586                                         }
 587                                 } else {
 588                                         if (print_deps)
 589                                                 printf(" %s ", path_filename);
 590                                 }
 591                         }
 592                 } else {
 593                         fprintf(stderr, "AMDFWTOOL config file line can't be parsed \"%s\"\n", oneline);
 594                         return 0;
 595                 }
 596         }
 597         return 1;
 598 }