IntelFsp2Pkg/Tools/FspDscBsf2Yaml.py

   1 #!/usr/bin/env python
   2 ## @ FspDscBsf2Yaml.py
   3 # This script convert DSC or BSF format file into YAML format
   4 #
   5 # Copyright(c) 2021, Intel Corporation. All rights reserved.<BR>
   6 # SPDX-License-Identifier: BSD-2-Clause-Patent
   7 #
   8 ##
   9
  10 import os
  11 import re
  12 import sys
  13
  14 from collections import OrderedDict
  15 from datetime import date
  16
  17 from FspGenCfgData import CFspBsf2Dsc, CGenCfgData
  18
  19 __copyright_tmp__ = """## @file
  20 #
  21 #  Slim Bootloader CFGDATA %s File.
  22 #
  23 #  Copyright (c) %4d, Intel Corporation. All rights reserved.<BR>
  24 #  SPDX-License-Identifier: BSD-2-Clause-Patent
  25 #
  26 ##
  27 """
  28
  29
  30 class CFspDsc2Yaml():
  31
  32     def __init__(self):
  33         self._Hdr_key_list = ['EMBED', 'STRUCT']
  34         self._Bsf_key_list = ['NAME', 'HELP', 'TYPE', 'PAGE', 'PAGES',
  35                               'OPTION', 'CONDITION', 'ORDER', 'MARKER',
  36                               'SUBT', 'FIELD', 'FIND']
  37         self.gen_cfg_data = None
  38         self.cfg_reg_exp = re.compile(
  39             "^([_a-zA-Z0-9$\\(\\)]+)\\s*\\|\\s*(0x[0-9A-F]+|\\*)"
  40             "\\s*\\|\\s*(\\d+|0x[0-9a-fA-F]+)\\s*\\|\\s*(.+)")
  41         self.bsf_reg_exp = re.compile("(%s):{(.+?)}(?:$|\\s+)"
  42                                       % '|'.join(self._Bsf_key_list))
  43         self.hdr_reg_exp = re.compile("(%s):{(.+?)}"
  44                                       % '|'.join(self._Hdr_key_list))
  45         self.prefix = ''
  46         self.unused_idx = 0
  47         self.offset = 0
  48         self.base_offset = 0
  49
  50     def load_config_data_from_dsc(self, file_name):
  51         """
  52         Load and parse a DSC CFGDATA file.
  53         """
  54         gen_cfg_data = CGenCfgData('FSP')
  55         if file_name.endswith('.dsc'):
  56             if gen_cfg_data.ParseDscFile(file_name) != 0:
  57                 raise Exception('DSC file parsing error !')
  58             if gen_cfg_data.CreateVarDict() != 0:
  59                 raise Exception('DSC variable creation error !')
  60         else:
  61             raise Exception('Unsupported file "%s" !' % file_name)
  62         gen_cfg_data.UpdateDefaultValue()
  63         self.gen_cfg_data = gen_cfg_data
  64
  65     def print_dsc_line(self):
  66         """
  67         Debug function to print all DSC lines.
  68         """
  69         for line in self.gen_cfg_data._DscLines:
  70             print(line)
  71
  72     def format_value(self, field, text, indent=''):
  73         """
  74         Format a CFGDATA item into YAML format.
  75         """
  76         if (not text.startswith('!expand')) and (': ' in text):
  77             tgt = ':' if field == 'option' else '- '
  78             text = text.replace(': ', tgt)
  79         lines = text.splitlines()
  80         if len(lines) == 1 and field != 'help':
  81             return text
  82         else:
  83             return '>\n   ' + '\n   '.join(
  84                 [indent + i.lstrip() for i in lines])
  85
  86     def reformat_pages(self, val):
  87         # Convert XXX:YYY into XXX::YYY format for page definition
  88         parts = val.split(',')
  89         if len(parts) <= 1:
  90             return val
  91
  92         new_val = []
  93         for each in parts:
  94             nodes = each.split(':')
  95             if len(nodes) == 2:
  96                 each = '%s::%s' % (nodes[0], nodes[1])
  97             new_val.append(each)
  98         ret = ','.join(new_val)
  99         return ret
 100
 101     def reformat_struct_value(self, utype, val):
 102         # Convert DSC UINT16/32/64 array into new format by
 103         # adding prefix 0:0[WDQ] to provide hint to the array format
 104         if utype in ['UINT16', 'UINT32', 'UINT64']:
 105             if val and val[0] == '{' and val[-1] == '}':
 106                 if utype == 'UINT16':
 107                     unit = 'W'
 108                 elif utype == 'UINT32':
 109                     unit = 'D'
 110                 else:
 111                     unit = 'Q'
 112                 val = '{ 0:0%s, %s }' % (unit, val[1:-1])
 113         return val
 114
 115     def process_config(self, cfg):
 116         if 'page' in cfg:
 117             cfg['page'] = self.reformat_pages(cfg['page'])
 118
 119         if 'struct' in cfg:
 120             cfg['value'] = self.reformat_struct_value(
 121                 cfg['struct'], cfg['value'])
 122
 123     def parse_dsc_line(self, dsc_line, config_dict, init_dict, include):
 124         """
 125         Parse a line in DSC and update the config dictionary accordingly.
 126         """
 127         init_dict.clear()
 128         match = re.match('g(CfgData|\\w+FspPkgTokenSpaceGuid)\\.(.+)',
 129                          dsc_line)
 130         if match:
 131             match = self.cfg_reg_exp.match(match.group(2))
 132             if not match:
 133                 return False
 134             config_dict['cname'] = self.prefix + match.group(1)
 135             value = match.group(4).strip()
 136             length = match.group(3).strip()
 137             config_dict['length'] = length
 138             config_dict['value'] = value
 139             if match.group(2) == '*':
 140                 self.offset += int(length, 0)
 141             else:
 142                 org_offset = int(match.group(2), 0)
 143                 if org_offset == 0:
 144                     self.base_offset = self.offset
 145                 offset = org_offset + self.base_offset
 146                 if self.offset != offset:
 147                     if offset > self.offset:
 148                         init_dict['padding'] = offset - self.offset
 149                 self.offset = offset + int(length, 0)
 150             return True
 151
 152         match = re.match("^\\s*#\\s+!([<>])\\s+include\\s+(.+)", dsc_line)
 153         if match and len(config_dict) == 0:
 154             # !include should not be inside a config field
 155             # if so, do not convert include into YAML
 156             init_dict = dict(config_dict)
 157             config_dict.clear()
 158             config_dict['cname'] = '$ACTION'
 159             if match.group(1) == '<':
 160                 config_dict['include'] = match.group(2)
 161             else:
 162                 config_dict['include'] = ''
 163             return True
 164
 165         match = re.match("^\\s*#\\s+(!BSF|!HDR)\\s+(.+)", dsc_line)
 166         if not match:
 167             return False
 168
 169         remaining = match.group(2)
 170         if match.group(1) == '!BSF':
 171             result = self.bsf_reg_exp.findall(remaining)
 172             if not result:
 173                 return False
 174
 175             for each in result:
 176                 key = each[0].lower()
 177                 val = each[1]
 178                 if key == 'field':
 179                     name = each[1]
 180                     if ':' not in name:
 181                         raise Exception('Incorrect bit field format !')
 182                     parts = name.split(':')
 183                     config_dict['length'] = parts[1]
 184                     config_dict['cname'] = '@' + parts[0]
 185                     return True
 186                 elif key in ['pages', 'page', 'find']:
 187                     init_dict = dict(config_dict)
 188                     config_dict.clear()
 189                     config_dict['cname'] = '$ACTION'
 190                     if key == 'find':
 191                         config_dict['find'] = val
 192                     else:
 193                         config_dict['page'] = val
 194                     return True
 195                 elif key == 'subt':
 196                     config_dict.clear()
 197                     parts = each[1].split(':')
 198                     tmp_name = parts[0][:-5]
 199                     if tmp_name == 'CFGHDR':
 200                         cfg_tag = '_$FFF_'
 201                         sval = '!expand { %s_TMPL : [ ' % \
 202                             tmp_name + '%s, %s, ' % (parts[1], cfg_tag) + \
 203                             ', '.join(parts[2:]) + ' ] }'
 204                     else:
 205                         sval = '!expand { %s_TMPL : [ ' % \
 206                             tmp_name + ', '.join(parts[1:]) + ' ] }'
 207                     config_dict.clear()
 208                     config_dict['cname'] = tmp_name
 209                     config_dict['expand'] = sval
 210                     return True
 211                 else:
 212                     if key in ['name', 'help', 'option'] and \
 213                             val.startswith('+'):
 214                         val = config_dict[key] + '\n' + val[1:]
 215                     if val.strip() == '':
 216                         val = "''"
 217                     config_dict[key] = val
 218
 219         else:
 220             match = self.hdr_reg_exp.match(remaining)
 221             if not match:
 222                 return False
 223             key = match.group(1)
 224             remaining = match.group(2)
 225             if key == 'EMBED':
 226                 parts = remaining.split(':')
 227                 names = parts[0].split(',')
 228                 if parts[-1] == 'END':
 229                     prefix = '>'
 230                 else:
 231                     prefix = '<'
 232                 skip = False
 233                 if parts[1].startswith('TAG_'):
 234                     tag_txt = '%s:%s' % (names[0], parts[1])
 235                 else:
 236                     tag_txt = names[0]
 237                     if parts[2] in ['START', 'END']:
 238                         if names[0] == 'PCIE_RP_PIN_CTRL[]':
 239                             skip = True
 240                         else:
 241                             tag_txt = '%s:%s' % (names[0], parts[1])
 242                 if not skip:
 243                     config_dict.clear()
 244                     config_dict['cname'] = prefix + tag_txt
 245                     return True
 246
 247             if key == 'STRUCT':
 248                 text = remaining.strip()
 249                 config_dict[key.lower()] = text
 250
 251         return False
 252
 253     def process_template_lines(self, lines):
 254         """
 255         Process a line in DSC template section.
 256         """
 257         template_name = ''
 258         bsf_temp_dict = OrderedDict()
 259         temp_file_dict = OrderedDict()
 260         include_file = ['.']
 261
 262         for line in lines:
 263             match = re.match("^\\s*#\\s+!([<>])\\s+include\\s+(.+)", line)
 264             if match:
 265                 if match.group(1) == '<':
 266                     include_file.append(match.group(2))
 267                 else:
 268                     include_file.pop()
 269
 270             match = re.match(
 271                 "^\\s*#\\s+(!BSF)\\s+DEFT:{(.+?):(START|END)}", line)
 272             if match:
 273                 if match.group(3) == 'START' and not template_name:
 274                     template_name = match.group(2).strip()
 275                     temp_file_dict[template_name] = list(include_file)
 276                     bsf_temp_dict[template_name] = []
 277                 if match.group(3) == 'END' and \
 278                         (template_name == match.group(2).strip()) and \
 279                         template_name:
 280                     template_name = ''
 281             else:
 282                 if template_name:
 283                     bsf_temp_dict[template_name].append(line)
 284         return bsf_temp_dict, temp_file_dict
 285
 286     def process_option_lines(self, lines):
 287         """
 288         Process a line in DSC config section.
 289         """
 290         cfgs = []
 291         struct_end = False
 292         config_dict = dict()
 293         init_dict = dict()
 294         include = ['']
 295         for line in lines:
 296             ret = self.parse_dsc_line(line, config_dict, init_dict, include)
 297             if ret:
 298                 if 'padding' in init_dict:
 299                     num = init_dict['padding']
 300                     init_dict.clear()
 301                     padding_dict = {}
 302                     cfgs.append(padding_dict)
 303                     padding_dict['cname'] = 'UnusedUpdSpace%d' % \
 304                         self.unused_idx
 305                     padding_dict['length'] = '0x%x' % num
 306                     padding_dict['value'] = '{ 0 }'
 307                     self.unused_idx += 1
 308
 309                 if cfgs and cfgs[-1]['cname'][0] != '@' and \
 310                         config_dict['cname'][0] == '@':
 311                     # it is a bit field, mark the previous one as virtual
 312                     cname = cfgs[-1]['cname']
 313                     new_cfg = dict(cfgs[-1])
 314                     new_cfg['cname'] = '@$STRUCT'
 315                     cfgs[-1].clear()
 316                     cfgs[-1]['cname'] = cname
 317                     cfgs.append(new_cfg)
 318
 319                 if cfgs and cfgs[-1]['cname'] == 'CFGHDR' and \
 320                         config_dict['cname'][0] == '<':
 321                     # swap CfgHeader and the CFG_DATA order
 322                     if ':' in config_dict['cname']:
 323                         # replace the real TAG for CFG_DATA
 324                         cfgs[-1]['expand'] = cfgs[-1]['expand'].replace(
 325                             '_$FFF_', '0x%s' %
 326                             config_dict['cname'].split(':')[1][4:])
 327                     cfgs.insert(-1, config_dict)
 328                 else:
 329                     self.process_config(config_dict)
 330                     if struct_end:
 331                         struct_end = False
 332                         cfgs.insert(-1, config_dict)
 333                     else:
 334                         cfgs.append(config_dict)
 335                         if config_dict['cname'][0] == '>':
 336                             struct_end = True
 337
 338                 config_dict = dict(init_dict)
 339         return cfgs
 340
 341     def variable_fixup(self, each):
 342         """
 343         Fix up some variable definitions for SBL.
 344         """
 345         key = each
 346         val = self.gen_cfg_data._MacroDict[each]
 347         return key, val
 348
 349     def template_fixup(self, tmp_name, tmp_list):
 350         """
 351         Fix up some special config templates for SBL
 352         """
 353         return
 354
 355     def config_fixup(self, cfg_list):
 356         """
 357         Fix up some special config items for SBL.
 358         """
 359
 360         # Insert FSPT_UPD/FSPM_UPD/FSPS_UPD tag so as to create C strcture
 361         idxs = []
 362         for idx, cfg in enumerate(cfg_list):
 363             if cfg['cname'].startswith('<FSP_UPD_HEADER'):
 364                 idxs.append(idx)
 365
 366         if len(idxs) != 3:
 367             return
 368
 369         # Handle insert backwards so that the index does not change in the loop
 370         fsp_comp = 'SMT'
 371         idx_comp = 0
 372         for idx in idxs[::-1]:
 373             # Add current FSP?_UPD start tag
 374             cfgfig_dict = {}
 375             cfgfig_dict['cname'] = '<FSP%s_UPD' % fsp_comp[idx_comp]
 376             cfg_list.insert(idx, cfgfig_dict)
 377             if idx_comp < 2:
 378                 # Add previous FSP?_UPD end tag
 379                 cfgfig_dict = {}
 380                 cfgfig_dict['cname'] = '>FSP%s_UPD' % fsp_comp[idx_comp + 1]
 381                 cfg_list.insert(idx, cfgfig_dict)
 382             idx_comp += 1
 383
 384         # Add final FSPS_UPD end tag
 385         cfgfig_dict = {}
 386         cfgfig_dict['cname'] = '>FSP%s_UPD' % fsp_comp[0]
 387         cfg_list.append(cfgfig_dict)
 388
 389         return
 390
 391     def get_section_range(self, section_name):
 392         """
 393         Extract line number range from config file for a given section name.
 394         """
 395         start = -1
 396         end = -1
 397         for idx, line in enumerate(self.gen_cfg_data._DscLines):
 398             if start < 0 and line.startswith('[%s]' % section_name):
 399                 start = idx
 400             elif start >= 0 and line.startswith('['):
 401                 end = idx
 402                 break
 403         if start == -1:
 404             start = 0
 405         if end == -1:
 406             end = len(self.gen_cfg_data._DscLines)
 407         return start, end
 408
 409     def normalize_file_name(self, file, is_temp=False):
 410         """
 411         Normalize file name convention so that it is consistent.
 412         """
 413         if file.endswith('.dsc'):
 414             file = file[:-4] + '.yaml'
 415         dir_name = os.path.dirname(file)
 416         base_name = os.path.basename(file)
 417         if is_temp:
 418             if 'Template_' not in file:
 419                 base_name = base_name.replace('Template', 'Template_')
 420         else:
 421             if 'CfgData_' not in file:
 422                 base_name = base_name.replace('CfgData', 'CfgData_')
 423         if dir_name:
 424             path = dir_name + '/' + base_name
 425         else:
 426             path = base_name
 427         return path
 428
 429     def output_variable(self):
 430         """
 431         Output variable block into a line list.
 432         """
 433         lines = []
 434         for each in self.gen_cfg_data._MacroDict:
 435             key, value = self.variable_fixup(each)
 436             lines.append('%-30s : %s' % (key,  value))
 437         return lines
 438
 439     def output_template(self):
 440         """
 441         Output template block into a line list.
 442         """
 443         self.offset = 0
 444         self.base_offset = 0
 445         start, end = self.get_section_range('PcdsDynamicVpd.Tmp')
 446         bsf_temp_dict, temp_file_dict = self.process_template_lines(
 447             self.gen_cfg_data._DscLines[start:end])
 448         template_dict = dict()
 449         lines = []
 450         file_lines = {}
 451         last_file = '.'
 452         file_lines[last_file] = []
 453
 454         for tmp_name in temp_file_dict:
 455             temp_file_dict[tmp_name][-1] = self.normalize_file_name(
 456                 temp_file_dict[tmp_name][-1], True)
 457             if len(temp_file_dict[tmp_name]) > 1:
 458                 temp_file_dict[tmp_name][-2] = self.normalize_file_name(
 459                     temp_file_dict[tmp_name][-2], True)
 460
 461         for tmp_name in bsf_temp_dict:
 462             file = temp_file_dict[tmp_name][-1]
 463             if last_file != file and len(temp_file_dict[tmp_name]) > 1:
 464                 inc_file = temp_file_dict[tmp_name][-2]
 465                 file_lines[inc_file].extend(
 466                     ['', '- !include %s' % temp_file_dict[tmp_name][-1], ''])
 467             last_file = file
 468             if file not in file_lines:
 469                 file_lines[file] = []
 470             lines = file_lines[file]
 471             text = bsf_temp_dict[tmp_name]
 472             tmp_list = self.process_option_lines(text)
 473             self.template_fixup(tmp_name, tmp_list)
 474             template_dict[tmp_name] = tmp_list
 475             lines.append('%s: >' % tmp_name)
 476             lines.extend(self.output_dict(tmp_list, False)['.'])
 477             lines.append('\n')
 478         return file_lines
 479
 480     def output_config(self):
 481         """
 482         Output config block into a line list.
 483         """
 484         self.offset = 0
 485         self.base_offset = 0
 486         start, end = self.get_section_range('PcdsDynamicVpd.Upd')
 487         cfgs = self.process_option_lines(
 488             self.gen_cfg_data._DscLines[start:end])
 489         self.config_fixup(cfgs)
 490         file_lines = self.output_dict(cfgs, True)
 491         return file_lines
 492
 493     def output_dict(self, cfgs, is_configs):
 494         """
 495         Output one config item into a line list.
 496         """
 497         file_lines = {}
 498         level = 0
 499         file = '.'
 500         for each in cfgs:
 501             if 'length' in each:
 502                 if not each['length'].endswith('b') and int(each['length'],
 503                                                             0) == 0:
 504                     continue
 505
 506             if 'include' in each:
 507                 if each['include']:
 508                     each['include'] = self.normalize_file_name(
 509                         each['include'])
 510                     file_lines[file].extend(
 511                         ['', '- !include %s' % each['include'], ''])
 512                     file = each['include']
 513                 else:
 514                     file = '.'
 515                 continue
 516
 517             if file not in file_lines:
 518                 file_lines[file] = []
 519
 520             lines = file_lines[file]
 521             name = each['cname']
 522
 523             prefix = name[0]
 524             if prefix == '<':
 525                 level += 1
 526
 527             padding = '  ' * level
 528             if prefix not in '<>@':
 529                 padding += '  '
 530             else:
 531                 name = name[1:]
 532                 if prefix == '@':
 533                     padding += '    '
 534
 535             if ':' in name:
 536                 parts = name.split(':')
 537                 name = parts[0]
 538
 539             padding = padding[2:] if is_configs else padding
 540
 541             if prefix != '>':
 542                 if 'expand' in each:
 543                     lines.append('%s- %s' % (padding, each['expand']))
 544                 else:
 545                     lines.append('%s- %-12s :' % (padding, name))
 546
 547             for field in each:
 548                 if field in ['cname', 'expand', 'include']:
 549                     continue
 550                 value_str = self.format_value(
 551                     field, each[field], padding + ' ' * 16)
 552                 full_line = '  %s  %-12s : %s' % (padding, field, value_str)
 553                 lines.extend(full_line.splitlines())
 554
 555             if prefix == '>':
 556                 level -= 1
 557                 if level == 0:
 558                     lines.append('')
 559
 560         return file_lines
 561
 562
 563 def bsf_to_dsc(bsf_file, dsc_file):
 564     fsp_dsc = CFspBsf2Dsc(bsf_file)
 565     dsc_lines = fsp_dsc.get_dsc_lines()
 566     fd = open(dsc_file, 'w')
 567     fd.write('\n'.join(dsc_lines))
 568     fd.close()
 569     return
 570
 571
 572 def dsc_to_yaml(dsc_file, yaml_file):
 573     dsc2yaml = CFspDsc2Yaml()
 574     dsc2yaml.load_config_data_from_dsc(dsc_file)
 575
 576     cfgs = {}
 577     for cfg in ['Template', 'Option']:
 578         if cfg == 'Template':
 579             file_lines = dsc2yaml.output_template()
 580         else:
 581             file_lines = dsc2yaml.output_config()
 582         for file in file_lines:
 583             lines = file_lines[file]
 584             if file == '.':
 585                 cfgs[cfg] = lines
 586             else:
 587                 if ('/' in file or '\\' in file):
 588                     continue
 589                 file = os.path.basename(file)
 590                 out_dir = os.path.dirname(file)
 591                 fo = open(os.path.join(out_dir, file), 'w')
 592                 fo.write(__copyright_tmp__ % (
 593                     cfg, date.today().year) + '\n\n')
 594                 for line in lines:
 595                     fo.write(line + '\n')
 596                 fo.close()
 597
 598     variables = dsc2yaml.output_variable()
 599     fo = open(yaml_file, 'w')
 600     fo.write(__copyright_tmp__ % ('Default', date.today().year))
 601     if len(variables) > 0:
 602         fo.write('\n\nvariable:\n')
 603         for line in variables:
 604             fo.write('  ' + line + '\n')
 605
 606     fo.write('\n\ntemplate:\n')
 607     for line in cfgs['Template']:
 608         fo.write('  ' + line + '\n')
 609
 610     fo.write('\n\nconfigs:\n')
 611     for line in cfgs['Option']:
 612         fo.write('  ' + line + '\n')
 613
 614     fo.close()
 615
 616
 617 def get_fsp_name_from_path(bsf_file):
 618     name = ''
 619     parts = bsf_file.split(os.sep)
 620     for part in parts:
 621         if part.endswith('FspBinPkg'):
 622             name = part[:-9]
 623             break
 624     if not name:
 625         raise Exception('Could not get FSP name from file path!')
 626     return name
 627
 628
 629 def usage():
 630     print('\n'.join([
 631           "FspDscBsf2Yaml Version 0.10",
 632           "Usage:",
 633           "    FspDscBsf2Yaml  BsfFile|DscFile  YamlFile"
 634           ]))
 635
 636
 637 def main():
 638     #
 639     # Parse the options and args
 640     #
 641     argc = len(sys.argv)
 642     if argc < 3:
 643         usage()
 644         return 1
 645
 646     bsf_file = sys.argv[1]
 647     yaml_file = sys.argv[2]
 648     if os.path.isdir(yaml_file):
 649         yaml_file = os.path.join(
 650             yaml_file, get_fsp_name_from_path(bsf_file) + '.yaml')
 651
 652     if bsf_file.endswith('.dsc'):
 653         dsc_file = bsf_file
 654         bsf_file = ''
 655     else:
 656         dsc_file = os.path.splitext(yaml_file)[0] + '.dsc'
 657         bsf_to_dsc(bsf_file, dsc_file)
 658
 659     dsc_to_yaml(dsc_file, yaml_file)
 660
 661     print("'%s' was created successfully!" % yaml_file)
 662
 663     return 0
 664
 665
 666 if __name__ == '__main__':
 667     sys.exit(main())