util/spd_tools/src/part_id_gen/part_id_gen.go - coreboot - Gitiles

 /* SPDX-License-Identifier: GPL-2.0-or-later */

 package main

 import (
 	"encoding/csv"
 	"fmt"
 	"io"
 	"io/ioutil"
 	"log"
 	"os"
 	"path/filepath"
 	"strconv"
 	"strings"
 )

 /*
  * This program allocates DRAM strap IDs for different parts that are being used by the variant.
  *
  * It expects the following inputs:
  *  Name of the SoC platform, e.g. TGL.
  *  Memory technology used by the variant, e.g. lp4x.
  *  Path to Makefile directory. Makefile.mk generated by this program is placed in this
  *  location.
  *  Text file containing a list of memory part names used by the board. Each line in the file
  *  is expected to have one memory part name.
  */
 const (
 	SPDManifestFileName       = "parts_spd_manifest.generated.txt"
 	PlatformsManifestFileName = "platforms_manifest.generated.txt"
 	SPDEmptyFileName          = "spd-empty.hex"
 	MakefileName              = "Makefile.mk"
 	DRAMIdFileName            = "dram_id.generated.txt"
 	MaxMemoryId               = 15
 )

 var supportedPlatforms = [...]string{
 	"TGL",
 	"ADL",
 	"JSL",
 	"PCO",
 	"CZN",
 	"MDN",
 	"MTL",
 	"PHX",
 }

 var supportedMemTechs = [...]string{
 	"lp4x",
 	"ddr4",
 	"lp5",
 }

 func usage() {
 	fmt.Printf("\nUsage: %s <platform> <mem_technology> <makefile_dir> <mem_parts_used_file>\n\n", os.Args[0])
 	fmt.Printf("   where,\n")
 	fmt.Printf("   platform = SoC platform which the board is based on\n")
 	fmt.Printf("              supported platforms: %v\n", supportedPlatforms)
 	fmt.Printf("   mem_technology = Memory technology used by the board\n")
 	fmt.Printf("                    supported technologies: %v\n", supportedMemTechs)
 	fmt.Printf("   makefile_dir = Directory path where generated Makefile.mk should be placed\n")
 	fmt.Printf("   mem_parts_used_file = CSV file containing list of memory parts used by the board and optional fixed ids\n\n\n")
 }

 func checkArgs(platform string, memTech string, makefileDir string, memPartsUsedFile string) error {
 	supported := false
 	for _, p := range supportedPlatforms {
 		if strings.ToUpper(platform) == p {
 			supported = true
 			break
 		}
 	}
 	if !supported {
 		return fmt.Errorf("Platform %s is not supported", platform)
 	}

 	supported = false
 	for _, m := range supportedMemTechs {
 		if strings.ToLower(memTech) == m {
 			supported = true
 			break
 		}
 	}
 	if !supported {
 		return fmt.Errorf("Memory technology %s is not supported", memTech)
 	}

 	if _, err := os.Stat(makefileDir); err != nil {
 		return fmt.Errorf("Invalid makefile_dir %s: %v", makefileDir, err)
 	}

 	if _, err := os.Stat(memPartsUsedFile); err != nil {
 		return fmt.Errorf("Invalid mem_parts_used_file %s: %v", memPartsUsedFile, err)
 	}

 	return nil
 }

 type mappingType int

 const (
 	Auto mappingType = iota
 	Fixed
 	Exclusive
 )

 type usedPart struct {
 	partName    string
 	index       int
 	mapping     mappingType
 	SPDOverride string
 }

 func readPlatformsManifest(memTech string) (map[string]string, error) {
 	manifestFilePath := filepath.Join("spd", strings.ToLower(memTech), PlatformsManifestFileName)
 	f, err := os.Open(manifestFilePath)
 	if err != nil {
 		return nil, err
 	}
 	defer f.Close()
 	r := csv.NewReader(f)
 	r.Comment = '#'

 	platformToSetMap := make(map[string]string)

 	for {
 		fields, err := r.Read()

 		if err == io.EOF {
 			break
 		}

 		if err != nil {
 			return nil, err
 		}

 		if len(fields) != 2 {
 			return nil, fmt.Errorf("Platforms manifest file is incorrectly formatted: %s", manifestFilePath)
 		}

 		platformToSetMap[fields[0]] = fields[1]
 	}

 	return platformToSetMap, nil
 }

 func getSPDDir(platform string, memTech string) (string, error) {
 	platformToSetMap, err := readPlatformsManifest(memTech)
 	if err != nil {
 		return "", err
 	}

 	setName, ok := platformToSetMap[strings.ToUpper(platform)]
 	if !ok {
 		return "", fmt.Errorf("Platform %s does not support memory technology %s", platform, memTech)
 	}

 	return filepath.Join("spd", strings.ToLower(memTech), setName), nil
 }

 /*
  * Read input file CSV that contains list of memory part names used by the variant
  * and an optional assigned id.
  */
 func readParts(memPartsUsedFileName string) ([]usedPart, error) {
 	f, err := os.Open(memPartsUsedFileName)
 	if err != nil {
 		return nil, err
 	}
 	defer f.Close()
 	r := csv.NewReader(f)
 	r.FieldsPerRecord = -1 // Allow variable length records
 	r.TrimLeadingSpace = true
 	r.Comment = '#'

 	parts := []usedPart{}

 	for {
 		fields, err := r.Read()

 		if err == io.EOF {
 			break
 		}

 		if err != nil {
 			return nil, err
 		}

 		if len(fields) == 1 {
 			parts = append(parts, usedPart{fields[0], -1, Auto, ""})
 		} else {
 			var mapping = Auto
 			var assignedId = -1
 			var err error = nil
 			var spdOverride string = ""

 			// Second column, ID override
 			if len(fields) >= 2 {
 				if len(fields[1]) >= 2 && fields[1][0] == '*' {
 					// Exclusive mapping
 					mapping = Exclusive
 					assignedId, err = strconv.Atoi(fields[1][1:])
 				} else if fields[1] != "" {
 					// Fixed mapping
 					mapping = Fixed
 					assignedId, err = strconv.Atoi(fields[1])
 				}
 			}

 			// Third column, SPD file override
 			if len(fields) >= 3 {
 				if len(fields[2]) == 0 {
 					err = fmt.Errorf("mem_parts_used_file file is incorrectly formatted, SPD file column is empty")
 				} else {
 					spdOverride = fields[2]
 				}
 			}

 			if err != nil {
 				return nil, err
 			}

 			if assignedId > MaxMemoryId {
 				return nil, fmt.Errorf("Out of bounds assigned id %d for part %s", assignedId, fields[0])
 			}

 			parts = append(parts, usedPart{fields[0], assignedId, mapping, spdOverride})
 		}
 	}

 	return parts, nil
 }

 /*
  * Read SPD manifest file(CSV) generated by gen_spd program and generate two maps:
  * 1. Part to SPD Map : This maps global memory part name to generated SPD file name
  * 2. SPD to Index Map: This generates a map of deduplicated SPD file names to index assigned to
  *                      that SPD. This function sets the index for all SPDs to -1. This index gets
  *                      updated as part of genPartIdInfo() depending upon the SPDs actually used
  *                      by the variant.
  */
 func readSPDManifest(SPDDirName string) (map[string]string, map[string]int, error) {
 	f, err := os.Open(filepath.Join(SPDDirName, SPDManifestFileName))
 	if err != nil {
 		return nil, nil, err
 	}
 	defer f.Close()
 	r := csv.NewReader(f)
 	r.Comment = '#'

 	partToSPDMap := make(map[string]string)
 	SPDToIndexMap := make(map[string]int)

 	for {
 		fields, err := r.Read()

 		if err == io.EOF {
 			break
 		}

 		if err != nil {
 			return nil, nil, err
 		}

 		if len(fields) != 2 {
 			return nil, nil, fmt.Errorf("CSV file is incorrectly formatted")
 		}

 		partToSPDMap[fields[0]] = fields[1]
 		SPDToIndexMap[fields[1]] = -1
 	}

 	return partToSPDMap, SPDToIndexMap, nil
 }

 /* Print information about memory part used by variant and ID assigned to it. */
 func appendPartIdInfo(s *string, partName string, index int) {
 	*s += fmt.Sprintf("%-30s %d (%04b)\n", partName, index, int64(index))
 }

 type partIds struct {
 	SPDFileName string
 	memParts    string
 }

 func getFileHeader() string {
 	return `# SPDX-License-Identifier: GPL-2.0-or-later
 # This is an auto-generated file. Do not edit!!
 # Generated by:
 ` + fmt.Sprintf("# %s\n\n", strings.Join(os.Args[0:], " "))
 }

 /*
  * For each part used by the variant, check if the SPD (as per the manifest) already has an ID
  * assigned to it. If yes, then add the part name to the list of memory parts supported by the
  * SPD entry. If not, then assign the next ID to the SPD file and add the part name to the
  * list of memory parts supported by the SPD entry.
  *
  * Returns list of partIds that contains spdFileName and supported memory parts for each
  * assigned ID.
  */
 func genPartIdInfo(parts []usedPart, partToSPDMap map[string]string, SPDToIndexMap map[string]int, makefileDirName string) ([]partIds, error) {
 	partIdList := []partIds{}
 	assignedMapping := []mappingType{}
 	var s string

 	// Assign parts with fixed ids first
 	for _, p := range parts {
 		if p.index == -1 {
 			continue
 		}

 		if p.partName == "" {
 			return nil, fmt.Errorf("Invalid part entry")
 		}

 		SPDFileName, ok := partToSPDMap[p.partName]
 		if !ok {
 			return nil, fmt.Errorf("Failed to find part %s in SPD Manifest. Please add the part to global part list and regenerate SPD Manifest", p.partName)
 		}

 		// Extend partIdList and assignedMapping with empty entries if needed
 		for i := len(partIdList) - 1; i < p.index; i++ {
 			partIdList = append(partIdList, partIds{})
 			assignedMapping = append(assignedMapping, Auto)
 		}

 		// Only allow parts with the same index if they share the same SPD
 		assignedSPD := partIdList[p.index].SPDFileName
 		if assignedSPD != "" && assignedSPD != partToSPDMap[p.partName] {
 			return nil, fmt.Errorf("ID %d is already assigned to %s, conflicting with %s(%s)", p.index, assignedSPD, p.partName, SPDFileName)
 		}

 		mapping := assignedMapping[p.index]
 		if (mapping == Fixed && p.mapping == Exclusive) || (mapping == Exclusive && p.mapping == Fixed) {
 			return nil, fmt.Errorf("Exclusive/non-exclusive conflict in assigning %s to ID %d", p.partName, p.index)
 		} else {
 			assignedMapping[p.index] = p.mapping
 		}

 		if partIdList[p.index].memParts == "" {
 			partIdList[p.index] = partIds{SPDFileName: SPDFileName, memParts: p.partName}
 		} else {
 			partIdList[p.index].memParts += ", " + p.partName
 		}

 		// SPDToIndexMap should point to first assigned index in the used part list
 		// Exclusive entries don't update the map because they're not valid for auto assigning
 		if SPDToIndexMap[SPDFileName] < 0 && p.mapping != Exclusive {
 			SPDToIndexMap[SPDFileName] = p.index
 		}
 	}

 	s += fmt.Sprintf("%-30s %s\n", "DRAM Part Name", "ID to assign")

 	// Assign parts with no fixed id
 	for _, p := range parts {
 		if p.partName == "" {
 			return nil, fmt.Errorf("Invalid part entry")
 		}

 		// Add assigned parts to dram id file in the order they appear
 		if p.index != -1 {
 			appendPartIdInfo(&s, p.partName, p.index)
 			continue
 		}

 		SPDFileName, ok := partToSPDMap[p.partName]
 		if !ok {
 			return nil, fmt.Errorf("Failed to find part ", p.partName, " in SPD Manifest. Please add the part to global part list and regenerate SPD Manifest")
 		}

 		index := SPDToIndexMap[SPDFileName]
 		// Only Exclusive mappings don't allow automatic assigning of parts
 		if index != -1 && assignedMapping[index] != Exclusive {
 			partIdList[index].memParts += ", " + p.partName
 			appendPartIdInfo(&s, p.partName, index)
 			continue
 		}

 		// Find first empty index
 		for i, partId := range partIdList {
 			if partId.SPDFileName == "" {
 				index = i
 				break
 			}
 		}

 		// Append new entry
 		if index == -1 {
 			index = len(partIdList)
 			if index > MaxMemoryId {
 				return nil, fmt.Errorf("Maximum part ID %d exceeded.", MaxMemoryId)
 			}
 			partIdList = append(partIdList, partIds{})
 			assignedMapping = append(assignedMapping, Auto)
 		}

 		SPDToIndexMap[SPDFileName] = index
 		appendPartIdInfo(&s, p.partName, index)
 		partIdList[index] = partIds{SPDFileName: SPDFileName, memParts: p.partName}
 	}

 	fmt.Printf("%s", s)

 	s = getFileHeader() + s
 	err := ioutil.WriteFile(filepath.Join(makefileDirName, DRAMIdFileName), []byte(s), 0644)

 	return partIdList, err
 }

 /*
  * This function generates Makefile.mk under the variant directory path and adds assigned SPDs
  * to SPD_SOURCES.
  */
 func genMakefile(partIdList []partIds, makefileDirName string, SPDDir string, partsDir string) error {
 	s := getFileHeader()
 	s += fmt.Sprintf("SPD_SOURCES =\n")

 	for i := 0; i < len(partIdList); i++ {
 		if partIdList[i].SPDFileName == "" {
 			s += fmt.Sprintf("SPD_SOURCES += %v ", filepath.Join(SPDDir, SPDEmptyFileName))
 			s += fmt.Sprintf("     # ID = %d(0b%04b)\n", i, int64(i))
 		} else {
 			SPDFileName := partIdList[i].SPDFileName
 			path := filepath.Join(partsDir, SPDFileName)

 			// Check if the file exists in the directory of the parts file
 			if _, err := os.Stat(path); err != nil {
 				// File doesn't exist, check spd directory
 				path = filepath.Join(SPDDir, SPDFileName)
 				if _, err = os.Stat(path); err != nil {
 					return fmt.Errorf("Failed to write Makefile, SPD file '%s' doesn't exist", SPDFileName)
 				}
 			}
 			s += fmt.Sprintf("SPD_SOURCES += %v ", path)
 			s += fmt.Sprintf("     # ID = %d(0b%04b) ", i, int64(i))
 			s += fmt.Sprintf(" Parts = %04s\n", partIdList[i].memParts)
 		}
 	}

 	return ioutil.WriteFile(filepath.Join(makefileDirName, MakefileName), []byte(s), 0644)
 }

 func main() {
 	if len(os.Args) != 5 {
 		usage()
 		log.Fatal("Incorrect number of arguments")
 	}

 	platform, memTech, makefileDir, memPartsUsedFile := os.Args[1], os.Args[2], os.Args[3], os.Args[4]

 	err := checkArgs(platform, memTech, makefileDir, memPartsUsedFile)
 	if err != nil {
 		log.Fatal(err)
 	}

 	SPDDir, err := getSPDDir(platform, memTech)
 	if err != nil {
 		log.Fatal(err)
 	}

 	partToSPDMap, SPDToIndexMap, err := readSPDManifest(SPDDir)
 	if err != nil {
 		log.Fatal(err)
 	}

 	parts, err := readParts(memPartsUsedFile)
 	if err != nil {
 		log.Fatal(err)
 	}

 	// Update our SPD maps with part specific overrides
 	for _, p := range parts {
 		if p.SPDOverride != "" {
 			partToSPDMap[p.partName] = p.SPDOverride
 			SPDToIndexMap[p.SPDOverride] = -1
 		}
 	}

 	partIdList, err := genPartIdInfo(parts, partToSPDMap, SPDToIndexMap, makefileDir)
 	if err != nil {
 		log.Fatal(err)
 	}

 	if err := genMakefile(partIdList, makefileDir, SPDDir, filepath.Dir(memPartsUsedFile)); err != nil {
 		log.Fatal(err)
 	}
 }
	/* SPDX-License-Identifier: GPL-2.0-or-later */

	package main

	import (
	"encoding/csv"
	"fmt"
	"io"
	"io/ioutil"
	"log"
	"os"
	"path/filepath"
	"strconv"
	"strings"
	)

	/*
	* This program allocates DRAM strap IDs for different parts that are being used by the variant.
	*
	* It expects the following inputs:
	* Name of the SoC platform, e.g. TGL.
	* Memory technology used by the variant, e.g. lp4x.
	* Path to Makefile directory. Makefile.mk generated by this program is placed in this
	* location.
	* Text file containing a list of memory part names used by the board. Each line in the file
	* is expected to have one memory part name.
	*/
	const (
	SPDManifestFileName = "parts_spd_manifest.generated.txt"
	PlatformsManifestFileName = "platforms_manifest.generated.txt"
	SPDEmptyFileName = "spd-empty.hex"
	MakefileName = "Makefile.mk"
	DRAMIdFileName = "dram_id.generated.txt"
	MaxMemoryId = 15
	)

	var supportedPlatforms = [...]string{
	"TGL",
	"ADL",
	"JSL",
	"PCO",
	"CZN",
	"MDN",
	"MTL",
	"PHX",
	}

	var supportedMemTechs = [...]string{
	"lp4x",
	"ddr4",
	"lp5",
	}

	func usage() {
	fmt.Printf("\nUsage: %s <platform> <mem_technology> <makefile_dir> <mem_parts_used_file>\n\n", os.Args[0])
	fmt.Printf(" where,\n")
	fmt.Printf(" platform = SoC platform which the board is based on\n")
	fmt.Printf(" supported platforms: %v\n", supportedPlatforms)
	fmt.Printf(" mem_technology = Memory technology used by the board\n")
	fmt.Printf(" supported technologies: %v\n", supportedMemTechs)
	fmt.Printf(" makefile_dir = Directory path where generated Makefile.mk should be placed\n")
	fmt.Printf(" mem_parts_used_file = CSV file containing list of memory parts used by the board and optional fixed ids\n\n\n")
	}

	func checkArgs(platform string, memTech string, makefileDir string, memPartsUsedFile string) error {
	supported := false
	for _, p := range supportedPlatforms {
	if strings.ToUpper(platform) == p {
	supported = true
	break
	}
	}
	if !supported {
	return fmt.Errorf("Platform %s is not supported", platform)
	}

	supported = false
	for _, m := range supportedMemTechs {
	if strings.ToLower(memTech) == m {
	supported = true
	break
	}
	}
	if !supported {
	return fmt.Errorf("Memory technology %s is not supported", memTech)
	}

	if _, err := os.Stat(makefileDir); err != nil {
	return fmt.Errorf("Invalid makefile_dir %s: %v", makefileDir, err)
	}

	if _, err := os.Stat(memPartsUsedFile); err != nil {
	return fmt.Errorf("Invalid mem_parts_used_file %s: %v", memPartsUsedFile, err)
	}

	return nil
	}

	type mappingType int

	const (
	Auto mappingType = iota
	Fixed
	Exclusive
	)

	type usedPart struct {
	partName string
	index int
	mapping mappingType
	SPDOverride string
	}

	func readPlatformsManifest(memTech string) (map[string]string, error) {
	manifestFilePath := filepath.Join("spd", strings.ToLower(memTech), PlatformsManifestFileName)
	f, err := os.Open(manifestFilePath)
	if err != nil {
	return nil, err
	}
	defer f.Close()
	r := csv.NewReader(f)
	r.Comment = '#'

	platformToSetMap := make(map[string]string)

	for {
	fields, err := r.Read()

	if err == io.EOF {
	break
	}

	if err != nil {
	return nil, err
	}

	if len(fields) != 2 {
	return nil, fmt.Errorf("Platforms manifest file is incorrectly formatted: %s", manifestFilePath)
	}

	platformToSetMap[fields[0]] = fields[1]
	}

	return platformToSetMap, nil
	}

	func getSPDDir(platform string, memTech string) (string, error) {
	platformToSetMap, err := readPlatformsManifest(memTech)
	if err != nil {
	return "", err
	}

	setName, ok := platformToSetMap[strings.ToUpper(platform)]
	if !ok {
	return "", fmt.Errorf("Platform %s does not support memory technology %s", platform, memTech)
	}

	return filepath.Join("spd", strings.ToLower(memTech), setName), nil
	}

	/*
	* Read input file CSV that contains list of memory part names used by the variant
	* and an optional assigned id.
	*/
	func readParts(memPartsUsedFileName string) ([]usedPart, error) {
	f, err := os.Open(memPartsUsedFileName)
	if err != nil {
	return nil, err
	}
	defer f.Close()
	r := csv.NewReader(f)
	r.FieldsPerRecord = -1 // Allow variable length records
	r.TrimLeadingSpace = true
	r.Comment = '#'

	parts := []usedPart{}

	for {
	fields, err := r.Read()

	if err == io.EOF {
	break
	}

	if err != nil {
	return nil, err
	}

	if len(fields) == 1 {
	parts = append(parts, usedPart{fields[0], -1, Auto, ""})
	} else {
	var mapping = Auto
	var assignedId = -1
	var err error = nil
	var spdOverride string = ""

	// Second column, ID override
	if len(fields) >= 2 {
	if len(fields[1]) >= 2 && fields[1][0] == '*' {
	// Exclusive mapping
	mapping = Exclusive
	assignedId, err = strconv.Atoi(fields[1][1:])
	} else if fields[1] != "" {
	// Fixed mapping
	mapping = Fixed
	assignedId, err = strconv.Atoi(fields[1])
	}
	}

	// Third column, SPD file override
	if len(fields) >= 3 {
	if len(fields[2]) == 0 {
	err = fmt.Errorf("mem_parts_used_file file is incorrectly formatted, SPD file column is empty")
	} else {
	spdOverride = fields[2]
	}
	}

	if err != nil {
	return nil, err
	}

	if assignedId > MaxMemoryId {
	return nil, fmt.Errorf("Out of bounds assigned id %d for part %s", assignedId, fields[0])
	}

	parts = append(parts, usedPart{fields[0], assignedId, mapping, spdOverride})
	}
	}

	return parts, nil
	}

	/*
	* Read SPD manifest file(CSV) generated by gen_spd program and generate two maps:
	* 1. Part to SPD Map : This maps global memory part name to generated SPD file name
	* 2. SPD to Index Map: This generates a map of deduplicated SPD file names to index assigned to
	* that SPD. This function sets the index for all SPDs to -1. This index gets
	* updated as part of genPartIdInfo() depending upon the SPDs actually used
	* by the variant.
	*/
	func readSPDManifest(SPDDirName string) (map[string]string, map[string]int, error) {
	f, err := os.Open(filepath.Join(SPDDirName, SPDManifestFileName))
	if err != nil {
	return nil, nil, err
	}
	defer f.Close()
	r := csv.NewReader(f)
	r.Comment = '#'

	partToSPDMap := make(map[string]string)
	SPDToIndexMap := make(map[string]int)

	for {
	fields, err := r.Read()

	if err == io.EOF {
	break
	}

	if err != nil {
	return nil, nil, err
	}

	if len(fields) != 2 {
	return nil, nil, fmt.Errorf("CSV file is incorrectly formatted")
	}

	partToSPDMap[fields[0]] = fields[1]
	SPDToIndexMap[fields[1]] = -1
	}

	return partToSPDMap, SPDToIndexMap, nil
	}

	/* Print information about memory part used by variant and ID assigned to it. */
	func appendPartIdInfo(s *string, partName string, index int) {
	*s += fmt.Sprintf("%-30s %d (%04b)\n", partName, index, int64(index))
	}

	type partIds struct {
	SPDFileName string
	memParts string
	}

	func getFileHeader() string {
	return `# SPDX-License-Identifier: GPL-2.0-or-later
	# This is an auto-generated file. Do not edit!!
	# Generated by:
	` + fmt.Sprintf("# %s\n\n", strings.Join(os.Args[0:], " "))
	}

	/*
	* For each part used by the variant, check if the SPD (as per the manifest) already has an ID
	* assigned to it. If yes, then add the part name to the list of memory parts supported by the
	* SPD entry. If not, then assign the next ID to the SPD file and add the part name to the
	* list of memory parts supported by the SPD entry.
	*
	* Returns list of partIds that contains spdFileName and supported memory parts for each
	* assigned ID.
	*/
	func genPartIdInfo(parts []usedPart, partToSPDMap map[string]string, SPDToIndexMap map[string]int, makefileDirName string) ([]partIds, error) {
	partIdList := []partIds{}
	assignedMapping := []mappingType{}
	var s string

	// Assign parts with fixed ids first
	for _, p := range parts {
	if p.index == -1 {
	continue
	}

	if p.partName == "" {
	return nil, fmt.Errorf("Invalid part entry")
	}

	SPDFileName, ok := partToSPDMap[p.partName]
	if !ok {
	return nil, fmt.Errorf("Failed to find part %s in SPD Manifest. Please add the part to global part list and regenerate SPD Manifest", p.partName)
	}

	// Extend partIdList and assignedMapping with empty entries if needed
	for i := len(partIdList) - 1; i < p.index; i++ {
	partIdList = append(partIdList, partIds{})
	assignedMapping = append(assignedMapping, Auto)
	}

	// Only allow parts with the same index if they share the same SPD
	assignedSPD := partIdList[p.index].SPDFileName
	if assignedSPD != "" && assignedSPD != partToSPDMap[p.partName] {
	return nil, fmt.Errorf("ID %d is already assigned to %s, conflicting with %s(%s)", p.index, assignedSPD, p.partName, SPDFileName)
	}

	mapping := assignedMapping[p.index]
	if (mapping == Fixed && p.mapping == Exclusive) \|\| (mapping == Exclusive && p.mapping == Fixed) {
	return nil, fmt.Errorf("Exclusive/non-exclusive conflict in assigning %s to ID %d", p.partName, p.index)
	} else {
	assignedMapping[p.index] = p.mapping
	}

	if partIdList[p.index].memParts == "" {
	partIdList[p.index] = partIds{SPDFileName: SPDFileName, memParts: p.partName}
	} else {
	partIdList[p.index].memParts += ", " + p.partName
	}

	// SPDToIndexMap should point to first assigned index in the used part list
	// Exclusive entries don't update the map because they're not valid for auto assigning
	if SPDToIndexMap[SPDFileName] < 0 && p.mapping != Exclusive {
	SPDToIndexMap[SPDFileName] = p.index
	}
	}

	s += fmt.Sprintf("%-30s %s\n", "DRAM Part Name", "ID to assign")

	// Assign parts with no fixed id
	for _, p := range parts {
	if p.partName == "" {
	return nil, fmt.Errorf("Invalid part entry")
	}

	// Add assigned parts to dram id file in the order they appear
	if p.index != -1 {
	appendPartIdInfo(&s, p.partName, p.index)
	continue
	}

	SPDFileName, ok := partToSPDMap[p.partName]
	if !ok {
	return nil, fmt.Errorf("Failed to find part ", p.partName, " in SPD Manifest. Please add the part to global part list and regenerate SPD Manifest")
	}

	index := SPDToIndexMap[SPDFileName]
	// Only Exclusive mappings don't allow automatic assigning of parts
	if index != -1 && assignedMapping[index] != Exclusive {
	partIdList[index].memParts += ", " + p.partName
	appendPartIdInfo(&s, p.partName, index)
	continue
	}

	// Find first empty index
	for i, partId := range partIdList {
	if partId.SPDFileName == "" {
	index = i
	break
	}
	}

	// Append new entry
	if index == -1 {
	index = len(partIdList)
	if index > MaxMemoryId {
	return nil, fmt.Errorf("Maximum part ID %d exceeded.", MaxMemoryId)
	}
	partIdList = append(partIdList, partIds{})
	assignedMapping = append(assignedMapping, Auto)
	}

	SPDToIndexMap[SPDFileName] = index
	appendPartIdInfo(&s, p.partName, index)
	partIdList[index] = partIds{SPDFileName: SPDFileName, memParts: p.partName}
	}

	fmt.Printf("%s", s)

	s = getFileHeader() + s
	err := ioutil.WriteFile(filepath.Join(makefileDirName, DRAMIdFileName), []byte(s), 0644)

	return partIdList, err
	}

	/*
	* This function generates Makefile.mk under the variant directory path and adds assigned SPDs
	* to SPD_SOURCES.
	*/
	func genMakefile(partIdList []partIds, makefileDirName string, SPDDir string, partsDir string) error {
	s := getFileHeader()
	s += fmt.Sprintf("SPD_SOURCES =\n")

	for i := 0; i < len(partIdList); i++ {
	if partIdList[i].SPDFileName == "" {
	s += fmt.Sprintf("SPD_SOURCES += %v ", filepath.Join(SPDDir, SPDEmptyFileName))
	s += fmt.Sprintf(" # ID = %d(0b%04b)\n", i, int64(i))
	} else {
	SPDFileName := partIdList[i].SPDFileName
	path := filepath.Join(partsDir, SPDFileName)

	// Check if the file exists in the directory of the parts file
	if _, err := os.Stat(path); err != nil {
	// File doesn't exist, check spd directory
	path = filepath.Join(SPDDir, SPDFileName)
	if _, err = os.Stat(path); err != nil {
	return fmt.Errorf("Failed to write Makefile, SPD file '%s' doesn't exist", SPDFileName)
	}
	}
	s += fmt.Sprintf("SPD_SOURCES += %v ", path)
	s += fmt.Sprintf(" # ID = %d(0b%04b) ", i, int64(i))
	s += fmt.Sprintf(" Parts = %04s\n", partIdList[i].memParts)
	}
	}

	return ioutil.WriteFile(filepath.Join(makefileDirName, MakefileName), []byte(s), 0644)
	}

	func main() {
	if len(os.Args) != 5 {
	usage()
	log.Fatal("Incorrect number of arguments")
	}

	platform, memTech, makefileDir, memPartsUsedFile := os.Args[1], os.Args[2], os.Args[3], os.Args[4]

	err := checkArgs(platform, memTech, makefileDir, memPartsUsedFile)
	if err != nil {
	log.Fatal(err)
	}

	SPDDir, err := getSPDDir(platform, memTech)
	if err != nil {
	log.Fatal(err)
	}

	partToSPDMap, SPDToIndexMap, err := readSPDManifest(SPDDir)
	if err != nil {
	log.Fatal(err)
	}

	parts, err := readParts(memPartsUsedFile)
	if err != nil {
	log.Fatal(err)
	}

	// Update our SPD maps with part specific overrides
	for _, p := range parts {
	if p.SPDOverride != "" {
	partToSPDMap[p.partName] = p.SPDOverride
	SPDToIndexMap[p.SPDOverride] = -1
	}
	}

	partIdList, err := genPartIdInfo(parts, partToSPDMap, SPDToIndexMap, makefileDir)
	if err != nil {
	log.Fatal(err)
	}

	if err := genMakefile(partIdList, makefileDir, SPDDir, filepath.Dir(memPartsUsedFile)); err != nil {
	log.Fatal(err)
	}
	}