1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
|
# SPDX-License-Identifier: GPL-2.0+
# Copyright (c) 2016 Google, Inc
# Written by Simon Glass <sjg@chromium.org>
#
# Entry-type module for Intel Management Engine binary blob
#
from collections import OrderedDict
from binman.entry import Entry
from binman.etype.blob_ext import Entry_blob_ext
from dtoc import fdt_util
from u_boot_pylib import tools
class Entry_intel_ifwi(Entry_blob_ext):
"""Intel Integrated Firmware Image (IFWI) file
Properties / Entry arguments:
- filename: Filename of file to read into entry. This is either the
IFWI file itself, or a file that can be converted into one using a
tool
- convert-fit: If present this indicates that the ifwitool should be
used to convert the provided file into a IFWI.
This file contains code and data used by the SoC that is required to make
it work. It includes U-Boot TPL, microcode, things related to the CSE
(Converged Security Engine, the microcontroller that loads all the firmware)
and other items beyond the wit of man.
A typical filename is 'ifwi.bin' for an IFWI file, or 'fitimage.bin' for a
file that will be converted to an IFWI.
The position of this entry is generally set by the intel-descriptor entry.
The contents of the IFWI are specified by the subnodes of the IFWI node.
Each subnode describes an entry which is placed into the IFWFI with a given
sub-partition (and optional entry name).
Properties for subnodes:
- ifwi-subpart: sub-parition to put this entry into, e.g. "IBBP"
- ifwi-entry: entry name t use, e.g. "IBBL"
- ifwi-replace: if present, indicates that the item should be replaced
in the IFWI. Otherwise it is added.
See README.x86 for information about x86 binary blobs.
"""
def __init__(self, section, etype, node):
super().__init__(section, etype, node)
self._convert_fit = fdt_util.GetBool(self._node, 'convert-fit')
self._ifwi_entries = OrderedDict()
def ReadNode(self):
self.ReadEntries()
super().ReadNode()
def _BuildIfwi(self):
"""Build the contents of the IFWI and write it to the 'data' property"""
# Create the IFWI file if needed
if self._convert_fit:
inname = self._pathname
outname = tools.get_output_filename('ifwi.bin')
if self.ifwitool.create_ifwi(inname, outname) is None:
# Bintool is missing; just create a zeroed ifwi.bin
self.record_missing_bintool(self.ifwitool)
self.SetContents(tools.get_bytes(0, 1024))
self._filename = 'ifwi.bin'
self._pathname = outname
else:
# Provide a different code path here to ensure we have test coverage
outname = self._pathname
# Delete OBBP if it is there, then add the required new items
if self.ifwitool.delete_subpart(outname, 'OBBP') is None:
# Bintool is missing; just use zero data
self.record_missing_bintool(self.ifwitool)
self.SetContents(tools.get_bytes(0, 1024))
return True
for entry in self._ifwi_entries.values():
# First get the input data and put it in a file
data = entry.GetPaddedData()
uniq = self.GetUniqueName()
input_fname = tools.get_output_filename('input.%s' % uniq)
tools.write_file(input_fname, data)
# At this point we know that ifwitool is present, so we don't need
# to check for None here
self.ifwitool.add_subpart(
outname, entry._ifwi_subpart, entry._ifwi_entry_name,
input_fname, entry._ifwi_replace)
self.ReadBlobContents()
return True
def ObtainContents(self):
"""Get the contents for the IFWI
Unfortunately we cannot create anything from scratch here, as Intel has
tools which create precursor binaries with lots of data and settings,
and these are not incorporated into binman.
The first step is to get a file in the IFWI format. This is either
supplied directly or is extracted from a fitimage using the 'create'
subcommand.
After that we delete the OBBP sub-partition and add each of the files
that we want in the IFWI file, one for each sub-entry of the IWFI node.
"""
self._pathname = tools.get_input_filename(self._filename,
self.section.GetAllowMissing())
# Allow the file to be missing
if not self._pathname:
self.SetContents(b'')
self.missing = True
return True
for entry in self._ifwi_entries.values():
if not entry.ObtainContents():
return False
return self._BuildIfwi()
def ProcessContents(self):
if self.missing:
return True
orig_data = self.data
self._BuildIfwi()
same = orig_data == self.data
return same
def ReadEntries(self):
"""Read the subnodes to find out what should go in this IFWI"""
for node in self._node.subnodes:
entry = Entry.Create(self.section, node)
entry.ReadNode()
entry._ifwi_replace = fdt_util.GetBool(node, 'ifwi-replace')
entry._ifwi_subpart = fdt_util.GetString(node, 'ifwi-subpart')
entry._ifwi_entry_name = fdt_util.GetString(node, 'ifwi-entry')
self._ifwi_entries[entry._ifwi_subpart] = entry
def WriteSymbols(self, section):
"""Write symbol values into binary files for access at run time"""
if not self.missing:
for entry in self._ifwi_entries.values():
entry.WriteSymbols(self)
def AddBintools(self, btools):
super().AddBintools(btools)
self.ifwitool = self.AddBintool(btools, 'ifwitool')
|