/* 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
}