]> git.sur5r.net Git - u-boot/blob - tools/genboardscfg.py
ARM: at91: ma5d4: Enable DFU and UMS
[u-boot] / tools / genboardscfg.py
1 #!/usr/bin/env python2
2 #
3 # Author: Masahiro Yamada <yamada.m@jp.panasonic.com>
4 #
5 # SPDX-License-Identifier:      GPL-2.0+
6 #
7
8 """
9 Converter from Kconfig and MAINTAINERS to a board database.
10
11 Run 'tools/genboardscfg.py' to create a board database.
12
13 Run 'tools/genboardscfg.py -h' for available options.
14
15 Python 2.6 or later, but not Python 3.x is necessary to run this script.
16 """
17
18 import errno
19 import fnmatch
20 import glob
21 import multiprocessing
22 import optparse
23 import os
24 import sys
25 import tempfile
26 import time
27
28 sys.path.append(os.path.join(os.path.dirname(__file__), 'buildman'))
29 import kconfiglib
30
31 ### constant variables ###
32 OUTPUT_FILE = 'boards.cfg'
33 CONFIG_DIR = 'configs'
34 SLEEP_TIME = 0.03
35 COMMENT_BLOCK = '''#
36 # List of boards
37 #   Automatically generated by %s: don't edit
38 #
39 # Status, Arch, CPU, SoC, Vendor, Board, Target, Options, Maintainers
40
41 ''' % __file__
42
43 ### helper functions ###
44 def try_remove(f):
45     """Remove a file ignoring 'No such file or directory' error."""
46     try:
47         os.remove(f)
48     except OSError as exception:
49         # Ignore 'No such file or directory' error
50         if exception.errno != errno.ENOENT:
51             raise
52
53 def check_top_directory():
54     """Exit if we are not at the top of source directory."""
55     for f in ('README', 'Licenses'):
56         if not os.path.exists(f):
57             sys.exit('Please run at the top of source directory.')
58
59 def output_is_new(output):
60     """Check if the output file is up to date.
61
62     Returns:
63       True if the given output file exists and is newer than any of
64       *_defconfig, MAINTAINERS and Kconfig*.  False otherwise.
65     """
66     try:
67         ctime = os.path.getctime(output)
68     except OSError as exception:
69         if exception.errno == errno.ENOENT:
70             # return False on 'No such file or directory' error
71             return False
72         else:
73             raise
74
75     for (dirpath, dirnames, filenames) in os.walk(CONFIG_DIR):
76         for filename in fnmatch.filter(filenames, '*_defconfig'):
77             if fnmatch.fnmatch(filename, '.*'):
78                 continue
79             filepath = os.path.join(dirpath, filename)
80             if ctime < os.path.getctime(filepath):
81                 return False
82
83     for (dirpath, dirnames, filenames) in os.walk('.'):
84         for filename in filenames:
85             if (fnmatch.fnmatch(filename, '*~') or
86                 not fnmatch.fnmatch(filename, 'Kconfig*') and
87                 not filename == 'MAINTAINERS'):
88                 continue
89             filepath = os.path.join(dirpath, filename)
90             if ctime < os.path.getctime(filepath):
91                 return False
92
93     # Detect a board that has been removed since the current board database
94     # was generated
95     with open(output) as f:
96         for line in f:
97             if line[0] == '#' or line == '\n':
98                 continue
99             defconfig = line.split()[6] + '_defconfig'
100             if not os.path.exists(os.path.join(CONFIG_DIR, defconfig)):
101                 return False
102
103     return True
104
105 ### classes ###
106 class KconfigScanner:
107
108     """Kconfig scanner."""
109
110     ### constant variable only used in this class ###
111     _SYMBOL_TABLE = {
112         'arch' : 'SYS_ARCH',
113         'cpu' : 'SYS_CPU',
114         'soc' : 'SYS_SOC',
115         'vendor' : 'SYS_VENDOR',
116         'board' : 'SYS_BOARD',
117         'config' : 'SYS_CONFIG_NAME',
118         'options' : 'SYS_EXTRA_OPTIONS'
119     }
120
121     def __init__(self):
122         """Scan all the Kconfig files and create a Config object."""
123         # Define environment variables referenced from Kconfig
124         os.environ['srctree'] = os.getcwd()
125         os.environ['UBOOTVERSION'] = 'dummy'
126         os.environ['KCONFIG_OBJDIR'] = ''
127         self._conf = kconfiglib.Config()
128
129     def __del__(self):
130         """Delete a leftover temporary file before exit.
131
132         The scan() method of this class creates a temporay file and deletes
133         it on success.  If scan() method throws an exception on the way,
134         the temporary file might be left over.  In that case, it should be
135         deleted in this destructor.
136         """
137         if hasattr(self, '_tmpfile') and self._tmpfile:
138             try_remove(self._tmpfile)
139
140     def scan(self, defconfig):
141         """Load a defconfig file to obtain board parameters.
142
143         Arguments:
144           defconfig: path to the defconfig file to be processed
145
146         Returns:
147           A dictionary of board parameters.  It has a form of:
148           {
149               'arch': <arch_name>,
150               'cpu': <cpu_name>,
151               'soc': <soc_name>,
152               'vendor': <vendor_name>,
153               'board': <board_name>,
154               'target': <target_name>,
155               'config': <config_header_name>,
156               'options': <extra_options>
157           }
158         """
159         # strip special prefixes and save it in a temporary file
160         fd, self._tmpfile = tempfile.mkstemp()
161         with os.fdopen(fd, 'w') as f:
162             for line in open(defconfig):
163                 colon = line.find(':CONFIG_')
164                 if colon == -1:
165                     f.write(line)
166                 else:
167                     f.write(line[colon + 1:])
168
169         self._conf.load_config(self._tmpfile)
170
171         try_remove(self._tmpfile)
172         self._tmpfile = None
173
174         params = {}
175
176         # Get the value of CONFIG_SYS_ARCH, CONFIG_SYS_CPU, ... etc.
177         # Set '-' if the value is empty.
178         for key, symbol in self._SYMBOL_TABLE.items():
179             value = self._conf.get_symbol(symbol).get_value()
180             if value:
181                 params[key] = value
182             else:
183                 params[key] = '-'
184
185         defconfig = os.path.basename(defconfig)
186         params['target'], match, rear = defconfig.partition('_defconfig')
187         assert match and not rear, '%s : invalid defconfig' % defconfig
188
189         # fix-up for aarch64
190         if params['arch'] == 'arm' and params['cpu'] == 'armv8':
191             params['arch'] = 'aarch64'
192
193         # fix-up options field. It should have the form:
194         # <config name>[:comma separated config options]
195         if params['options'] != '-':
196             params['options'] = params['config'] + ':' + \
197                                 params['options'].replace(r'\"', '"')
198         elif params['config'] != params['target']:
199             params['options'] = params['config']
200
201         return params
202
203 def scan_defconfigs_for_multiprocess(queue, defconfigs):
204     """Scan defconfig files and queue their board parameters
205
206     This function is intended to be passed to
207     multiprocessing.Process() constructor.
208
209     Arguments:
210       queue: An instance of multiprocessing.Queue().
211              The resulting board parameters are written into it.
212       defconfigs: A sequence of defconfig files to be scanned.
213     """
214     kconf_scanner = KconfigScanner()
215     for defconfig in defconfigs:
216         queue.put(kconf_scanner.scan(defconfig))
217
218 def read_queues(queues, params_list):
219     """Read the queues and append the data to the paramers list"""
220     for q in queues:
221         while not q.empty():
222             params_list.append(q.get())
223
224 def scan_defconfigs(jobs=1):
225     """Collect board parameters for all defconfig files.
226
227     This function invokes multiple processes for faster processing.
228
229     Arguments:
230       jobs: The number of jobs to run simultaneously
231     """
232     all_defconfigs = []
233     for (dirpath, dirnames, filenames) in os.walk(CONFIG_DIR):
234         for filename in fnmatch.filter(filenames, '*_defconfig'):
235             if fnmatch.fnmatch(filename, '.*'):
236                 continue
237             all_defconfigs.append(os.path.join(dirpath, filename))
238
239     total_boards = len(all_defconfigs)
240     processes = []
241     queues = []
242     for i in range(jobs):
243         defconfigs = all_defconfigs[total_boards * i / jobs :
244                                     total_boards * (i + 1) / jobs]
245         q = multiprocessing.Queue(maxsize=-1)
246         p = multiprocessing.Process(target=scan_defconfigs_for_multiprocess,
247                                     args=(q, defconfigs))
248         p.start()
249         processes.append(p)
250         queues.append(q)
251
252     # The resulting data should be accumulated to this list
253     params_list = []
254
255     # Data in the queues should be retrieved preriodically.
256     # Otherwise, the queues would become full and subprocesses would get stuck.
257     while any([p.is_alive() for p in processes]):
258         read_queues(queues, params_list)
259         # sleep for a while until the queues are filled
260         time.sleep(SLEEP_TIME)
261
262     # Joining subprocesses just in case
263     # (All subprocesses should already have been finished)
264     for p in processes:
265         p.join()
266
267     # retrieve leftover data
268     read_queues(queues, params_list)
269
270     return params_list
271
272 class MaintainersDatabase:
273
274     """The database of board status and maintainers."""
275
276     def __init__(self):
277         """Create an empty database."""
278         self.database = {}
279
280     def get_status(self, target):
281         """Return the status of the given board.
282
283         The board status is generally either 'Active' or 'Orphan'.
284         Display a warning message and return '-' if status information
285         is not found.
286
287         Returns:
288           'Active', 'Orphan' or '-'.
289         """
290         if not target in self.database:
291             print >> sys.stderr, "WARNING: no status info for '%s'" % target
292             return '-'
293
294         tmp = self.database[target][0]
295         if tmp.startswith('Maintained'):
296             return 'Active'
297         elif tmp.startswith('Supported'):
298             return 'Active'
299         elif tmp.startswith('Orphan'):
300             return 'Orphan'
301         else:
302             print >> sys.stderr, ("WARNING: %s: unknown status for '%s'" %
303                                   (tmp, target))
304             return '-'
305
306     def get_maintainers(self, target):
307         """Return the maintainers of the given board.
308
309         Returns:
310           Maintainers of the board.  If the board has two or more maintainers,
311           they are separated with colons.
312         """
313         if not target in self.database:
314             print >> sys.stderr, "WARNING: no maintainers for '%s'" % target
315             return ''
316
317         return ':'.join(self.database[target][1])
318
319     def parse_file(self, file):
320         """Parse a MAINTAINERS file.
321
322         Parse a MAINTAINERS file and accumulates board status and
323         maintainers information.
324
325         Arguments:
326           file: MAINTAINERS file to be parsed
327         """
328         targets = []
329         maintainers = []
330         status = '-'
331         for line in open(file):
332             # Check also commented maintainers
333             if line[:3] == '#M:':
334                 line = line[1:]
335             tag, rest = line[:2], line[2:].strip()
336             if tag == 'M:':
337                 maintainers.append(rest)
338             elif tag == 'F:':
339                 # expand wildcard and filter by 'configs/*_defconfig'
340                 for f in glob.glob(rest):
341                     front, match, rear = f.partition('configs/')
342                     if not front and match:
343                         front, match, rear = rear.rpartition('_defconfig')
344                         if match and not rear:
345                             targets.append(front)
346             elif tag == 'S:':
347                 status = rest
348             elif line == '\n':
349                 for target in targets:
350                     self.database[target] = (status, maintainers)
351                 targets = []
352                 maintainers = []
353                 status = '-'
354         if targets:
355             for target in targets:
356                 self.database[target] = (status, maintainers)
357
358 def insert_maintainers_info(params_list):
359     """Add Status and Maintainers information to the board parameters list.
360
361     Arguments:
362       params_list: A list of the board parameters
363     """
364     database = MaintainersDatabase()
365     for (dirpath, dirnames, filenames) in os.walk('.'):
366         if 'MAINTAINERS' in filenames:
367             database.parse_file(os.path.join(dirpath, 'MAINTAINERS'))
368
369     for i, params in enumerate(params_list):
370         target = params['target']
371         params['status'] = database.get_status(target)
372         params['maintainers'] = database.get_maintainers(target)
373         params_list[i] = params
374
375 def format_and_output(params_list, output):
376     """Write board parameters into a file.
377
378     Columnate the board parameters, sort lines alphabetically,
379     and then write them to a file.
380
381     Arguments:
382       params_list: The list of board parameters
383       output: The path to the output file
384     """
385     FIELDS = ('status', 'arch', 'cpu', 'soc', 'vendor', 'board', 'target',
386               'options', 'maintainers')
387
388     # First, decide the width of each column
389     max_length = dict([ (f, 0) for f in FIELDS])
390     for params in params_list:
391         for f in FIELDS:
392             max_length[f] = max(max_length[f], len(params[f]))
393
394     output_lines = []
395     for params in params_list:
396         line = ''
397         for f in FIELDS:
398             # insert two spaces between fields like column -t would
399             line += '  ' + params[f].ljust(max_length[f])
400         output_lines.append(line.strip())
401
402     # ignore case when sorting
403     output_lines.sort(key=str.lower)
404
405     with open(output, 'w') as f:
406         f.write(COMMENT_BLOCK + '\n'.join(output_lines) + '\n')
407
408 def gen_boards_cfg(output, jobs=1, force=False):
409     """Generate a board database file.
410
411     Arguments:
412       output: The name of the output file
413       jobs: The number of jobs to run simultaneously
414       force: Force to generate the output even if it is new
415     """
416     check_top_directory()
417
418     if not force and output_is_new(output):
419         print "%s is up to date. Nothing to do." % output
420         sys.exit(0)
421
422     params_list = scan_defconfigs(jobs)
423     insert_maintainers_info(params_list)
424     format_and_output(params_list, output)
425
426 def main():
427     try:
428         cpu_count = multiprocessing.cpu_count()
429     except NotImplementedError:
430         cpu_count = 1
431
432     parser = optparse.OptionParser()
433     # Add options here
434     parser.add_option('-f', '--force', action="store_true", default=False,
435                       help='regenerate the output even if it is new')
436     parser.add_option('-j', '--jobs', type='int', default=cpu_count,
437                       help='the number of jobs to run simultaneously')
438     parser.add_option('-o', '--output', default=OUTPUT_FILE,
439                       help='output file [default=%s]' % OUTPUT_FILE)
440     (options, args) = parser.parse_args()
441
442     gen_boards_cfg(options.output, jobs=options.jobs, force=options.force)
443
444 if __name__ == '__main__':
445     main()