1  // SPDX-License-Identifier: GPL-2.0-only
  2  package main
  3  
  4  import (
  5  	"bufio"
  6  	"flag"
  7  	"fmt"
  8  	"log"
  9  	"os"
 10  	"path/filepath"
 11  	"regexp"
 12  	"review.coreboot.org/coreboot.git/util/hda-decoder/decoder"
 13  	"strconv"
 14  	"strings"
 15  )
 16  
 17  type decodeOperation int
 18  
 19  const (
 20  	decodeToHumanReadable decodeOperation = iota
 21  	decodeToVerbs
 22  )
 23  
 24  var indentLevel int = 0
 25  
 26  func indentedPrintf(format string, args ...interface{}) (n int, err error) {
 27  	s := fmt.Sprintf("%s%s", strings.Repeat("\t", indentLevel), format)
 28  	return fmt.Printf(s, args...)
 29  }
 30  
 31  func stringToUint32(s string) uint32 {
 32  	s = strings.Replace(s, "0x", "", -1)
 33  	v, err := strconv.ParseUint(s, 16, 32)
 34  	if err != nil {
 35  		log.Fatal(err)
 36  	}
 37  	return uint32(v)
 38  }
 39  
 40  func decodeConfig(config uint32) {
 41  	out := decoder.ToHumanReadable(decoder.Decode(config))
 42  
 43  	indentedPrintf("%s,\n", out.PortConnectivity)
 44  	indentedPrintf("%s,\n", out.Location)
 45  	indentedPrintf("%s,\n", out.DefaultDevice)
 46  	indentedPrintf("%s,\n", out.ConnectionType)
 47  	indentedPrintf("%s,\n", out.Color)
 48  	indentedPrintf("%s,\n", out.Misc)
 49  	indentedPrintf("%s, %s\n", out.DefaultAssociation, out.Sequence)
 50  }
 51  
 52  func printDisconnectedPort(config uint32) {
 53  	// The value 0x411111f0 is not defined in the specification, but is a
 54  	// common value vendors use to indicate "not connected".
 55  	const nc uint32 = 0x411111f0
 56  
 57  	// Setting some values (e.g. 0x40000000) as `AZALIA_PIN_CFG_NC(0)` is
 58  	// probably harmless. However, we will stay on the safe side for now.
 59  	if (config & 0xfffffff0) != nc {
 60  		// Do not decode these values, as they would likely describe a
 61  		// bogus device which could be slighly confusing.
 62  		fmt.Printf("0x%08x), // does not describe a jack or internal device\n", config)
 63  	} else {
 64  		fmt.Printf("AZALIA_PIN_CFG_NC(%d)),\n", (config & 0x0000000f))
 65  	}
 66  }
 67  
 68  func decodeFile(path string, codec uint32, operation decodeOperation) {
 69  	file, err := os.Open(path)
 70  	if err != nil {
 71  		log.Fatal(err)
 72  	}
 73  	defer file.Close()
 74  
 75  	scanner := bufio.NewScanner(file)
 76  
 77  	for scanner.Scan() {
 78  		fields := strings.Fields(scanner.Text())
 79  		if len(fields) != 2 {
 80  			fmt.Print("// Something went wrong\n")
 81  			continue
 82  		}
 83  
 84  		pin := stringToUint32(fields[0])
 85  		config := stringToUint32(fields[1])
 86  
 87  		switch operation {
 88  		case decodeToVerbs:
 89  			fmt.Printf("address: %d, node ID: %#02x, configuration default: %#08x\n",
 90  				codec, pin, config)
 91  
 92  			verbs := decoder.ConfigToVerbs(codec, pin, config)
 93  			fmt.Printf("  %#08x\n", verbs[0])
 94  			fmt.Printf("  %#08x\n", verbs[1])
 95  			fmt.Printf("  %#08x\n", verbs[2])
 96  			fmt.Printf("  %#08x\n", verbs[3])
 97  		case decodeToHumanReadable:
 98  			indentedPrintf("AZALIA_PIN_CFG(%d, 0x%02x, ", codec, pin)
 99  			if decoder.PortIsConnected(config) {
100  				fmt.Printf("AZALIA_PIN_DESC(\n")
101  				indentLevel += 1
102  				decodeConfig(config)
103  				indentLevel -= 1
104  				indentedPrintf(")),\n")
105  			} else {
106  				printDisconnectedPort(config)
107  			}
108  		}
109  	}
110  }
111  
112  func getFileContents(path string) string {
113  	contents, err := os.ReadFile(path)
114  	if err != nil {
115  		log.Fatal(err)
116  	}
117  	return strings.TrimSpace(string(contents))
118  }
119  
120  func getLineCount(path string) int {
121  	return len(strings.Split(getFileContents(path), "\n"))
122  }
123  
124  func decodeDeviceCodec(path string, codec uint32, isLastCodec bool, generate bool) {
125  	if generate {
126  		vendorId := getFileContents(path + "/vendor_id")
127  		vendorName := getFileContents(path + "/vendor_name")
128  		chipName := getFileContents(path + "/chip_name")
129  		subsystemId := getFileContents(path + "/subsystem_id")
130  		lineCount := getLineCount(path + "/init_pin_configs")
131  
132  		indentedPrintf("%s, // Vendor/Device ID: %s %s\n", vendorId, vendorName, chipName)
133  		indentedPrintf("%s, // Subsystem ID\n", subsystemId)
134  		indentedPrintf("%d,\n", lineCount+1)
135  		indentedPrintf("AZALIA_SUBVENDOR(%d, %s),\n\n", codec, subsystemId)
136  	}
137  
138  	decodeFile(path+"/init_pin_configs", codec, decodeToHumanReadable)
139  	if !isLastCodec {
140  		fmt.Printf("\n")
141  	}
142  }
143  
144  func decodeDeviceCodecs(generate bool) {
145  	matches, err := filepath.Glob("/sys/class/sound/hwC0D*")
146  	if err != nil {
147  		log.Fatal(err)
148  	}
149  	re := regexp.MustCompile(`D([0-9]+)$`)
150  
151  	for i, match := range matches {
152  		codec := stringToUint32(re.FindStringSubmatch(match)[1])
153  		isLastCodec := (i + 1) == len(matches)
154  
155  		decodeDeviceCodec(match, codec, isLastCodec, generate)
156  	}
157  }
158  
159  func isFlagPassed(name string) bool {
160  	found := false
161  
162  	flag.Visit(func(f *flag.Flag) {
163  		if f.Name == name {
164  			found = true
165  		}
166  	})
167  	return found
168  }
169  
170  func main() {
171  	codec := flag.Uint64("codec", 0, "Set the codec number when decoding a file\n"+
172  		"This flag is only meaningful in combination with the 'file' flag")
173  	config := flag.Uint64("config", 0, "Decode a single configuration")
174  	file := flag.String("file", "", "Decode configurations in a file\n"+
175  		"The decoder assumes each line in the file has the format: <pin> <config>")
176  	generate := flag.Bool("generate", false, "Automatically generate hda_verb.c for the host device")
177  	toVerbs := flag.Bool("to-verbs", false, "Convert configuration defaults to their corresponding verbs\n"+
178  		"This flag is only meaningful in combination with the 'file' flag")
179  	flag.Parse()
180  
181  	operation := decodeToHumanReadable
182  	if *toVerbs {
183  		operation = decodeToVerbs
184  	}
185  
186  	if isFlagPassed("config") {
187  		decodeConfig(uint32(*config))
188  	} else if isFlagPassed("file") {
189  		decodeFile(*file, uint32(*codec), operation)
190  	} else {
191  		if *generate {
192  			fmt.Printf("/* SPDX-License-Identifier: GPL-2.0-only */\n\n")
193  			fmt.Printf("#include <device/azalia_device.h>\n\n")
194  			fmt.Printf("const u32 cim_verb_data[] = {\n")
195  			indentLevel += 1
196  		}
197  		decodeDeviceCodecs(*generate)
198  		if *generate {
199  			indentLevel -= 1
200  			fmt.Printf("};\n\n")
201  			fmt.Printf("const u32 pc_beep_verbs[] = {};\n")
202  			fmt.Printf("AZALIA_ARRAY_SIZES;\n")
203  		}
204  	}
205  }