]> git.sur5r.net Git - u-boot/blob - tools/microcode-tool.py
armv8/fsl-lsch3: Convert flushing L3 to assembly to avoid using stack
[u-boot] / tools / microcode-tool.py
1 #!/usr/bin/env python
2 #
3 # Copyright (c) 2014 Google, Inc
4 #
5 # SPDX-License-Identifier:      GPL-2.0+
6 #
7 # Intel microcode update tool
8
9 from optparse import OptionParser
10 import os
11 import re
12 import struct
13 import sys
14
15 MICROCODE_DIR = 'arch/x86/dts/microcode'
16
17 class Microcode:
18     """Holds information about the microcode for a particular model of CPU.
19
20     Attributes:
21         name:  Name of the CPU this microcode is for, including any version
22                    information (e.g. 'm12206a7_00000029')
23         model: Model code string (this is cpuid(1).eax, e.g. '206a7')
24         words: List of hex words containing the microcode. The first 16 words
25                    are the public header.
26     """
27     def __init__(self, name, data):
28         self.name = name
29         # Convert data into a list of hex words
30         self.words = []
31         for value in ''.join(data).split(','):
32             hexval = value.strip()
33             if hexval:
34                 self.words.append(int(hexval, 0))
35
36         # The model is in the 4rd hex word
37         self.model = '%x' % self.words[3]
38
39 def ParseFile(fname):
40     """Parse a micrcode.dat file and return the component parts
41
42     Args:
43         fname: Filename to parse
44     Returns:
45         3-Tuple:
46             date:         String containing date from the file's header
47             license_text: List of text lines for the license file
48             microcodes:   List of Microcode objects from the file
49     """
50     re_date = re.compile('/\* *(.* [0-9]{4}) *\*/$')
51     re_license = re.compile('/[^-*+] *(.*)$')
52     re_name = re.compile('/\* *(.*)\.inc *\*/', re.IGNORECASE)
53     microcodes = {}
54     license_text = []
55     date = ''
56     data = []
57     name = None
58     with open(fname) as fd:
59         for line in fd:
60             line = line.rstrip()
61             m_date = re_date.match(line)
62             m_license = re_license.match(line)
63             m_name = re_name.match(line)
64             if m_name:
65                 if name:
66                     microcodes[name] = Microcode(name, data)
67                 name = m_name.group(1).lower()
68                 data = []
69             elif m_license:
70                 license_text.append(m_license.group(1))
71             elif m_date:
72                 date = m_date.group(1)
73             else:
74                 data.append(line)
75     if name:
76         microcodes[name] = Microcode(name, data)
77     return date, license_text, microcodes
78
79 def ParseHeaderFiles(fname_list):
80     """Parse a list of header files and return the component parts
81
82     Args:
83         fname_list: List of files to parse
84     Returns:
85             date:         String containing date from the file's header
86             license_text: List of text lines for the license file
87             microcodes:   List of Microcode objects from the file
88     """
89     microcodes = {}
90     license_text = []
91     date = ''
92     name = None
93     for fname in fname_list:
94         name = os.path.basename(fname).lower()
95         name = os.path.splitext(name)[0]
96         data = []
97         with open(fname) as fd:
98             for line in fd:
99                 line = line.rstrip()
100
101                 # Omit anything after the last comma
102                 words = line.split(',')[:-1]
103                 data += [word + ',' for word in words]
104         microcodes[name] = Microcode(name, data)
105     return date, license_text, microcodes
106
107
108 def List(date, microcodes, model):
109     """List the available microcode chunks
110
111     Args:
112         date:           Date of the microcode file
113         microcodes:     Dict of Microcode objects indexed by name
114         model:          Model string to search for, or None
115     """
116     print 'Date: %s' % date
117     if model:
118         mcode_list, tried = FindMicrocode(microcodes, model.lower())
119         print 'Matching models %s:' % (', '.join(tried))
120     else:
121         print 'All models:'
122         mcode_list = [microcodes[m] for m in microcodes.keys()]
123     for mcode in mcode_list:
124         print '%-20s: model %s' % (mcode.name, mcode.model)
125
126 def FindMicrocode(microcodes, model):
127     """Find all the microcode chunks which match the given model.
128
129     This model is something like 306a9 (the value returned in eax from
130     cpuid(1) when running on Intel CPUs). But we allow a partial match,
131     omitting the last 1 or two characters to allow many families to have the
132     same microcode.
133
134     If the model name is ambiguous we return a list of matches.
135
136     Args:
137         microcodes: Dict of Microcode objects indexed by name
138         model:      String containing model name to find
139     Returns:
140         Tuple:
141             List of matching Microcode objects
142             List of abbreviations we tried
143     """
144     # Allow a full name to be used
145     mcode = microcodes.get(model)
146     if mcode:
147         return [mcode], []
148
149     tried = []
150     found = []
151     for i in range(3):
152         abbrev = model[:-i] if i else model
153         tried.append(abbrev)
154         for mcode in microcodes.values():
155             if mcode.model.startswith(abbrev):
156                 found.append(mcode)
157         if found:
158             break
159     return found, tried
160
161 def CreateFile(date, license_text, mcodes, outfile):
162     """Create a microcode file in U-Boot's .dtsi format
163
164     Args:
165         date:       String containing date of original microcode file
166         license:    List of text lines for the license file
167         mcodes:      Microcode objects to write (normally only 1)
168         outfile:    Filename to write to ('-' for stdout)
169     """
170     out = '''/*%s
171  * ---
172  * This is a device tree fragment. Use #include to add these properties to a
173  * node.
174  *
175  * Date: %s
176  */
177
178 compatible = "intel,microcode";
179 intel,header-version = <%d>;
180 intel,update-revision = <%#x>;
181 intel,date-code = <%#x>;
182 intel,processor-signature = <%#x>;
183 intel,checksum = <%#x>;
184 intel,loader-revision = <%d>;
185 intel,processor-flags = <%#x>;
186
187 /* The first 48-bytes are the public header which repeats the above data */
188 data = <%s
189 \t>;'''
190     words = ''
191     add_comments = len(mcodes) > 1
192     for mcode in mcodes:
193         if add_comments:
194             words += '\n/* %s */' % mcode.name
195         for i in range(len(mcode.words)):
196             if not (i & 3):
197                 words += '\n'
198             val = mcode.words[i]
199             # Change each word so it will be little-endian in the FDT
200             # This data is needed before RAM is available on some platforms so
201             # we cannot do an endianness swap on boot.
202             val = struct.unpack("<I", struct.pack(">I", val))[0]
203             words += '\t%#010x' % val
204
205     # Use the first microcode for the headers
206     mcode = mcodes[0]
207
208     # Take care to avoid adding a space before a tab
209     text = ''
210     for line in license_text:
211         if line[0] == '\t':
212             text += '\n *' + line
213         else:
214             text += '\n * ' + line
215     args = [text, date]
216     args += [mcode.words[i] for i in range(7)]
217     args.append(words)
218     if outfile == '-':
219         print out % tuple(args)
220     else:
221         if not outfile:
222             if not os.path.exists(MICROCODE_DIR):
223                 print >> sys.stderr, "Creating directory '%s'" % MICROCODE_DIR
224                 os.makedirs(MICROCODE_DIR)
225             outfile = os.path.join(MICROCODE_DIR, mcode.name + '.dtsi')
226         print >> sys.stderr, "Writing microcode for '%s' to '%s'" % (
227                 ', '.join([mcode.name for mcode in mcodes]), outfile)
228         with open(outfile, 'w') as fd:
229             print >> fd, out % tuple(args)
230
231 def MicrocodeTool():
232     """Run the microcode tool"""
233     commands = 'create,license,list'.split(',')
234     parser = OptionParser()
235     parser.add_option('-d', '--mcfile', type='string', action='store',
236                     help='Name of microcode.dat file')
237     parser.add_option('-H', '--headerfile', type='string', action='append',
238                     help='Name of .h file containing microcode')
239     parser.add_option('-m', '--model', type='string', action='store',
240                     help="Model name to extract ('all' for all)")
241     parser.add_option('-M', '--multiple', type='string', action='store',
242                     help="Allow output of multiple models")
243     parser.add_option('-o', '--outfile', type='string', action='store',
244                     help='Filename to use for output (- for stdout), default is'
245                     ' %s/<name>.dtsi' % MICROCODE_DIR)
246     parser.usage += """ command
247
248     Process an Intel microcode file (use -h for help). Commands:
249
250        create     Create microcode .dtsi file for a model
251        list       List available models in microcode file
252        license    Print the license
253
254     Typical usage:
255
256        ./tools/microcode-tool -d microcode.dat -m 306a create
257
258     This will find the appropriate file and write it to %s.""" % MICROCODE_DIR
259
260     (options, args) = parser.parse_args()
261     if not args:
262         parser.error('Please specify a command')
263     cmd = args[0]
264     if cmd not in commands:
265         parser.error("Unknown command '%s'" % cmd)
266
267     if (not not options.mcfile) != (not not options.mcfile):
268         parser.error("You must specify either header files or a microcode file, not both")
269     if options.headerfile:
270         date, license_text, microcodes = ParseHeaderFiles(options.headerfile)
271     elif options.mcfile:
272         date, license_text, microcodes = ParseFile(options.mcfile)
273     else:
274         parser.error('You must specify a microcode file (or header files)')
275
276     if cmd == 'list':
277         List(date, microcodes, options.model)
278     elif cmd == 'license':
279         print '\n'.join(license_text)
280     elif cmd == 'create':
281         if not options.model:
282             parser.error('You must specify a model to create')
283         model = options.model.lower()
284         if options.model == 'all':
285             options.multiple = True
286             mcode_list = microcodes.values()
287             tried = []
288         else:
289             mcode_list, tried = FindMicrocode(microcodes, model)
290         if not mcode_list:
291             parser.error("Unknown model '%s' (%s) - try 'list' to list" %
292                         (model, ', '.join(tried)))
293         if not options.multiple and len(mcode_list) > 1:
294             parser.error("Ambiguous model '%s' (%s) matched %s - try 'list' "
295                         "to list or specify a particular file" %
296                         (model, ', '.join(tried),
297                         ', '.join([m.name for m in mcode_list])))
298         CreateFile(date, license_text, mcode_list, options.outfile)
299     else:
300         parser.error("Unknown command '%s'" % cmd)
301
302 if __name__ == "__main__":
303     MicrocodeTool()