util/spd_tools/src/spd_gen/lp4x.go

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

import (
	"encoding/json"
	"fmt"
	"strconv"
	"strings"
)

/* ------------------------------------------------------------------------------------------ */
/*                                     LP4x-defined types                                     */
/* ------------------------------------------------------------------------------------------ */

type lp4x struct {
}

type LP4xMemAttributes struct {
	/* Primary attributes - must be provided by JSON file for each part */
	DensityPerChannelGb int
	Banks               int
	ChannelsPerDie      int
	DiesPerPackage      int
	BitWidthPerChannel  int
	RanksPerChannel     int
	SpeedMbps           int

	/*
	 * All the following parameters are optional and required only if the part requires
	 * special parameters as per the datasheet.
	 */
	/* Timing parameters */
	TRFCABNs   int
	TRFCPBNs   int
	TRPABMinNs int
	TRPPBMinNs int
	TCKMinPs   int
	TCKMaxPs   int
	TAAMinPs   int
	TRCDMinNs  int

	/* CAS */
	CASLatencies  string
	CASFirstByte  byte
	CASSecondByte byte
	CASThirdByte  byte
}

type LP4xSpeedParams struct {
	TCKMinPs               int
	TCKMaxPs               int
	CASLatenciesx16Channel string
	CASLatenciesx8Channel  string
}

type LP4xRefreshTimings struct {
	TRFCABNs int
	TRFCPBNs int
}

type LP4xSPDAttribFunc func(*LP4xMemAttributes) byte

type LP4xSPDAttribTableEntry struct {
	constVal byte
	getVal   LP4xSPDAttribFunc
}

type LP4xSetFunc func(*LP4xMemAttributes) int

type LP4xSet struct {
	getMRCDensity     LP4xSetFunc
	getDiesPerPackage LP4xSetFunc
	busWidthEncoding  byte
	normalizeAttribs  LP4xSetFunc
}

/* ------------------------------------------------------------------------------------------ */
/*                                         Constants                                          */
/* ------------------------------------------------------------------------------------------ */

const (
	/* SPD Byte Index */
	LP4xSPDIndexSize                            = 0
	LP4xSPDIndexRevision                        = 1
	LP4xSPDIndexMemoryType                      = 2
	LP4xSPDIndexModuleType                      = 3
	LP4xSPDIndexDensityBanks                    = 4
	LP4xSPDIndexAddressing                      = 5
	LP4xSPDIndexPackageType                     = 6
	LP4xSPDIndexOptionalFeatures                = 7
	LP4xSPDIndexModuleOrganization              = 12
	LP4xSPDIndexBusWidth                        = 13
	LP4xSPDIndexTimebases                       = 17
	LP4xSPDIndexTCKMin                          = 18
	LP4xSPDIndexTCKMax                          = 19
	LP4xSPDIndexCASFirstByte                    = 20
	LP4xSPDIndexCASSecondByte                   = 21
	LP4xSPDIndexCASThirdByte                    = 22
	LP4xSPDIndexCASFourthByte                   = 23
	LP4xSPDIndexTAAMin                          = 24
	LP4xSPDIndexReadWriteLatency                = 25
	LP4xSPDIndexTRCDMin                         = 26
	LP4xSPDIndexTRPABMin                        = 27
	LP4xSPDIndexTRPPBMin                        = 28
	LP4xSPDIndexTRFCABMinLSB                    = 29
	LP4xSPDIndexTRFCABMinMSB                    = 30
	LP4xSPDIndexTRFCPBMinLSB                    = 31
	LP4xSPDIndexTRFCPBMinMSB                    = 32
	LP4xSPDIndexTRPPBMinFineOffset              = 120
	LP4xSPDIndexTRPABMinFineOffset              = 121
	LP4xSPDIndexTRCDMinFineOffset               = 122
	LP4xSPDIndexTAAMinFineOffset                = 123
	LP4xSPDIndexTCKMaxFineOffset                = 124
	LP4xSPDIndexTCKMinFineOffset                = 125
	LP4xSPDIndexManufacturerPartNumberStartByte = 329
	LP4xSPDIndexManufacturerPartNumberEndByte   = 348

	/* SPD Byte Value */

	/*
	 * From JEDEC spec:
	 * 6:4 (Bytes total) = 2 (512 bytes)
	 * 3:0 (Bytes used) = 3 (384 bytes)
	 * Set to 0x23 for LPDDR4x.
	 */
	LP4xSPDValueSize = 0x23

	/*
	 * From JEDEC spec: Revision 1.1
	 * Set to 0x11.
	 */
	LP4xSPDValueRevision = 0x11

	/* LPDDR4x memory type = 0x11 */
	LP4xSPDValueMemoryType = 0x11

	/*
	 * From JEDEC spec:
	 * 7:7 (Hybrid) = 0 (Not hybrid)
	 * 6:4 (Hybrid media) = 000 (Not hybrid)
	 * 3:0 (Base Module Type) = 1110 (Non-DIMM solution)
	 *
	 * This is dependent on hardware design. LPDDR4x only has memory down solution.
	 * Hence this is not hybrid non-DIMM solution.
	 * Set to 0x0E.
	 */
	LP4xSPDValueModuleType = 0x0e

	/*
	 * From JEDEC spec:
	 * 5:4 (Maximum Activate Window) = 00 (8192 * tREFI)
	 * 3:0 (Maximum Activate Count) = 1000 (Unlimited MAC)
	 *
	 * Needs to come from datasheet, but most parts seem to support unlimited MAC.
	 * MR#24 OP3
	 */
	LP4xSPDValueOptionalFeatures = 0x08

	/*
	 * From JEDEC spec:
	 * 3:2 (MTB) = 00 (0.125ns)
	 * 1:0 (FTB) = 00 (1ps)
	 * Set to 0x00.
	 */
	LP4xSPDValueTimebases = 0x00

	/* CAS fourth byte: All bits are reserved */
	LP4xSPDValueCASFourthByte = 0x00

	/* Write Latency Set A and Read Latency DBI-RD disabled. */
	LP4xSPDValueReadWriteLatency = 0x00

	/* As per JEDEC spec, unused digits of manufacturer part number are left as blank. */
	LP4xSPDValueManufacturerPartNumberBlank = 0x20
)

const (
	/* First Byte */
	LP4xCAS6  = 1 << 1
	LP4xCAS10 = 1 << 4
	LP4xCAS14 = 1 << 7
	/* Second Byte */
	LP4xCAS16 = 1 << 0
	LP4xCAS20 = 1 << 2
	LP4xCAS22 = 1 << 3
	LP4xCAS24 = 1 << 4
	LP4xCAS26 = 1 << 5
	LP4xCAS28 = 1 << 6
	/* Third Byte */
	LP4xCAS32 = 1 << 0
	LP4xCAS36 = 1 << 2
	LP4xCAS40 = 1 << 4
)

const (
	/*
	 * JEDEC spec says that TCKmax should be 100ns for all speed grades.
	 * 100ns in MTB units comes out to be 0x320. But since this is a byte field, set it to
	 * 0xFF i.e. 31.875ns.
	 */
	LP4xTCKMaxPsDefault = 31875
)

/* ------------------------------------------------------------------------------------------ */
/*                                    Global variables                                        */
/* ------------------------------------------------------------------------------------------ */

var LP4xPlatformSetMap = map[int][]int{
	0: {PlatformTGL, PlatformADL},
	1: {PlatformJSL, PlatformCZN},
}

var LP4xSetInfo = map[int]LP4xSet{
	0: {
		getMRCDensity:     LP4xGetMRCDensitySet0,
		getDiesPerPackage: LP4xGetDiesPerPackageSet0,
		/*
		 * As per advisory 616599:
		 * 7:5 (Number of system channels) = 000 (1 channel always)
		 * 2:0 (Bus width) = 001 (x16 always)
		 * Set to 0x01.
		 */
		busWidthEncoding: 0x01,
		normalizeAttribs: LP4xNormalizeAttribsSet0,
	},
	1: {
		getMRCDensity:     LP4xGetMRCDensitySet1,
		getDiesPerPackage: LP4xGetDiesPerPackageSet1,
		/*
		* As per advisory 610202:
		* 7:5 (Number of system channels) = 001 (2 channel always)
		* 2:0 (Bus width) = 010 (x32 always)
		* Set to 0x22.
		 */
		busWidthEncoding: 0x22,
	},
}

var LP4xPartAttributeMap = map[string]LP4xMemAttributes{}
var LP4xCurrSet int

/* This encodes the density in Gb to SPD values as per JESD 21-C */
var LP4xDensityGbToSPDEncoding = map[int]byte{
	4:  0x4,
	6:  0xb,
	8:  0x5,
	12: 0x8,
	16: 0x6,
	24: 0x9,
	32: 0x7,
}

/*
 * Table 5 from JESD209-4C.
 * Maps density per physical channel to row-column encoding as per JESD 21-C for a device with
 * x8 physical channel.
 */
var LP4xDensityGbx8ChannelToRowColumnEncoding = map[int]byte{
	3:  0x21, /* 16 rows, 10 columns */
	4:  0x21, /* 16 rows, 10 columns */
	6:  0x29, /* 17 rows, 10 columns */
	8:  0x29, /* 17 rows, 10 columns */
	12: 0x31, /* 18 rows, 10 columns */
	16: 0x31, /* 18 rows, 10 columns */
}

/*
 * Table 3 from JESD209-4C.
 * Maps density per physical channel to row-column encoding as per JESD 21-C for a device with
 * x16 physical channel.
 */
var LP4xDensityGbx16ChannelToRowColumnEncoding = map[int]byte{
	4:  0x19, /* 15 rows, 10 columns */
	6:  0x21, /* 16 rows, 10 columns */
	8:  0x21, /* 16 rows, 10 columns */
	12: 0x29, /* 17 rows, 10 columns */
	16: 0x29, /* 17 rows, 10 columns */
}

/*
 * Table 112 from JESD209-4C
 * Maps density per physical channel to refresh timings. This is the same for x8 and x16
 * devices.
 */
var LP4xDensityGbPhysicalChannelToRefreshEncoding = map[int]LP4xRefreshTimings{
	3: {
		TRFCABNs: 180,
		TRFCPBNs: 90,
	},
	4: {
		TRFCABNs: 180,
		TRFCPBNs: 90,
	},
	6: {
		TRFCABNs: 280,
		TRFCPBNs: 140,
	},
	8: {
		TRFCABNs: 280,
		TRFCPBNs: 140,
	},
	12: {
		TRFCABNs: 380,
		TRFCPBNs: 190,
	},
	16: {
		TRFCABNs: 380,
		TRFCPBNs: 190,
	},
}

var LP4xBankEncoding = map[int]byte{
	4: 0 << 4,
	8: 1 << 4,
}

var LP4xSpeedMbpsToSPDEncoding = map[int]LP4xSpeedParams{
	4267: {
		TCKMinPs:               468, /* 1/4267 * 2 */
		TCKMaxPs:               LP4xTCKMaxPsDefault,
		CASLatenciesx16Channel: "6 10 14 20 24 28 32 36",
		CASLatenciesx8Channel:  "6 10 16 22 26 32 36 40",
	},
	3733: {
		TCKMinPs:               535, /* 1/3733 * 2 */
		TCKMaxPs:               LP4xTCKMaxPsDefault,
		CASLatenciesx16Channel: "6 10 14 20 24 28 32",
		CASLatenciesx8Channel:  "6 10 16 22 26 32 36",
	},
	3200: {
		TCKMinPs:               625, /* 1/3200 * 2 */
		TCKMaxPs:               LP4xTCKMaxPsDefault,
		CASLatenciesx16Channel: "6 10 14 20 24 28",
		CASLatenciesx8Channel:  "6 10 16 22 26 32",
	},
}

var LP4xSPDAttribTable = map[int]LP4xSPDAttribTableEntry{
	LP4xSPDIndexSize:               {constVal: LP4xSPDValueSize},
	LP4xSPDIndexRevision:           {constVal: LP4xSPDValueRevision},
	LP4xSPDIndexMemoryType:         {constVal: LP4xSPDValueMemoryType},
	LP4xSPDIndexModuleType:         {constVal: LP4xSPDValueModuleType},
	LP4xSPDIndexDensityBanks:       {getVal: LP4xEncodeDensityBanks},
	LP4xSPDIndexAddressing:         {getVal: LP4xEncodeSdramAddressing},
	LP4xSPDIndexPackageType:        {getVal: LP4xEncodePackageType},
	LP4xSPDIndexOptionalFeatures:   {constVal: LP4xSPDValueOptionalFeatures},
	LP4xSPDIndexModuleOrganization: {getVal: LP4xEncodeModuleOrganization},
	LP4xSPDIndexBusWidth:           {getVal: LP4xEncodeBusWidth},
	LP4xSPDIndexTimebases:          {constVal: LP4xSPDValueTimebases},
	LP4xSPDIndexTCKMin:             {getVal: LP4xEncodeTCKMin},
	LP4xSPDIndexTCKMax:             {getVal: LP4xEncodeTCKMax},
	LP4xSPDIndexTCKMaxFineOffset:   {getVal: LP4xEncodeTCKMaxFineOffset},
	LP4xSPDIndexTCKMinFineOffset:   {getVal: LP4xEncodeTCKMinFineOffset},
	LP4xSPDIndexCASFirstByte:       {getVal: LP4xEncodeCASFirstByte},
	LP4xSPDIndexCASSecondByte:      {getVal: LP4xEncodeCASSecondByte},
	LP4xSPDIndexCASThirdByte:       {getVal: LP4xEncodeCASThirdByte},
	LP4xSPDIndexCASFourthByte:      {constVal: LP4xSPDValueCASFourthByte},
	LP4xSPDIndexTAAMin:             {getVal: LP4xEncodeTAAMin},
	LP4xSPDIndexTAAMinFineOffset:   {getVal: LP4xEncodeTAAMinFineOffset},
	LP4xSPDIndexReadWriteLatency:   {constVal: LP4xSPDValueReadWriteLatency},
	LP4xSPDIndexTRCDMin:            {getVal: LP4xEncodeTRCDMin},
	LP4xSPDIndexTRCDMinFineOffset:  {getVal: LP4xEncodeTRCDMinFineOffset},
	LP4xSPDIndexTRPABMin:           {getVal: LP4xEncodeTRPABMin},
	LP4xSPDIndexTRPABMinFineOffset: {getVal: LP4xEncodeTRPABMinFineOffset},
	LP4xSPDIndexTRPPBMin:           {getVal: LP4xEncodeTRPPBMin},
	LP4xSPDIndexTRPPBMinFineOffset: {getVal: LP4xEncodeTRPPBMinFineOffset},
	LP4xSPDIndexTRFCABMinLSB:       {getVal: LP4xEncodeTRFCABMinLsb},
	LP4xSPDIndexTRFCABMinMSB:       {getVal: LP4xEncodeTRFCABMinMsb},
	LP4xSPDIndexTRFCPBMinLSB:       {getVal: LP4xEncodeTRFCPBMinLsb},
	LP4xSPDIndexTRFCPBMinMSB:       {getVal: LP4xEncodeTRFCPBMinMsb},
}

/* ------------------------------------------------------------------------------------------ */
/*                                        Functions                                           */
/* ------------------------------------------------------------------------------------------ */

func LP4xGetMRCDensitySet0(memAttribs *LP4xMemAttributes) int {
	/*
	 * Intel MRC on TGL/ADL expects density per logical channel to be encoded in
	 * SPDIndexDensityBanks. Logical channel on TGL/ADL is an x16 channel.
	 */
	return memAttribs.DensityPerChannelGb * 16 / memAttribs.BitWidthPerChannel
}

func LP4xGetMRCDensitySet1(memAttribs *LP4xMemAttributes) int {
	/*
	 * Intel MRC on JSL expects density per die to be encoded in
	 * SPDIndexDensityBanks.
	 */
	return memAttribs.DensityPerChannelGb * memAttribs.ChannelsPerDie
}

func LP4xGetMRCDensity(memAttribs *LP4xMemAttributes) int {
	f, ok := LP4xSetInfo[LP4xCurrSet]

	if ok == false || f.getMRCDensity == nil {
		return 0
	}

	return f.getMRCDensity(memAttribs)
}

func LP4xEncodeDensityBanks(memAttribs *LP4xMemAttributes) byte {
	var b byte

	b = LP4xDensityGbToSPDEncoding[LP4xGetMRCDensity(memAttribs)]
	b |= LP4xBankEncoding[memAttribs.Banks]

	return b
}

func LP4xEncodeSdramAddressing(memAttribs *LP4xMemAttributes) byte {
	densityPerChannelGb := memAttribs.DensityPerChannelGb
	if memAttribs.BitWidthPerChannel == 8 {
		return LP4xDensityGbx8ChannelToRowColumnEncoding[densityPerChannelGb]
	} else {
		return LP4xDensityGbx16ChannelToRowColumnEncoding[densityPerChannelGb]
	}
	return 0
}

func LP4xEncodePackage(dies int) byte {
	var temp byte

	if dies > 1 {
		/* If more than one die, then this is a non-monolithic device. */
		temp = 1
	} else {
		/* If only single die, then this is a monolithic device. */
		temp = 0
	}

	return temp << 7
}

func LP4xEncodeChannelsPerDie(channels int) byte {
	var temp byte

	temp = byte(channels >> 1)

	return temp << 2
}

func LP4xGetDiesPerPackageSet0(memAttribs *LP4xMemAttributes) int {
	/* Intel MRC expects logical dies to be encoded for TGL/ADL. */
	return memAttribs.ChannelsPerDie * memAttribs.RanksPerChannel * memAttribs.BitWidthPerChannel / 16
}

func LP4xGetDiesPerPackageSet1(memAttribs *LP4xMemAttributes) int {
	/* Intel MRC expects physical dies to be encoded for JSL. */
	/* AMD PSP expects physical dies (ZQ balls) */
	return memAttribs.DiesPerPackage
}

/* Per JESD209-4C Dies = ZQ balls on the package */
/* Note that this can be different than the part's die count */
func LP4xEncodeDiesPerPackage(memAttribs *LP4xMemAttributes) byte {
	var dies int = 0

	f, ok := LP4xSetInfo[LP4xCurrSet]
	if ok != false && f.getDiesPerPackage != nil {
		dies = f.getDiesPerPackage(memAttribs)
	}

	b := LP4xEncodePackage(dies) /* Monolithic / Non-monolithic device */
	b |= (byte(dies) - 1) << 4

	return b
}

func LP4xEncodePackageType(memAttribs *LP4xMemAttributes) byte {
	var b byte

	b |= LP4xEncodeChannelsPerDie(memAttribs.ChannelsPerDie)
	b |= LP4xEncodeDiesPerPackage(memAttribs)

	return b
}

func LP4xEncodeDataWidth(bitWidthPerChannel int) byte {
	return byte(bitWidthPerChannel / 8)
}

func LP4xEncodeRanks(ranks int) byte {
	var b byte
	b = byte(ranks - 1)
	return b << 3
}

func LP4xEncodeModuleOrganization(memAttribs *LP4xMemAttributes) byte {
	var b byte

	b = LP4xEncodeDataWidth(memAttribs.BitWidthPerChannel)
	b |= LP4xEncodeRanks(memAttribs.RanksPerChannel)

	return b
}

func LP4xEncodeBusWidth(memAttribs *LP4xMemAttributes) byte {
	f, ok := LP4xSetInfo[LP4xCurrSet]

	if ok == false {
		return 0
	}

	return f.busWidthEncoding
}

func LP4xEncodeTCKMin(memAttribs *LP4xMemAttributes) byte {
	return convPsToMtbByte(memAttribs.TCKMinPs)
}

func LP4xEncodeTCKMinFineOffset(memAttribs *LP4xMemAttributes) byte {
	return convPsToFtbByte(memAttribs.TCKMinPs)
}

func LP4xEncodeTCKMax(memAttribs *LP4xMemAttributes) byte {
	return convPsToMtbByte(memAttribs.TCKMaxPs)
}

func LP4xEncodeTCKMaxFineOffset(memAttribs *LP4xMemAttributes) byte {
	return convPsToFtbByte(memAttribs.TCKMaxPs)
}

func LP4xEncodeCASFirstByte(memAttribs *LP4xMemAttributes) byte {
	return memAttribs.CASFirstByte
}

func LP4xEncodeCASSecondByte(memAttribs *LP4xMemAttributes) byte {
	return memAttribs.CASSecondByte
}

func LP4xEncodeCASThirdByte(memAttribs *LP4xMemAttributes) byte {
	return memAttribs.CASThirdByte
}

func LP4xEncodeTAAMin(memAttribs *LP4xMemAttributes) byte {
	return convPsToMtbByte(memAttribs.TAAMinPs)
}

func LP4xEncodeTAAMinFineOffset(memAttribs *LP4xMemAttributes) byte {
	return convPsToFtbByte(memAttribs.TAAMinPs)
}

func LP4xEncodeTRCDMin(memAttribs *LP4xMemAttributes) byte {
	return convNsToMtbByte(memAttribs.TRCDMinNs)
}

func LP4xEncodeTRCDMinFineOffset(memAttribs *LP4xMemAttributes) byte {
	return convNsToFtbByte(memAttribs.TRCDMinNs)
}

func LP4xEncodeTRPABMin(memAttribs *LP4xMemAttributes) byte {
	return convNsToMtbByte(memAttribs.TRPABMinNs)
}

func LP4xEncodeTRPABMinFineOffset(memAttribs *LP4xMemAttributes) byte {
	return convNsToFtbByte(memAttribs.TRPABMinNs)
}

func LP4xEncodeTRPPBMin(memAttribs *LP4xMemAttributes) byte {
	return convNsToMtbByte(memAttribs.TRPPBMinNs)
}

func LP4xEncodeTRPPBMinFineOffset(memAttribs *LP4xMemAttributes) byte {
	return convNsToFtbByte(memAttribs.TRPPBMinNs)
}

func LP4xEncodeTRFCABMinMsb(memAttribs *LP4xMemAttributes) byte {
	return byte((convNsToMtb(memAttribs.TRFCABNs) >> 8) & 0xff)
}

func LP4xEncodeTRFCABMinLsb(memAttribs *LP4xMemAttributes) byte {
	return byte(convNsToMtb(memAttribs.TRFCABNs) & 0xff)
}

func LP4xEncodeTRFCPBMinMsb(memAttribs *LP4xMemAttributes) byte {
	return byte((convNsToMtb(memAttribs.TRFCPBNs) >> 8) & 0xff)
}

func LP4xEncodeTRFCPBMinLsb(memAttribs *LP4xMemAttributes) byte {
	return byte(convNsToMtb(memAttribs.TRFCPBNs) & 0xff)
}

func LP4xEncodeLatencies(latency int, memAttribs *LP4xMemAttributes) error {
	switch latency {
	case 6:
		memAttribs.CASFirstByte |= LP4xCAS6
	case 10:
		memAttribs.CASFirstByte |= LP4xCAS10
	case 14:
		memAttribs.CASFirstByte |= LP4xCAS14
	case 16:
		memAttribs.CASSecondByte |= LP4xCAS16
	case 20:
		memAttribs.CASSecondByte |= LP4xCAS20
	case 22:
		memAttribs.CASSecondByte |= LP4xCAS22
	case 24:
		memAttribs.CASSecondByte |= LP4xCAS24
	case 26:
		memAttribs.CASSecondByte |= LP4xCAS26
	case 28:
		memAttribs.CASSecondByte |= LP4xCAS28
	case 32:
		memAttribs.CASThirdByte |= LP4xCAS32
	case 36:
		memAttribs.CASThirdByte |= LP4xCAS36
	case 40:
		memAttribs.CASThirdByte |= LP4xCAS40
	default:
		fmt.Errorf("Incorrect CAS Latency: ", latency)
	}

	return nil
}

func LP4xUpdateTCK(memAttribs *LP4xMemAttributes) {
	if memAttribs.TCKMinPs == 0 {
		memAttribs.TCKMinPs = LP4xSpeedMbpsToSPDEncoding[memAttribs.SpeedMbps].TCKMinPs
	}
	if memAttribs.TCKMaxPs == 0 {
		memAttribs.TCKMaxPs = LP4xSpeedMbpsToSPDEncoding[memAttribs.SpeedMbps].TCKMaxPs
	}
}

func LP4xGetCASLatencies(memAttribs *LP4xMemAttributes) string {
	if memAttribs.BitWidthPerChannel == 16 {
		return LP4xSpeedMbpsToSPDEncoding[memAttribs.SpeedMbps].CASLatenciesx16Channel
	} else if memAttribs.BitWidthPerChannel == 8 {
		return LP4xSpeedMbpsToSPDEncoding[memAttribs.SpeedMbps].CASLatenciesx8Channel
	}

	return ""
}

func LP4xUpdateCAS(memAttribs *LP4xMemAttributes) error {
	if len(memAttribs.CASLatencies) == 0 {
		memAttribs.CASLatencies = LP4xGetCASLatencies(memAttribs)
	}

	latencies := strings.Fields(memAttribs.CASLatencies)
	for i := 0; i < len(latencies); i++ {
		latency, err := strconv.Atoi(latencies[i])
		if err != nil {
			return fmt.Errorf("Unable to convert latency ", latencies[i])
		}
		if err := LP4xEncodeLatencies(latency, memAttribs); err != nil {
			return err
		}
	}
	return nil
}

func LP4xGetMinCAS(memAttribs *LP4xMemAttributes) (int, error) {
	if (memAttribs.CASThirdByte & LP4xCAS40) != 0 {
		return 40, nil
	}
	if (memAttribs.CASThirdByte & LP4xCAS36) != 0 {
		return 36, nil
	}
	if (memAttribs.CASThirdByte & LP4xCAS32) != 0 {
		return 32, nil
	}
	if (memAttribs.CASSecondByte & LP4xCAS28) != 0 {
		return 28, nil
	}

	return 0, fmt.Errorf("Unexpected min CAS")
}

func LP4xUpdateTAAMin(memAttribs *LP4xMemAttributes) error {
	if memAttribs.TAAMinPs == 0 {
		minCAS, err := LP4xGetMinCAS(memAttribs)
		if err != nil {
			return err
		}
		memAttribs.TAAMinPs = memAttribs.TCKMinPs * minCAS
	}

	return nil
}

func LP4xUpdateTRFCAB(memAttribs *LP4xMemAttributes) {
	if memAttribs.TRFCABNs == 0 {
		memAttribs.TRFCABNs = LP4xDensityGbPhysicalChannelToRefreshEncoding[memAttribs.DensityPerChannelGb].TRFCABNs
	}
}

func LP4xUpdateTRFCPB(memAttribs *LP4xMemAttributes) {
	if memAttribs.TRFCPBNs == 0 {
		memAttribs.TRFCPBNs = LP4xDensityGbPhysicalChannelToRefreshEncoding[memAttribs.DensityPerChannelGb].TRFCPBNs
	}
}

func LP4xUpdateTRCD(memAttribs *LP4xMemAttributes) {
	if memAttribs.TRCDMinNs == 0 {
		/* JEDEC spec says max of 18ns */
		memAttribs.TRCDMinNs = 18
	}
}

func LP4xUpdateTRPAB(memAttribs *LP4xMemAttributes) {
	if memAttribs.TRPABMinNs == 0 {
		/* JEDEC spec says max of 21ns */
		memAttribs.TRPABMinNs = 21
	}
}

func LP4xUpdateTRPPB(memAttribs *LP4xMemAttributes) {
	if memAttribs.TRPPBMinNs == 0 {
		/* JEDEC spec says max of 18ns */
		memAttribs.TRPPBMinNs = 18
	}
}

func LP4xNormalizeAttribsSet0(memAttribs *LP4xMemAttributes) int {
	/*
	 * TGL does not really use physical organization of dies per package when
	 * generating the SPD. So, set it to 0 here so that deduplication ignores
	 * that field.
	 */
	memAttribs.DiesPerPackage = 0

	return 0
}

func LP4xNormalizeMemoryAttributes(memAttribs *LP4xMemAttributes) {
	f, ok := LP4xSetInfo[LP4xCurrSet]

	if ok == false || f.normalizeAttribs == nil {
		return
	}

	f.normalizeAttribs(memAttribs)
}

func Lp4xUpdateMemoryAttributes(memAttribs *LP4xMemAttributes) error {
	LP4xUpdateTCK(memAttribs)
	if err := LP4xUpdateCAS(memAttribs); err != nil {
		return err
	}
	if err := LP4xUpdateTAAMin(memAttribs); err != nil {
		return err
	}
	LP4xUpdateTRFCAB(memAttribs)
	LP4xUpdateTRFCPB(memAttribs)
	LP4xUpdateTRCD(memAttribs)
	LP4xUpdateTRPAB(memAttribs)
	LP4xUpdateTRPPB(memAttribs)

	LP4xNormalizeMemoryAttributes(memAttribs)

	return nil
}

func LP4xValidateDensityx8Channel(densityPerChannelGb int) error {
	if _, ok := LP4xDensityGbx8ChannelToRowColumnEncoding[densityPerChannelGb]; ok == false {
		return fmt.Errorf("Incorrect x8 density: %d Gb", densityPerChannelGb)
	}
	return nil
}

func LP4xValidateDensityx16Channel(densityPerChannelGb int) error {
	if _, ok := LP4xDensityGbx16ChannelToRowColumnEncoding[densityPerChannelGb]; ok == false {
		return fmt.Errorf("Incorrect x16 density: %d Gb", densityPerChannelGb)
	}
	return nil
}

func LP4xValidateDensity(memAttribs *LP4xMemAttributes) error {
	if memAttribs.BitWidthPerChannel == 8 {
		return LP4xValidateDensityx8Channel(memAttribs.DensityPerChannelGb)
	} else if memAttribs.BitWidthPerChannel == 16 {
		return LP4xValidateDensityx16Channel(memAttribs.DensityPerChannelGb)
	}

	return fmt.Errorf("No density table for this bit width: %d", memAttribs.BitWidthPerChannel)
}

func LP4xValidateBanks(banks int) error {
	if banks != 4 && banks != 8 {
		return fmt.Errorf("Incorrect banks: %d", banks)
	}
	return nil
}

func LP4xValidateChannels(channels int) error {
	if channels != 1 && channels != 2 && channels != 4 {
		return fmt.Errorf("Incorrect channels per die: %d ", channels)
	}
	return nil
}

func LP4xValidateDataWidth(width int) error {
	if width != 8 && width != 16 {
		return fmt.Errorf("Incorrect bit width: %d", width)
	}
	return nil
}

func LP4xValidateRanks(ranks int) error {
	if ranks != 1 && ranks != 2 {
		return fmt.Errorf("Incorrect ranks: %d", ranks)
	}
	return nil
}

func LP4xValidateSpeed(speed int) error {
	if _, ok := LP4xSpeedMbpsToSPDEncoding[speed]; ok == false {
		return fmt.Errorf("Incorrect speed: %d Mbps", speed)
	}
	return nil
}

func Lp4xValidateMemPartAttributes(memAttribs *LP4xMemAttributes) error {
	if err := LP4xValidateBanks(memAttribs.Banks); err != nil {
		return err
	}
	if err := LP4xValidateChannels(memAttribs.ChannelsPerDie); err != nil {
		return err
	}
	if err := LP4xValidateDataWidth(memAttribs.BitWidthPerChannel); err != nil {
		return err
	}
	if err := LP4xValidateDensity(memAttribs); err != nil {
		return err
	}
	if err := LP4xValidateRanks(memAttribs.RanksPerChannel); err != nil {
		return err
	}
	if err := LP4xValidateSpeed(memAttribs.SpeedMbps); err != nil {
		return err
	}

	return nil
}

func LP4xIsManufacturerPartNumberByte(index int) bool {
	if index >= LP4xSPDIndexManufacturerPartNumberStartByte &&
		index <= LP4xSPDIndexManufacturerPartNumberEndByte {
		return true
	}
	return false
}

/* ------------------------------------------------------------------------------------------ */
/*                                 Interface Functions                                       */
/* ------------------------------------------------------------------------------------------ */

func (lp4x) getSetMap() map[int][]int {
	return LP4xPlatformSetMap
}

func (lp4x) addNewPart(name string, attribs interface{}) error {
	var lp4xAttributes LP4xMemAttributes
	eByte, err := json.Marshal(attribs)
	if err != nil {
		return err
	}

	if err := json.Unmarshal(eByte, &lp4xAttributes); err != nil {
		return err
	}

	if err := Lp4xValidateMemPartAttributes(&lp4xAttributes); err != nil {
		return err
	}

	LP4xPartAttributeMap[name] = lp4xAttributes
	return nil
}

func (lp4x) getSPDAttribs(name string, set int) (interface{}, error) {
	lp4xAttributes := LP4xPartAttributeMap[name]

	LP4xCurrSet = set

	if err := Lp4xUpdateMemoryAttributes(&lp4xAttributes); err != nil {
		return lp4xAttributes, err
	}

	return lp4xAttributes, nil
}

func (lp4x) getSPDLen() int {
	return 512
}

func (lp4x) getSPDByte(index int, attribs interface{}) byte {
	e, ok := LP4xSPDAttribTable[index]
	if ok == false {
		if LP4xIsManufacturerPartNumberByte(index) {
			return LP4xSPDValueManufacturerPartNumberBlank
		}
		return 0x00
	}

	if e.getVal != nil {
		var lp4xAttribs LP4xMemAttributes
		lp4xAttribs = attribs.(LP4xMemAttributes)
		return e.getVal(&lp4xAttribs)
	}

	return e.constVal
}