util/intelp2m/main.go

   1 package main
   2
   3 import (
   4         "flag"
   5         "fmt"
   6         "os"
   7
   8         "review.coreboot.org/coreboot.git/util/intelp2m/config"
   9         "review.coreboot.org/coreboot.git/util/intelp2m/parser"
  10 )
  11
  12 // generateOutputFile - generates include file
  13 // parser            : parser data structure
  14 func generateOutputFile(parser *parser.ParserData) (err error) {
  15
  16         config.OutputGenFile.WriteString(`/* SPDX-License-Identifier: GPL-2.0-only */
  17
  18 #ifndef CFG_GPIO_H
  19 #define CFG_GPIO_H
  20
  21 #include <gpio.h>
  22
  23 /* Pad configuration was generated automatically using intelp2m utility */
  24 static const struct pad_config gpio_table[] = {`)
  25         // Add the pads map
  26         parser.PadMapFprint()
  27         config.OutputGenFile.WriteString(`};
  28
  29 #endif /* CFG_GPIO_H */
  30 `)
  31         return nil
  32 }
  33
  34 // main
  35 func main() {
  36         // Command line arguments
  37         inputFileName := flag.String("file",
  38                 "inteltool.log",
  39                 "the path to the inteltool log file\n")
  40
  41         outputFileName := flag.String("o",
  42                 "generate/gpio.h",
  43                 "the path to the generated file with GPIO configuration\n")
  44
  45         ignFlag := flag.Bool("ign",
  46                 false,
  47                 "exclude fields that should be ignored from advanced macros\n")
  48
  49         nonCheckFlag := flag.Bool("n",
  50                 false,
  51                 "Generate macros without checking.\n" +
  52                 "\tIn this case, some fields of the configuration registers\n" +
  53                 "\tDW0 will be ignored.\n")
  54
  55         infoLevels := []*bool {
  56                 flag.Bool("i",    false, "Show pads function in the comments"),
  57                 flag.Bool("ii",   false, "Show DW0/DW1 value in the comments"),
  58                 flag.Bool("iii",  false, "Show ignored bit fields in the comments"),
  59                 flag.Bool("iiii", false, "Show target PAD_CFG() macro in the comments"),
  60         }
  61
  62         template := flag.Int("t", 0, "template type number\n"+
  63                 "\t0 - inteltool.log (default)\n"+
  64                 "\t1 - gpio.h\n"+
  65                 "\t2 - your template\n\t")
  66
  67         platform :=  flag.String("p", "snr", "set platform:\n"+
  68                 "\tsnr - Sunrise PCH or Skylake/Kaby Lake SoC\n"+
  69                 "\tlbg - Lewisburg PCH with Xeon SP\n"+
  70                 "\tapl - Apollo Lake SoC\n"+
  71                 "\tcnl - CannonLake-LP or Whiskeylake/Coffeelake/Cometlake-U SoC\n"+
  72                 "\ttgl - TigerLake-H SoC\n"+
  73                 "\tadl - AlderLake PCH\n"+
  74                 "\tjsl - Jasper Lake SoC\n"+
  75                 "\tmtl - MeteorLake SoC\n"+
  76                 "\tebg - Emmitsburg PCH with Xeon SP\n")
  77
  78         fieldstyle :=  flag.String("fld", "none", "set fields macros style:\n"+
  79                 "\tcb  - use coreboot style for bit fields macros\n"+
  80                 "\tfsp - use fsp style\n"+
  81                 "\traw - do not convert, print as is\n")
  82
  83         flag.Parse()
  84
  85         config.IgnoredFieldsFlagSet(*ignFlag)
  86         config.NonCheckingFlagSet(*nonCheckFlag)
  87
  88         for level, flag := range infoLevels {
  89                 if *flag {
  90                         config.InfoLevelSet(level + 1)
  91                         fmt.Printf("Info level: Use level %d!\n", level + 1)
  92                         break
  93                 }
  94         }
  95
  96         if !config.TemplateSet(*template) {
  97                 fmt.Printf("Error! Unknown template format of input file!\n")
  98                 os.Exit(1)
  99         }
 100
 101         if valid := config.PlatformSet(*platform); valid != 0 {
 102                 fmt.Printf("Error: invalid platform -%s!\n", *platform)
 103                 os.Exit(1)
 104         }
 105
 106         fmt.Println("Log file:", *inputFileName)
 107         fmt.Println("Output generated file:", *outputFileName)
 108
 109         inputRegDumpFile, err := os.Open(*inputFileName)
 110         if err != nil {
 111                 fmt.Printf("Error: inteltool log file was not found!\n")
 112                 os.Exit(1)
 113         }
 114
 115         if config.FldStyleSet(*fieldstyle) != 0 {
 116                 fmt.Printf("Error! Unknown bit fields style option -%s!\n", *fieldstyle)
 117                 os.Exit(1)
 118         }
 119
 120         // create dir for output files
 121         err = os.MkdirAll("generate", os.ModePerm)
 122         if err != nil {
 123                 fmt.Printf("Error! Can not create a directory for the generated files!\n")
 124                 os.Exit(1)
 125         }
 126
 127         // create empty gpio.h file
 128         outputGenFile, err := os.Create(*outputFileName)
 129         if err != nil {
 130                 fmt.Printf("Error: unable to generate GPIO config file!\n")
 131                 os.Exit(1)
 132         }
 133
 134         defer inputRegDumpFile.Close()
 135         defer outputGenFile.Close()
 136
 137         config.OutputGenFile = outputGenFile
 138         config.InputRegDumpFile = inputRegDumpFile
 139
 140         parser := parser.ParserData{}
 141         parser.Parse()
 142
 143         // gpio.h
 144         err = generateOutputFile(&parser)
 145         if err != nil {
 146                 fmt.Printf("Error! Can not create the file with GPIO configuration!\n")
 147                 os.Exit(1)
 148         }
 149 }