util/spd_tools: Remove intel subfolder
Move ddr4 and lp4x to spd_tools root folder. The tool now applies to non intel platforms. BUG=b:162939176 TEST=Run tool Signed-off-by: Rob Barnes <robbarnes@google.com> Change-Id: I0941ea036d760ee27eb34f259f4506a4b7584bee Reviewed-on: https://review.coreboot.org/c/coreboot/+/44844 Reviewed-by: Furquan Shaikh <furquan@google.com> Reviewed-by: Nick Vaccaro <nvaccaro@google.com> Tested-by: build bot (Jenkins) <no-reply@coreboot.org>
This commit is contained in:
Rob Barnes
committed by
Furquan Shaikh
Furquan Shaikh
parent
1860cd460a
commit
196e9c0021
986
util/spd_tools/lp4x/gen_spd.go
Normal file
986
util/spd_tools/lp4x/gen_spd.go
Normal file
@ -0,0 +1,986 @@
|
||||
/* SPDX-License-Identifier: GPL-2.0-or-later */
|
||||
|
||||
package main
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"io/ioutil"
|
||||
"log"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"reflect"
|
||||
"strconv"
|
||||
"strings"
|
||||
)
|
||||
|
||||
/*
|
||||
* This program generates de-duplicated SPD files for LPDDR4x memory using the global memory
|
||||
* part list provided in CSV format. In addition to that, it also generates SPD manifest in CSV
|
||||
* format that contains entries of type (DRAM part name, SPD file name) which provides the SPD
|
||||
* file name used by a given DRAM part.
|
||||
*
|
||||
* It takes as input:
|
||||
* Pointer to directory where the generated SPD files will be placed.
|
||||
* JSON file containing a list of memory parts with their attributes as per datasheet.
|
||||
*/
|
||||
const (
|
||||
SPDManifestFileName = "spd_manifest.generated.txt"
|
||||
|
||||
PlatformTGL = 0
|
||||
PlatformJSL = 1
|
||||
)
|
||||
|
||||
var platformMap = map[string]int {
|
||||
"TGL": PlatformTGL,
|
||||
"JSL": PlatformJSL,
|
||||
}
|
||||
|
||||
var currPlatform int
|
||||
|
||||
type memAttributes 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
|
||||
}
|
||||
|
||||
/* This encodes the density in Gb to SPD values as per JESD 21-C */
|
||||
var densityGbToSPDEncoding = map[int]byte {
|
||||
4: 0x4,
|
||||
6: 0xb,
|
||||
8: 0x5,
|
||||
12: 0x8,
|
||||
16: 0x6,
|
||||
24: 0x9,
|
||||
32: 0x7,
|
||||
}
|
||||
|
||||
/*
|
||||
* 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 densityGbx16ChannelToRowColumnEncoding = 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 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 densityGbx8ChannelToRowColumnEncoding = 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 */
|
||||
}
|
||||
|
||||
type refreshTimings struct {
|
||||
TRFCABNs int
|
||||
TRFCPBNs int
|
||||
}
|
||||
|
||||
/*
|
||||
* Table 112 from JESD209-4C
|
||||
* Maps density per physical channel to refresh timings. This is the same for x8 and x16
|
||||
* devices.
|
||||
*/
|
||||
var densityGbPhysicalChannelToRefreshEncoding = map[int]refreshTimings {
|
||||
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,
|
||||
},
|
||||
}
|
||||
|
||||
type speedParams struct {
|
||||
TCKMinPs int
|
||||
TCKMaxPs int
|
||||
CASLatenciesx16Channel string
|
||||
CASLatenciesx8Channel string
|
||||
}
|
||||
|
||||
const (
|
||||
/* First Byte */
|
||||
CAS6 = 1 << 1
|
||||
CAS10 = 1 << 4
|
||||
CAS14 = 1 << 7
|
||||
/* Second Byte */
|
||||
CAS16 = 1 << 0
|
||||
CAS20 = 1 << 2
|
||||
CAS22 = 1 << 3
|
||||
CAS24 = 1 << 4
|
||||
CAS26 = 1 << 5
|
||||
CAS28 = 1 << 6
|
||||
/* Third Byte */
|
||||
CAS32 = 1 << 0
|
||||
CAS36 = 1 << 2
|
||||
CAS40 = 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.
|
||||
*/
|
||||
TCKMaxPsDefault = 31875
|
||||
)
|
||||
|
||||
var speedMbpsToSPDEncoding = map[int]speedParams {
|
||||
4267: {
|
||||
TCKMinPs: 468, /* 1/4267 * 2 */
|
||||
TCKMaxPs: TCKMaxPsDefault,
|
||||
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: TCKMaxPsDefault,
|
||||
CASLatenciesx16Channel: "6 10 14 20 24 28 32",
|
||||
CASLatenciesx8Channel: "6 10 16 22 26 32 36",
|
||||
},
|
||||
3200: {
|
||||
TCKMinPs: 625, /* 1/3200 * 2 */
|
||||
TCKMaxPs: TCKMaxPsDefault,
|
||||
CASLatenciesx16Channel: "6 10 14 20 24 28",
|
||||
CASLatenciesx8Channel: "6 10 16 22 26 32",
|
||||
},
|
||||
}
|
||||
|
||||
var bankEncoding = map[int]byte {
|
||||
4: 0 << 4,
|
||||
8: 1 << 4,
|
||||
}
|
||||
|
||||
const (
|
||||
TGLLogicalChannelWidth = 16
|
||||
)
|
||||
|
||||
/* Returns density to encode as per Intel MRC expectations. */
|
||||
func getMRCDensity(memAttribs *memAttributes) int {
|
||||
if currPlatform == PlatformTGL {
|
||||
/*
|
||||
* Intel MRC on TGL expects density per logical channel to be encoded in
|
||||
* SPDIndexDensityBanks. Logical channel on TGL is an x16 channel.
|
||||
*/
|
||||
return memAttribs.DensityPerChannelGb * TGLLogicalChannelWidth / memAttribs.BitWidthPerChannel
|
||||
} else if currPlatform == PlatformJSL {
|
||||
/*
|
||||
* Intel MRC on JSL expects density per die to be encoded in
|
||||
* SPDIndexDensityBanks.
|
||||
*/
|
||||
return memAttribs.DensityPerChannelGb * memAttribs.ChannelsPerDie
|
||||
}
|
||||
|
||||
return 0
|
||||
}
|
||||
|
||||
func encodeDensityBanks(memAttribs *memAttributes) byte {
|
||||
var b byte
|
||||
|
||||
b = densityGbToSPDEncoding[getMRCDensity(memAttribs)]
|
||||
b |= bankEncoding[memAttribs.Banks]
|
||||
|
||||
return b
|
||||
}
|
||||
|
||||
func encodeSdramAddressing(memAttribs *memAttributes) byte {
|
||||
densityPerChannelGb := memAttribs.DensityPerChannelGb
|
||||
if memAttribs.BitWidthPerChannel == 8 {
|
||||
return densityGbx8ChannelToRowColumnEncoding[densityPerChannelGb]
|
||||
} else {
|
||||
return densityGbx16ChannelToRowColumnEncoding[densityPerChannelGb]
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func encodeChannelsPerDie(channels int) byte {
|
||||
var temp byte
|
||||
|
||||
temp = byte(channels >> 1)
|
||||
|
||||
return temp << 2
|
||||
}
|
||||
|
||||
func encodePackage(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 encodeDiesPerPackage(memAttribs *memAttributes) byte {
|
||||
var dies int = 0
|
||||
if currPlatform == PlatformTGL {
|
||||
/* Intel MRC expects logical dies to be encoded for TGL. */
|
||||
dies = memAttribs.ChannelsPerDie * memAttribs.RanksPerChannel * memAttribs.BitWidthPerChannel / 16
|
||||
} else if currPlatform == PlatformJSL {
|
||||
/* Intel MRC expects physical dies to be encoded for JSL. */
|
||||
dies = memAttribs.DiesPerPackage
|
||||
}
|
||||
|
||||
b := encodePackage(dies) /* Monolithic / Non-monolithic device */
|
||||
b |= (byte(dies) - 1) << 4
|
||||
|
||||
return b
|
||||
}
|
||||
|
||||
func encodePackageType(memAttribs *memAttributes) byte {
|
||||
var b byte
|
||||
|
||||
b |= encodeChannelsPerDie(memAttribs.ChannelsPerDie)
|
||||
b |= encodeDiesPerPackage(memAttribs)
|
||||
|
||||
return b
|
||||
}
|
||||
|
||||
func encodeDataWidth(bitWidthPerChannel int) byte {
|
||||
return byte(bitWidthPerChannel / 8)
|
||||
}
|
||||
|
||||
func encodeRanks(ranks int) byte {
|
||||
var b byte
|
||||
b = byte(ranks - 1)
|
||||
return b << 3
|
||||
}
|
||||
|
||||
func encodeModuleOrganization(memAttribs *memAttributes) byte {
|
||||
var b byte
|
||||
|
||||
b = encodeDataWidth(memAttribs.BitWidthPerChannel)
|
||||
b |= encodeRanks(memAttribs.RanksPerChannel)
|
||||
|
||||
return b
|
||||
}
|
||||
|
||||
const (
|
||||
/*
|
||||
* As per advisory 616599:
|
||||
* 7:5 (Number of system channels) = 000 (1 channel always)
|
||||
* 2:0 (Bus width) = 001 (x16 always)
|
||||
* Set to 0x01.
|
||||
*/
|
||||
SPDValueBusWidthTGL = 0x01
|
||||
/*
|
||||
* As per advisory 610202:
|
||||
* 7:5 (Number of system channels) = 001 (2 channel always)
|
||||
* 2:0 (Bus width) = 010 (x32 always)
|
||||
* Set to 0x01.
|
||||
*/
|
||||
SPDValueBusWidthJSL = 0x22
|
||||
)
|
||||
|
||||
func encodeBusWidth(memAttribs *memAttributes) byte {
|
||||
if currPlatform == PlatformTGL {
|
||||
return SPDValueBusWidthTGL
|
||||
} else if currPlatform == PlatformJSL {
|
||||
return SPDValueBusWidthJSL
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func encodeTCKMin(memAttribs *memAttributes) byte {
|
||||
return convPsToMtbByte(memAttribs.TCKMinPs)
|
||||
}
|
||||
|
||||
func encodeTCKMinFineOffset(memAttribs *memAttributes) byte {
|
||||
return convPsToFtbByte(memAttribs.TCKMinPs)
|
||||
}
|
||||
|
||||
func encodeTCKMax(memAttribs *memAttributes) byte {
|
||||
return convPsToMtbByte(memAttribs.TCKMaxPs)
|
||||
}
|
||||
|
||||
func encodeTCKMaxFineOffset(memAttribs *memAttributes) byte {
|
||||
return convPsToFtbByte(memAttribs.TCKMaxPs)
|
||||
}
|
||||
|
||||
func encodeCASFirstByte(memAttribs *memAttributes) byte {
|
||||
return memAttribs.CASFirstByte
|
||||
}
|
||||
|
||||
func encodeCASSecondByte(memAttribs *memAttributes) byte {
|
||||
return memAttribs.CASSecondByte
|
||||
}
|
||||
|
||||
func encodeCASThirdByte(memAttribs *memAttributes) byte {
|
||||
return memAttribs.CASThirdByte
|
||||
}
|
||||
|
||||
func divRoundUp(dividend int, divisor int) int {
|
||||
return (dividend + divisor - 1) / divisor
|
||||
}
|
||||
|
||||
func convNsToPs(timeNs int) int {
|
||||
return timeNs * 1000
|
||||
}
|
||||
|
||||
func convMtbToPs(mtb int) int {
|
||||
return mtb * 125
|
||||
}
|
||||
|
||||
func convPsToMtb(timePs int) int {
|
||||
return divRoundUp(timePs, 125)
|
||||
}
|
||||
|
||||
func convPsToMtbByte(timePs int) byte {
|
||||
return byte(convPsToMtb(timePs) & 0xff)
|
||||
}
|
||||
|
||||
func convPsToFtbByte(timePs int) byte {
|
||||
mtb := convPsToMtb(timePs)
|
||||
ftb := timePs - convMtbToPs(mtb)
|
||||
|
||||
return byte(ftb)
|
||||
}
|
||||
|
||||
func convNsToMtb(timeNs int) int {
|
||||
return convPsToMtb(convNsToPs(timeNs))
|
||||
}
|
||||
|
||||
func convNsToMtbByte(timeNs int) byte {
|
||||
return convPsToMtbByte(convNsToPs(timeNs))
|
||||
}
|
||||
|
||||
func convNsToFtbByte(timeNs int) byte {
|
||||
return convPsToFtbByte(convNsToPs(timeNs))
|
||||
}
|
||||
|
||||
func encodeTAAMin(memAttribs *memAttributes) byte {
|
||||
return convPsToMtbByte(memAttribs.TAAMinPs)
|
||||
}
|
||||
|
||||
func encodeTAAMinFineOffset(memAttribs *memAttributes) byte {
|
||||
return convPsToFtbByte(memAttribs.TAAMinPs)
|
||||
}
|
||||
|
||||
func encodeTRCDMin(memAttribs *memAttributes) byte {
|
||||
return convNsToMtbByte(memAttribs.TRCDMinNs)
|
||||
}
|
||||
|
||||
func encodeTRCDMinFineOffset(memAttribs *memAttributes) byte {
|
||||
return convNsToFtbByte(memAttribs.TRCDMinNs)
|
||||
}
|
||||
|
||||
func encodeTRPABMin(memAttribs *memAttributes) byte {
|
||||
return convNsToMtbByte(memAttribs.TRPABMinNs)
|
||||
}
|
||||
|
||||
func encodeTRPABMinFineOffset(memAttribs *memAttributes) byte {
|
||||
return convNsToFtbByte(memAttribs.TRPABMinNs)
|
||||
}
|
||||
|
||||
func encodeTRPPBMin(memAttribs *memAttributes) byte {
|
||||
return convNsToMtbByte(memAttribs.TRPPBMinNs)
|
||||
}
|
||||
|
||||
func encodeTRPPBMinFineOffset(memAttribs *memAttributes) byte {
|
||||
return convNsToFtbByte(memAttribs.TRPPBMinNs)
|
||||
}
|
||||
|
||||
func encodeTRFCABMinMsb(memAttribs *memAttributes) byte {
|
||||
return byte((convNsToMtb(memAttribs.TRFCABNs) >> 8) & 0xff)
|
||||
}
|
||||
|
||||
func encodeTRFCABMinLsb(memAttribs *memAttributes) byte {
|
||||
return byte(convNsToMtb(memAttribs.TRFCABNs) & 0xff)
|
||||
}
|
||||
|
||||
func encodeTRFCPBMinMsb(memAttribs *memAttributes) byte {
|
||||
return byte((convNsToMtb(memAttribs.TRFCPBNs) >> 8) & 0xff)
|
||||
}
|
||||
|
||||
func encodeTRFCPBMinLsb(memAttribs *memAttributes) byte {
|
||||
return byte(convNsToMtb(memAttribs.TRFCPBNs) & 0xff)
|
||||
}
|
||||
|
||||
type SPDAttribFunc func (*memAttributes) byte
|
||||
|
||||
type SPDAttribTableEntry struct {
|
||||
constVal byte
|
||||
getVal SPDAttribFunc
|
||||
}
|
||||
|
||||
const (
|
||||
/* SPD Byte Index */
|
||||
SPDIndexSize = 0
|
||||
SPDIndexRevision = 1
|
||||
SPDIndexMemoryType = 2
|
||||
SPDIndexModuleType = 3
|
||||
SPDIndexDensityBanks = 4
|
||||
SPDIndexAddressing = 5
|
||||
SPDIndexPackageType = 6
|
||||
SPDIndexOptionalFeatures = 7
|
||||
SPDIndexModuleOrganization = 12
|
||||
SPDIndexBusWidth = 13
|
||||
SPDIndexTimebases = 17
|
||||
SPDIndexTCKMin = 18
|
||||
SPDIndexTCKMax = 19
|
||||
SPDIndexCASFirstByte = 20
|
||||
SPDIndexCASSecondByte = 21
|
||||
SPDIndexCASThirdByte = 22
|
||||
SPDIndexCASFourthByte = 23
|
||||
SPDIndexTAAMin = 24
|
||||
SPDIndexReadWriteLatency = 25
|
||||
SPDIndexTRCDMin = 26
|
||||
SPDIndexTRPABMin = 27
|
||||
SPDIndexTRPPBMin = 28
|
||||
SPDIndexTRFCABMinLSB = 29
|
||||
SPDIndexTRFCABMinMSB = 30
|
||||
SPDIndexTRFCPBMinLSB = 31
|
||||
SPDIndexTRFCPBMinMSB = 32
|
||||
SPDIndexTRPPBMinFineOffset = 120
|
||||
SPDIndexTRPABMinFineOffset = 121
|
||||
SPDIndexTRCDMinFineOffset = 122
|
||||
SPDIndexTAAMinFineOffset = 123
|
||||
SPDIndexTCKMaxFineOffset = 124
|
||||
SPDIndexTCKMinFineOffset = 125
|
||||
SPDIndexManufacturerPartNumberStartByte = 329
|
||||
SPDIndexManufacturerPartNumberEndByte = 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.
|
||||
*/
|
||||
SPDValueSize = 0x23
|
||||
|
||||
/*
|
||||
* From JEDEC spec: Revision 1.1
|
||||
* Set to 0x11.
|
||||
*/
|
||||
SPDValueRevision = 0x11
|
||||
|
||||
/* LPDDR4x memory type = 0x11 */
|
||||
SPDValueMemoryType = 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.
|
||||
*/
|
||||
SPDValueModuleType = 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
|
||||
*/
|
||||
SPDValueOptionalFeatures = 0x08
|
||||
|
||||
/*
|
||||
* From JEDEC spec:
|
||||
* 3:2 (MTB) = 00 (0.125ns)
|
||||
* 1:0 (FTB) = 00 (1ps)
|
||||
* Set to 0x00.
|
||||
*/
|
||||
SPDValueTimebases = 0x00
|
||||
|
||||
/* CAS fourth byte: All bits are reserved */
|
||||
SPDValueCASFourthByte = 0x00
|
||||
|
||||
/* Write Latency Set A and Read Latency DBI-RD disabled. */
|
||||
SPDValueReadWriteLatency = 0x00
|
||||
|
||||
/* As per JEDEC spec, unused digits of manufacturer part number are left as blank. */
|
||||
SPDValueManufacturerPartNumberBlank = 0x20
|
||||
)
|
||||
|
||||
var SPDAttribTable = map[int]SPDAttribTableEntry {
|
||||
SPDIndexSize: { constVal: SPDValueSize },
|
||||
SPDIndexRevision: { constVal: SPDValueRevision },
|
||||
SPDIndexMemoryType: { constVal: SPDValueMemoryType },
|
||||
SPDIndexModuleType: { constVal: SPDValueModuleType },
|
||||
SPDIndexDensityBanks: { getVal: encodeDensityBanks },
|
||||
SPDIndexAddressing: { getVal: encodeSdramAddressing },
|
||||
SPDIndexPackageType: { getVal: encodePackageType },
|
||||
SPDIndexOptionalFeatures: { constVal: SPDValueOptionalFeatures },
|
||||
SPDIndexModuleOrganization: { getVal: encodeModuleOrganization },
|
||||
SPDIndexBusWidth: { getVal: encodeBusWidth },
|
||||
SPDIndexTimebases: { constVal: SPDValueTimebases },
|
||||
SPDIndexTCKMin: { getVal: encodeTCKMin },
|
||||
SPDIndexTCKMax: { getVal: encodeTCKMax },
|
||||
SPDIndexTCKMaxFineOffset: { getVal: encodeTCKMaxFineOffset },
|
||||
SPDIndexTCKMinFineOffset: { getVal: encodeTCKMinFineOffset },
|
||||
SPDIndexCASFirstByte: { getVal: encodeCASFirstByte },
|
||||
SPDIndexCASSecondByte: { getVal: encodeCASSecondByte },
|
||||
SPDIndexCASThirdByte: { getVal: encodeCASThirdByte },
|
||||
SPDIndexCASFourthByte: { constVal: SPDValueCASFourthByte },
|
||||
SPDIndexTAAMin: { getVal: encodeTAAMin },
|
||||
SPDIndexTAAMinFineOffset: { getVal: encodeTAAMinFineOffset },
|
||||
SPDIndexReadWriteLatency: { constVal: SPDValueReadWriteLatency },
|
||||
SPDIndexTRCDMin: { getVal: encodeTRCDMin },
|
||||
SPDIndexTRCDMinFineOffset: { getVal: encodeTRCDMinFineOffset },
|
||||
SPDIndexTRPABMin: { getVal: encodeTRPABMin },
|
||||
SPDIndexTRPABMinFineOffset: { getVal: encodeTRPABMinFineOffset },
|
||||
SPDIndexTRPPBMin: { getVal: encodeTRPPBMin },
|
||||
SPDIndexTRPPBMinFineOffset: { getVal: encodeTRPPBMinFineOffset },
|
||||
SPDIndexTRFCABMinLSB: { getVal: encodeTRFCABMinLsb },
|
||||
SPDIndexTRFCABMinMSB: { getVal: encodeTRFCABMinMsb },
|
||||
SPDIndexTRFCPBMinLSB: { getVal: encodeTRFCPBMinLsb },
|
||||
SPDIndexTRFCPBMinMSB: { getVal: encodeTRFCPBMinMsb },
|
||||
}
|
||||
|
||||
type memParts struct {
|
||||
MemParts []memPart `json:"parts"`
|
||||
}
|
||||
|
||||
type memPart struct {
|
||||
Name string
|
||||
Attribs memAttributes
|
||||
SPDFileName string
|
||||
}
|
||||
|
||||
func writeSPDManifest(memParts *memParts, SPDDirName string) error {
|
||||
var s string
|
||||
|
||||
fmt.Printf("Generating SPD Manifest with following entries:\n")
|
||||
|
||||
for i := 0; i < len(memParts.MemParts); i++ {
|
||||
fmt.Printf("%-40s %s\n", memParts.MemParts[i].Name, memParts.MemParts[i].SPDFileName)
|
||||
s += fmt.Sprintf("%s,%s\n", memParts.MemParts[i].Name, memParts.MemParts[i].SPDFileName)
|
||||
}
|
||||
|
||||
return ioutil.WriteFile(filepath.Join(SPDDirName, SPDManifestFileName), []byte(s), 0644)
|
||||
}
|
||||
|
||||
func isManufacturerPartNumberByte(index int) bool {
|
||||
if index >= SPDIndexManufacturerPartNumberStartByte && index <= SPDIndexManufacturerPartNumberEndByte {
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func getSPDByte(index int, memAttribs *memAttributes) byte {
|
||||
e, ok := SPDAttribTable[index]
|
||||
if ok == false {
|
||||
if isManufacturerPartNumberByte(index) {
|
||||
return SPDValueManufacturerPartNumberBlank
|
||||
}
|
||||
return 0x00
|
||||
}
|
||||
|
||||
if e.getVal != nil {
|
||||
return e.getVal(memAttribs)
|
||||
}
|
||||
|
||||
return e.constVal
|
||||
}
|
||||
|
||||
func createSPD(memAttribs *memAttributes) string {
|
||||
var s string
|
||||
|
||||
for i := 0; i < 512; i++ {
|
||||
b := getSPDByte(i, memAttribs)
|
||||
|
||||
if (i + 1) % 16 == 0 {
|
||||
s += fmt.Sprintf("%02X\n", b)
|
||||
} else {
|
||||
s += fmt.Sprintf("%02X ", b)
|
||||
}
|
||||
}
|
||||
|
||||
return s
|
||||
}
|
||||
|
||||
func dedupeMemoryPart(dedupedParts []*memPart, memPart *memPart) bool {
|
||||
for i := 0; i < len(dedupedParts); i++ {
|
||||
if reflect.DeepEqual(dedupedParts[i].Attribs, memPart.Attribs) {
|
||||
memPart.SPDFileName = dedupedParts[i].SPDFileName
|
||||
return true
|
||||
}
|
||||
}
|
||||
|
||||
return false
|
||||
}
|
||||
|
||||
func generateSPD(memPart *memPart, SPDId int, SPDDirName string) {
|
||||
s := createSPD(&memPart.Attribs)
|
||||
memPart.SPDFileName = fmt.Sprintf("spd-%d.hex", SPDId)
|
||||
ioutil.WriteFile(filepath.Join(SPDDirName, memPart.SPDFileName), []byte(s), 0644)
|
||||
}
|
||||
|
||||
func readMemoryParts(memParts *memParts, memPartsFileName string) error {
|
||||
databytes, err := ioutil.ReadFile(memPartsFileName)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
return json.Unmarshal(databytes, memParts)
|
||||
}
|
||||
|
||||
func validateDensityx8Channel(densityPerChannelGb int) error {
|
||||
if _, ok := densityGbx8ChannelToRowColumnEncoding[densityPerChannelGb]; ok == false {
|
||||
return fmt.Errorf("Incorrect x8 density: ", densityPerChannelGb, "Gb")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func validateDensityx16Channel(densityPerChannelGb int) error {
|
||||
if _, ok := densityGbx16ChannelToRowColumnEncoding[densityPerChannelGb]; ok == false {
|
||||
return fmt.Errorf("Incorrect x16 density: ", densityPerChannelGb, "Gb")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func validateDensity(memAttribs *memAttributes) error {
|
||||
if memAttribs.BitWidthPerChannel == 8 {
|
||||
return validateDensityx8Channel(memAttribs.DensityPerChannelGb)
|
||||
} else if memAttribs.BitWidthPerChannel == 16 {
|
||||
return validateDensityx16Channel(memAttribs.DensityPerChannelGb)
|
||||
}
|
||||
|
||||
return fmt.Errorf("No density table for this bit width: ", memAttribs.BitWidthPerChannel)
|
||||
}
|
||||
|
||||
func validateBanks(banks int) error {
|
||||
if banks != 4 && banks != 8 {
|
||||
return fmt.Errorf("Incorrect banks: ", banks)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func validateChannels(channels int) error {
|
||||
if channels != 1 && channels != 2 && channels != 4 {
|
||||
return fmt.Errorf("Incorrect channels per die: ", channels)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func validateDataWidth(width int) error {
|
||||
if width != 8 && width != 16 {
|
||||
return fmt.Errorf("Incorrect bit width: ", width)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func validateRanks(ranks int) error {
|
||||
if ranks != 1 && ranks != 2 {
|
||||
return fmt.Errorf("Incorrect ranks: ", ranks)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func validateSpeed(speed int) error {
|
||||
if _, ok := speedMbpsToSPDEncoding[speed]; ok == false {
|
||||
return fmt.Errorf("Incorrect speed: ", speed, " Mbps")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func validateMemoryParts(memParts *memParts) error {
|
||||
for i := 0; i < len(memParts.MemParts); i++ {
|
||||
if err := validateBanks(memParts.MemParts[i].Attribs.Banks); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := validateChannels(memParts.MemParts[i].Attribs.ChannelsPerDie); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := validateDataWidth(memParts.MemParts[i].Attribs.BitWidthPerChannel); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := validateDensity(&memParts.MemParts[i].Attribs); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := validateRanks(memParts.MemParts[i].Attribs.RanksPerChannel); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := validateSpeed(memParts.MemParts[i].Attribs.SpeedMbps); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func encodeLatencies(latency int, memAttribs *memAttributes) error {
|
||||
switch latency {
|
||||
case 6:
|
||||
memAttribs.CASFirstByte |= CAS6
|
||||
case 10:
|
||||
memAttribs.CASFirstByte |= CAS10
|
||||
case 14:
|
||||
memAttribs.CASFirstByte |= CAS14
|
||||
case 16:
|
||||
memAttribs.CASSecondByte |= CAS16
|
||||
case 20:
|
||||
memAttribs.CASSecondByte |= CAS20
|
||||
case 22:
|
||||
memAttribs.CASSecondByte |= CAS22
|
||||
case 24:
|
||||
memAttribs.CASSecondByte |= CAS24
|
||||
case 26:
|
||||
memAttribs.CASSecondByte |= CAS26
|
||||
case 28:
|
||||
memAttribs.CASSecondByte |= CAS28
|
||||
case 32:
|
||||
memAttribs.CASThirdByte |= CAS32
|
||||
case 36:
|
||||
memAttribs.CASThirdByte |= CAS36
|
||||
case 40:
|
||||
memAttribs.CASThirdByte |= CAS40
|
||||
default:
|
||||
fmt.Errorf("Incorrect CAS Latency: ", latency)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func updateTCK(memAttribs *memAttributes) {
|
||||
if memAttribs.TCKMinPs == 0 {
|
||||
memAttribs.TCKMinPs = speedMbpsToSPDEncoding[memAttribs.SpeedMbps].TCKMinPs
|
||||
}
|
||||
if memAttribs.TCKMaxPs == 0 {
|
||||
memAttribs.TCKMaxPs = speedMbpsToSPDEncoding[memAttribs.SpeedMbps].TCKMaxPs
|
||||
}
|
||||
}
|
||||
|
||||
func getCASLatencies(memAttribs *memAttributes) string {
|
||||
if memAttribs.BitWidthPerChannel == 16 {
|
||||
return speedMbpsToSPDEncoding[memAttribs.SpeedMbps].CASLatenciesx16Channel
|
||||
} else if memAttribs.BitWidthPerChannel == 8 {
|
||||
return speedMbpsToSPDEncoding[memAttribs.SpeedMbps].CASLatenciesx8Channel
|
||||
}
|
||||
|
||||
return ""
|
||||
}
|
||||
|
||||
func updateCAS(memAttribs *memAttributes) error {
|
||||
if len(memAttribs.CASLatencies) == 0 {
|
||||
memAttribs.CASLatencies = getCASLatencies(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 := encodeLatencies(latency, memAttribs); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func getMinCAS(memAttribs *memAttributes) (int, error) {
|
||||
if (memAttribs.CASThirdByte & CAS40) != 0 {
|
||||
return 40, nil
|
||||
}
|
||||
if (memAttribs.CASThirdByte & CAS36) != 0 {
|
||||
return 36, nil
|
||||
}
|
||||
if (memAttribs.CASThirdByte & CAS32) != 0 {
|
||||
return 32, nil
|
||||
}
|
||||
if (memAttribs.CASSecondByte & CAS28) != 0 {
|
||||
return 28, nil
|
||||
}
|
||||
|
||||
return 0, fmt.Errorf("Unexpected min CAS")
|
||||
}
|
||||
|
||||
func updateTAAMin(memAttribs *memAttributes) error {
|
||||
if memAttribs.TAAMinPs == 0 {
|
||||
minCAS, err := getMinCAS(memAttribs)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
memAttribs.TAAMinPs = memAttribs.TCKMinPs * minCAS
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func updateTRFCAB(memAttribs *memAttributes) {
|
||||
if memAttribs.TRFCABNs == 0 {
|
||||
memAttribs.TRFCABNs = densityGbPhysicalChannelToRefreshEncoding[memAttribs.DensityPerChannelGb].TRFCABNs
|
||||
}
|
||||
}
|
||||
|
||||
func updateTRFCPB(memAttribs *memAttributes) {
|
||||
if memAttribs.TRFCPBNs == 0 {
|
||||
memAttribs.TRFCPBNs = densityGbPhysicalChannelToRefreshEncoding[memAttribs.DensityPerChannelGb].TRFCPBNs
|
||||
}
|
||||
}
|
||||
|
||||
func updateTRCD(memAttribs *memAttributes) {
|
||||
if memAttribs.TRCDMinNs == 0 {
|
||||
/* JEDEC spec says max of 18ns */
|
||||
memAttribs.TRCDMinNs = 18
|
||||
}
|
||||
}
|
||||
|
||||
func updateTRPAB(memAttribs *memAttributes) {
|
||||
if memAttribs.TRPABMinNs == 0 {
|
||||
/* JEDEC spec says max of 21ns */
|
||||
memAttribs.TRPABMinNs = 21
|
||||
}
|
||||
}
|
||||
|
||||
func updateTRPPB(memAttribs *memAttributes) {
|
||||
if memAttribs.TRPPBMinNs == 0 {
|
||||
/* JEDEC spec says max of 18ns */
|
||||
memAttribs.TRPPBMinNs = 18
|
||||
}
|
||||
}
|
||||
|
||||
func normalizeMemoryAttributes(memAttribs *memAttributes) {
|
||||
if currPlatform == PlatformTGL {
|
||||
/*
|
||||
* 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
|
||||
}
|
||||
}
|
||||
|
||||
func updateMemoryAttributes(memAttribs *memAttributes) error {
|
||||
updateTCK(memAttribs)
|
||||
if err := updateCAS(memAttribs); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := updateTAAMin(memAttribs); err != nil {
|
||||
return err
|
||||
}
|
||||
updateTRFCAB(memAttribs)
|
||||
updateTRFCPB(memAttribs)
|
||||
updateTRCD(memAttribs)
|
||||
updateTRPAB(memAttribs)
|
||||
updateTRPPB(memAttribs)
|
||||
|
||||
normalizeMemoryAttributes(memAttribs)
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func isPlatformSupported(platform string) error {
|
||||
var ok bool
|
||||
|
||||
currPlatform, ok = platformMap[platform]
|
||||
if ok == false {
|
||||
return fmt.Errorf("Unsupported platform: ", platform)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func usage() {
|
||||
fmt.Printf("\nUsage: %s <spd_dir> <mem_parts_list_json> <platform>\n\n", os.Args[0])
|
||||
fmt.Printf(" where,\n")
|
||||
fmt.Printf(" spd_dir = Directory path containing SPD files and manifest generated by gen_spd.go\n")
|
||||
fmt.Printf(" mem_parts_list_json = JSON File containing list of memory parts and attributes\n")
|
||||
fmt.Printf(" platform = SoC Platform for which the SPDs are being generated\n\n\n")
|
||||
}
|
||||
|
||||
func main() {
|
||||
if len(os.Args) != 4 {
|
||||
usage()
|
||||
log.Fatal("Incorrect number of arguments")
|
||||
}
|
||||
|
||||
var memParts memParts
|
||||
var dedupedParts []*memPart
|
||||
|
||||
SPDDir, GlobalMemPartsFile, Platform := os.Args[1], os.Args[2], strings.ToUpper(os.Args[3])
|
||||
|
||||
if err := isPlatformSupported(Platform); err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
|
||||
if err := readMemoryParts(&memParts, GlobalMemPartsFile); err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
|
||||
if err := validateMemoryParts(&memParts); err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
|
||||
SPDId := 1
|
||||
|
||||
for i := 0; i < len(memParts.MemParts); i++ {
|
||||
if err := updateMemoryAttributes(&memParts.MemParts[i].Attribs); err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
|
||||
if dedupeMemoryPart(dedupedParts, &memParts.MemParts[i]) == false {
|
||||
generateSPD(&memParts.MemParts[i], SPDId, SPDDir)
|
||||
SPDId++
|
||||
dedupedParts = append(dedupedParts, &memParts.MemParts[i])
|
||||
}
|
||||
}
|
||||
|
||||
if err := writeSPDManifest(&memParts, SPDDir); err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user