[pkg/amd] Fix typos and formatting

Signed-off-by: Dmitrii Okunev <xaionaro@meta.com>

Author: xaionaro

pkg/amd/apcb/apcb.go

@@ -15,10 +15,10 @@ import (
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //
 // APCB config consists of tokens, all tokens have the following attributes: ID, type, priority, boardMask, value
-// ID - is token's unqique identifier. Note APCB config may contain multiple tokens with same ID. The used one is determined by priority and board
+// ID - is token's unique identifier. Note APCB config may contain multiple tokens with same ID. The used one is determined by priority and board
 // Type - boolean, 1, 2 or 4 bytes value
 // Priority - see PriorityLevel
-// BoardMask - determines type of hardware for wich the token is aplicable
+// BoardMask - determines type of hardware for which the token is applicable
 // Value - token's value according to its type
 //
 // Structure of APCB/APCB recovery config is the following:

pkg/amd/psb/entries.go

@@ -20,10 +20,13 @@ type DirectoryType uint8
 const (
 	// PSPDirectoryLevel1 represents PSP directory table level 1
 	PSPDirectoryLevel1 DirectoryType = iota
+
 	// PSPDirectoryLevel2 represents PSP directory table level 2
 	PSPDirectoryLevel2
+
 	// BIOSDirectoryLevel1 represents BIOS directory table level 1
 	BIOSDirectoryLevel1
+
 	// BIOSDirectoryLevel2 represents BIOS directory table level 2
 	BIOSDirectoryLevel2
 )

pkg/amd/psb/keys.go

@@ -310,7 +310,7 @@ func NewTokenKey(buff *bytes.Buffer, keySet KeySet) (*Key, error) {
 	// * modulus
 	// * signature.
 	//
-	// Exponent, modulus and signature are all of the same size. Only the latter is not signed, hence the lenght
+	// Exponent, modulus and signature are all of the same size. Only the latter is not signed, hence the length
 	// of the signed payload is header size + 2 * exponent/modulus size.
 	lenSigned := uint64(64 + 2*key.data.ModulusSize/8)
 	if uint64(len(raw)) < lenSigned {

pkg/amd/psb/keyset.go

@@ -14,8 +14,6 @@ import (
 	amd_manifest "github.com/linuxboot/fiano/pkg/amd/manifest"
 )
 
-const keydbHeaderSize = 80
-
 // KeyType represents the type of the key stored in KeySet
 type KeyType string
 
@@ -52,7 +50,7 @@ func (kdb *KeySet) String() string {
 // AddKey adds a key to the key set
 func (kdb KeySet) AddKey(k *Key, keyType KeyType) error {
 	if _, ok := kdb.db[k.data.KeyID]; ok {
-		return fmt.Errorf("canont add key id %s to set, key with same id already exists", k.data.KeyID.Hex())
+		return fmt.Errorf("cannot add key id %s to set, key with same id already exists", k.data.KeyID.Hex())
 	}
 
 	kdb.db[k.data.KeyID] = k
@@ -102,8 +100,8 @@ func (kdb KeySet) KeysetFromType(keyType KeyType) (KeySet, error) {
 	return keySet, nil
 }
 
-// keydbHeader represents the header pre-pended to keydb structure
-type keydbHeader struct {
+// keyDBHeader represents the header pre-pended to keydb structure
+type keyDBHeader struct {
 	DataSize        uint32
 	Version         uint32
 	Cookie          uint32
@@ -122,8 +120,8 @@ func readAndCountSize(r io.Reader, order binary.ByteOrder, data interface{}, cou
 }
 
 // extractKeydbHeader parses keydbHeader from binary buffer. KeyDB header is supposed to be 80 bytes long
-func extractKeydbHeader(buff io.Reader) (*keydbHeader, error) {
-	header := keydbHeader{}
+func extractKeydbHeader(buff io.Reader) (*keyDBHeader, error) {
+	header := keyDBHeader{}
 
 	if err := binary.Read(buff, binary.LittleEndian, &header); err != nil {
 		return nil, fmt.Errorf("could not read key database header: %w", err)

pkg/amd/psb/psbbinary.go

@@ -16,16 +16,13 @@ const pspHeaderSize = 0x100
 // signedDataStart indicates the start address of signed data content within a PSP binary
 const signedDataStart = 0x0
 
-// sizeSignedToSignatureParametersLen is the size of the header from sizeSigned field to signatureParameters
-const sizeSignedToSignatureParametersLen = 32
-
-// PspHeaderData emebds the data of PspHeader
-type PspHeaderData struct {
+// PSPHeaderData embeds the data of PspHeader
+type PSPHeaderData struct {
 	Nonce                 Buf16B
 	HeaderVersion         uint32
 	SizeSigned            uint32
 	EncryptionOptions     uint32
-	IkekType              uint8
+	IKEKType              uint8
 	Reserved0             Buf3B
 	EncryptionParameters  Buf16B
 	SignatureOption       uint32
@@ -54,7 +51,7 @@ type PspHeaderData struct {
 
 // PspHeader models the header pre-pended to PSP binaries
 type PspHeader struct {
-	data PspHeaderData
+	data PSPHeaderData
 
 	// There should be 48 bytes of padding after the last field of the header,
 	// which can be ignored. What we care about is the signature of the binary,
@@ -132,7 +129,7 @@ func (b *PSPBinary) getSignedBlob(keyDB KeySet) (*SignedBlob, error) {
 		sizeImage = b.header.data.SizeImage
 	} else {
 		// the image is compressed, SizeFWSigned is to be ignored and instead compressedImageSize should be
-		// taken into consideration and aligned to 16 bits. PSP header size is not included in compresseImageSize.
+		// taken into consideration and aligned to 16 bits. PSP header size is not included in compressedImageSize.
 		alignment := uint32(0x10)
 		sizeSignedImage = (b.header.data.CompressedImageSize+alignment-1) & ^(alignment-1) + pspHeaderSize
 		sizeImage = sizeSignedImage + sizeSignature

pkg/amd/psb/pspentries.go

@@ -19,8 +19,8 @@ const (
 	// AMDPublicKeyEntry denotes AMD public key entry in PSP Directory table
 	AMDPublicKeyEntry amd_manifest.PSPDirectoryTableEntryType = 0x00
 
-	// PSPRecoveryBootlader is a recovery instance of PSP bootloader
-	PSPRecoveryBootlader amd_manifest.PSPDirectoryTableEntryType = 0x03
+	// PSPRecoveryBootloader is a recovery instance of PSP bootloader
+	PSPRecoveryBootloader amd_manifest.PSPDirectoryTableEntryType = 0x03
 
 	// SMUOffChipFirmwareEntry points to a region of firmware containing SMU offchip firmware
 	SMUOffChipFirmwareEntry amd_manifest.PSPDirectoryTableEntryType = 0x08

pkg/amd/psb/util.go

@@ -9,7 +9,7 @@ import (
 )
 
 func reverse(s []byte) []byte {
-	if s == nil || len(s) == 0 {
+	if len(s) == 0 {
 		return nil
 	}
 	d := make([]byte, len(s))
@@ -24,10 +24,10 @@ func reverse(s []byte) []byte {
 
 func checkBoundaries(start, end uint64, blob []byte) error {
 	if start > uint64(len(blob)) {
-		return fmt.Errorf("boundary check error: start is beyond blob bondary (%d > %d)", start, len(blob))
+		return fmt.Errorf("boundary check error: start is beyond blob boundary (%d > %d)", start, len(blob))
 	}
 	if end > uint64(len(blob)) {
-		return fmt.Errorf("boundary check error: start is beyond blob bondary (%d > %d)", end, len(blob))
+		return fmt.Errorf("boundary check error: start is beyond blob boundary (%d > %d)", end, len(blob))
 	}
 	if start > end {
 		return fmt.Errorf("boundary check error: start > end (%d > %d)", start, end)