• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1#!/usr/bin/perl
2
3# Copyright 2016 by Frank Rowand
4# Copyright 2016 by Gaurav Minocha
5#
6# This file is subject to the terms and conditions of the GNU General Public
7# License v2.
8
9use strict 'refs';
10use strict subs;
11
12use Getopt::Long;
13
14$VUFX = "160610a";
15
16$script_name = $0;
17$script_name =~ s|^.*/||;
18
19
20# ----- constants for print_flags()
21
22# Position in string $pr_flags.  Range of 0..($num_pr_flags - 1).
23$pr_flag_pos_mcompatible       = 0;
24$pr_flag_pos_driver            = 1;
25$pr_flag_pos_mdriver           = 2;
26$pr_flag_pos_config            = 3;
27$pr_flag_pos_mconfig           = 4;
28$pr_flag_pos_node_not_enabled  = 5;
29$pr_flag_pos_white_list        = 6;
30$pr_flag_pos_hard_coded        = 7;
31$pr_flag_pos_config_hard_coded = 8;
32$pr_flag_pos_config_none       = 9;
33$pr_flag_pos_config_m          = 10;
34$pr_flag_pos_config_y          = 11;
35$pr_flag_pos_config_test_fail  = 12;
36
37$num_pr_flags = $pr_flag_pos_config_test_fail + 1;
38
39# flags in @pr_flag_value must be unique values to allow simple regular
40# expessions to work for --include_flags and --exclude_flags.
41# Convention: use upper case letters for potential issues or problems.
42
43@pr_flag_value = ('M', 'd', 'D', 'c', 'C', 'E', 'W', 'H', 'x', 'n', 'm', 'y', 'F');
44
45@pr_flag_help = (
46    "multiple compatibles found for this node",
47    "driver found for this compatible",
48    "multiple drivers found for this compatible",
49    "kernel config found for this driver",
50    "multiple config options found for this driver",
51    "node is not enabled",
52    "compatible is white listed",
53    "matching driver and/or kernel config is hard coded",
54    "kernel config hard coded in Makefile",
55    "one or more kernel config file options is not set",
56    "one or more kernel config file options is set to 'm'",
57    "one or more kernel config file options is set to 'y'",
58    "one of more kernel config file options fails to have correct value"
59);
60
61
62# -----
63
64%driver_config = ();   # driver config array, indexed by driver source file
65%driver_count = ();    # driver_cnt, indexed by compatible
66%compat_driver = ();   # compatible driver array, indexed by compatible
67%existing_config = (); # existing config symbols present in given config file
68                       # expected values are: "y", "m", a decimal number, a
69                       # hex number, or a string
70
71# ----- magic compatibles, do not have a driver
72#
73# Will not search for drivers for these compatibles.
74
75%compat_white_list = (
76       'none'                  => '1',
77       'pci'                   => '1',
78       'simple-bus'            => '1',
79);
80
81# Will not search for drivers for these compatibles.
82#
83# These compatibles have a very large number of false positives.
84#
85# 'hardcoded_no_driver' is a magic value.  Other code knows this
86# magic value.  Do not use 'no_driver' here!
87#
88# Revisit each 'hardcoded_no_driver' to see how the compatible
89# is used.  Are there drivers that can be provided?
90
91%driver_hard_code_list = (
92       'cache'                 => ['hardcoded_no_driver'],
93       'eeprom'                => ['hardcoded_no_driver'],
94       'gpio'                  => ['hardcoded_no_driver'],
95       'gpio-keys'             => ['drivers/input/keyboard/gpio_keys.c'],
96       'i2c-gpio'              => ['drivers/i2c/busses/i2c-gpio.c'],
97       'isa'                   => ['arch/mips/mti-malta/malta-dt.c',
98                                    'arch/x86/kernel/devicetree.c'],
99       'led'                   => ['hardcoded_no_driver'],
100       'm25p32'                => ['hardcoded_no_driver'],
101       'm25p64'                => ['hardcoded_no_driver'],
102       'm25p80'                => ['hardcoded_no_driver'],
103       'mtd-ram'               => ['drivers/mtd/maps/physmap_of.c'],
104       'pwm-backlight'         => ['drivers/video/backlight/pwm_bl.c'],
105       'spidev'                => ['hardcoded_no_driver'],
106       'syscon'                => ['drivers/mfd/syscon.c'],
107       'tlv320aic23'           => ['hardcoded_no_driver'],
108       'wm8731'                => ['hardcoded_no_driver'],
109);
110
111# Use these config options instead of searching makefiles
112
113%driver_config_hard_code_list = (
114
115       # this one needed even if %driver_hard_code_list is empty
116       'no_driver'                             => ['no_config'],
117       'hardcoded_no_driver'                   => ['no_config'],
118
119       # drivers/usb/host/ehci-ppc-of.c
120       # drivers/usb/host/ehci-xilinx-of.c
121       #  are included from:
122       #    drivers/usb/host/ehci-hcd.c
123       #  thus the search of Makefile for the included .c files is incorrect
124       # ehci-hcd.c wraps the includes with ifdef CONFIG_USB_EHCI_HCD_..._OF
125       #
126       # similar model for ohci-hcd.c (but no ohci-xilinx-of.c)
127       #
128       # similarly, uhci-hcd.c includes uhci-platform.c
129
130       'drivers/usb/host/ehci-ppc-of.c'        => ['CONFIG_USB_EHCI_HCD',
131                                                   'CONFIG_USB_EHCI_HCD_PPC_OF'],
132       'drivers/usb/host/ohci-ppc-of.c'        => ['CONFIG_USB_OHCI_HCD',
133                                                   'CONFIG_USB_OHCI_HCD_PPC_OF'],
134
135       'drivers/usb/host/ehci-xilinx-of.c'     => ['CONFIG_USB_EHCI_HCD',
136                                                   'CONFIG_USB_EHCI_HCD_XILINX'],
137
138       'drivers/usb/host/uhci-platform.c'      => ['CONFIG_USB_UHCI_HCD',
139                                                   'CONFIG_USB_UHCI_PLATFORM'],
140
141       # scan_makefile will find only one of these config options:
142       #    ifneq ($(CONFIG_SOC_IMX6)$(CONFIG_SOC_LS1021A),)
143       'arch/arm/mach-imx/platsmp.c'           => ['CONFIG_SOC_IMX6 && CONFIG_SMP',
144                                                   'CONFIG_SOC_LS1021A && CONFIG_SMP'],
145);
146
147
148# 'virt/kvm/arm/.*' are controlled by makefiles in other directories,
149# using relative paths, such as 'KVM := ../../../virt/kvm'.  Do not
150# add complexity to find_kconfig() to deal with this.  There is a long
151# term intent to change the kvm related makefiles to the normal kernel
152# style.  After that is done, this entry can be removed from the
153# black_list_driver.
154
155@black_list_driver = (
156       # kvm no longer a problem after commit 503a62862e8f in 4.7-rc1
157       # 'virt/kvm/arm/.*',
158);
159
160
161sub usage()
162{
163       print
164"
165Usage: $script_name [options] device-tree...
166
167    device_tree is: dts_file | dtb_file | proc_device-tree
168
169
170Valid options:
171     -c FILE             Read kernel config options from FILE
172    --config FILE        synonym for 'c'
173    --config-format      config file friendly output format
174    --exclude-flag FLAG  exclude entries with a matching flag
175     -h                  Display this message and exit
176    --help               synonym for 'h'
177    --black-list-driver  use driver black list
178    --white-list-config  use config white list
179    --white-list-driver  use driver white list
180    --include-flag FLAG  include only entries with a matching flag
181    --include-suspect    include only entries with an uppercase flag
182    --short-name         do not show the path portion of the node name
183    --show-lists         report of white and black lists
184    --version            Display program version and exit
185
186
187  Report driver source files that match the compatibles in the device
188  tree file and the kernel config options that enable the driver source
189  files.
190
191  This program must be run in the root directory of a Linux kernel
192  source tree.
193
194  The default format is a report that is intended to be easily human
195  scannable.
196
197  An alternate format can be selected by --config-format.  This will
198  create output that can easily be edited to create a fragment that can
199  be appended to the existing kernel config file.  Each entry consists of
200  multiple lines.  The first line reports flags, the node path, compatible
201  value, driver file matching the compatible, configuration options, and
202  current values of the configuration options.  For each configuration
203  option, the following lines report the current value and the value that
204  is required for the driver file to be included in the kernel.
205
206  If a large number of drivers or config options is listed for a node,
207  and the '$pr_flag_value[$pr_flag_pos_hard_coded]' flag is set consider using --white-list-config and/or
208  --white-list-driver.  If the white list option suppresses the correct
209  entry please report that as a bug.
210
211  CAUTION:
212     This program uses heuristics to guess which driver(s) support each
213     compatible string and which config option(s) enables the driver(s).
214     Do not believe that the reported information is fully correct.
215     This program is intended to aid the process of determining the
216     proper kernel configuration for a device tree, but this is not
217     a fully automated process -- human involvement may still be
218     required!
219
220     The driver match heuristic used is to search for source files
221     containing the compatible string enclosed in quotes.
222
223     This program might not be able to find all drivers matching a
224     compatible string.
225
226     Some makefiles are overly clever.  This program was not made
227     complex enough to handle them.  If no config option is listed
228     for a driver, look at the makefile for the driver source file.
229     Even if a config option is listed for a driver, some other
230     available config options may not be listed.
231
232  FLAG values:
233";
234
235       for ($k = 0; $k < $num_pr_flags; $k++) {
236               printf "     %s   %s\n", $pr_flag_value[$k], $pr_flag_help[$k];
237       }
238
239       print
240"
241     Upper case letters indicate potential issues or problems.
242
243  The flag:
244
245";
246
247       $k = $pr_flag_pos_hard_coded;
248       printf "     %s   %s\n", $pr_flag_value[$k], $pr_flag_help[$k];
249
250       print
251"
252  will be set if the config or driver is in the white lists, even if
253  --white-list-config and --white-list-driver are not specified.
254  This is a hint that 1) many of these reported lines are likely to
255  be incorrect, and 2) using those options will reduce the number of
256  drivers and/or config options reported.
257
258  --white-list-config and --white-list-driver may not be accurate if this
259  program is not well maintained.  Use them with appropriate skepticism.
260  Use the --show-lists option to report the values in the list.
261
262  Return value:
263    0   if no error
264    1   error processing command line
265    2   unable to open or read kernel config file
266    3   unable to open or process input device tree file(s)
267
268  EXAMPLES:
269
270     dt_to_config arch/arm/boot/dts/my_dts_file.dts
271
272       Basic report.
273
274     dt_to_config \\
275        --config \${KBUILD_OUTPUT}/.config \\
276        arch/\${ARCH}/boot/dts/my_dts_file.dts
277
278       Full report, with config file issues noted.
279
280     dt_to_config --include-suspect \\
281        --config \${KBUILD_OUTPUT}/.config \\
282        arch/\${ARCH}/boot/dts/my_dts_file.dts
283
284       Report of node / compatible string / driver tuples that should
285       be further investigated.  A node may have multiple compatible
286       strings.  A compatible string may be matched by multiple drivers.
287       A driver may have config file issues noted.  The compatible string
288       and/or driver may be in the white lists.
289
290     dt_to_config --include-suspect --config-format \\
291        --config ${KBUILD_OUTPUT}/.config \\
292        arch/\${ARCH}/boot/dts/my_dts_file.dts
293
294       Report of node / compatible string / driver tuples that should
295       be further investigated.  The report can be edited to uncomment
296       the config options to select the desired tuple for a given node.
297       A node may have multiple compatible strings.  A compatible string
298       may be matched by multiple drivers.  A driver may have config file
299       issues noted.  The compatible string and/or driver may be in the
300       white lists.
301
302";
303}
304
305sub set_flag()
306{
307       # pr_flags_ref is a reference to $pr_flags
308
309       my $pr_flags_ref = shift;
310       my $pos          = shift;
311
312       substr $$pr_flags_ref, $pos, 1, $pr_flag_value[$pos];
313
314       return $pr_flags;
315}
316
317sub print_flags()
318{
319       # return 1 if anything printed, else 0
320
321       # some fields of pn_arg_ref might not be used in this function, but
322       # extract all of them anyway.
323       my $pn_arg_ref     = shift;
324
325       my $compat         = $pn_arg_ref->{compat};
326       my $compatible_cnt = $pn_arg_ref->{compatible_cnt};
327       my $config         = $pn_arg_ref->{config};
328       my $config_cnt     = $pn_arg_ref->{config_cnt};
329       my $driver         = $pn_arg_ref->{driver};
330       my $driver_cnt     = $pn_arg_ref->{driver_cnt};
331       my $full_node      = $pn_arg_ref->{full_node};
332       my $node           = $pn_arg_ref->{node};
333       my $node_enabled   = $pn_arg_ref->{node_enabled};
334       my $white_list     = $pn_arg_ref->{white_list};
335
336       my $pr_flags       = '-' x $num_pr_flags;
337
338
339       # ----- set flags in $pr_flags
340
341       if ($compatible_cnt > 1) {
342               &set_flag(\$pr_flags, $pr_flag_pos_mcompatible);
343       }
344
345       if ($config_cnt > 1) {
346               &set_flag(\$pr_flags, $pr_flag_pos_mconfig);
347       }
348
349       if ($driver_cnt >= 1) {
350               &set_flag(\$pr_flags, $pr_flag_pos_driver);
351       }
352
353       if ($driver_cnt > 1) {
354               &set_flag(\$pr_flags, $pr_flag_pos_mdriver);
355       }
356
357       # These strings are the same way the linux kernel tests.
358       # The ePapr lists of values is slightly different.
359       if (!(
360             ($node_enabled eq "") ||
361             ($node_enabled eq "ok") ||
362             ($node_enabled eq "okay")
363            )) {
364               &set_flag(\$pr_flags, $pr_flag_pos_node_not_enabled);
365       }
366
367       if ($white_list) {
368               &set_flag(\$pr_flags, $pr_flag_pos_white_list);
369       }
370
371       if (exists($driver_hard_code_list{$compat}) ||
372           (exists($driver_config_hard_code_list{$driver}) &&
373            ($driver ne "no_driver"))) {
374               &set_flag(\$pr_flags, $pr_flag_pos_hard_coded);
375       }
376
377       my @configs = split(' && ', $config);
378       for $configs (@configs) {
379               $not = $configs =~ /^!/;
380               $configs =~ s/^!//;
381
382               if (($configs ne "no_config") && ($configs ne "no_makefile")) {
383                       &set_flag(\$pr_flags, $pr_flag_pos_config);
384               }
385
386               if (($config_cnt >= 1) &&
387                   ($configs !~ /CONFIG_/) &&
388                   (($configs ne "no_config") && ($configs ne "no_makefile"))) {
389                       &set_flag(\$pr_flags, $pr_flag_pos_config_hard_coded);
390               }
391
392               my $existing_config = $existing_config{$configs};
393               if ($existing_config eq "m") {
394                       &set_flag(\$pr_flags, $pr_flag_pos_config_m);
395                       # Possible fail, depends on whether built in or
396                       # module is desired.
397                       &set_flag(\$pr_flags, $pr_flag_pos_config_test_fail);
398               } elsif ($existing_config eq "y") {
399                       &set_flag(\$pr_flags, $pr_flag_pos_config_y);
400                       if ($not) {
401                               &set_flag(\$pr_flags, $pr_flag_pos_config_test_fail);
402                       }
403               } elsif (($config_file) && ($configs =~ /CONFIG_/)) {
404                       &set_flag(\$pr_flags, $pr_flag_pos_config_none);
405                       if (!$not) {
406                               &set_flag(\$pr_flags, $pr_flag_pos_config_test_fail);
407                       }
408               }
409       }
410
411       # ----- include / exclude filters
412
413       if ($include_flag_pattern && ($pr_flags !~ m/$include_flag_pattern/)) {
414               return 0;
415       }
416
417       if ($exclude_flag_pattern && ($pr_flags =~ m/$exclude_flag_pattern/)) {
418               return 0;
419       }
420
421       if ($config_format) {
422               print "# ";
423       }
424       print "$pr_flags : ";
425
426       return 1;
427}
428
429
430sub print_node()
431{
432       # return number of lines printed
433
434       # some fields of pn_arg_ref might not be used in this function, but
435       # extract all of them anyway.
436       my $pn_arg_ref     = shift;
437
438       my $compat         = $pn_arg_ref->{compat};
439       my $compatible_cnt = $pn_arg_ref->{compatible_cnt};
440       my $config         = $pn_arg_ref->{config};
441       my $config_cnt     = $pn_arg_ref->{config_cnt};
442       my $driver         = $pn_arg_ref->{driver};
443       my $driver_cnt     = $pn_arg_ref->{driver_cnt};
444       my $full_node      = $pn_arg_ref->{full_node};
445       my $node           = $pn_arg_ref->{node};
446       my $node_enabled   = $pn_arg_ref->{node_enabled};
447       my $white_list     = $pn_arg_ref->{white_list};
448
449       my $separator;
450
451       if (! &print_flags($pn_arg_ref)) {
452               return 0;
453       }
454
455
456       if ($short_name) {
457               print "$node";
458       } else {
459               print "$full_node";
460       }
461       print " : $compat : $driver : $config : ";
462
463       my @configs = split(' && ', $config);
464
465       if ($config_file) {
466               for $configs (@configs) {
467                       $configs =~ s/^!//;
468                       my $existing_config = $existing_config{$configs};
469                       if (!$existing_config) {
470                               # check for /-m/, /-y/, or /-objs/
471                               if ($configs !~ /CONFIG_/) {
472                                       $existing_config = "x";
473                               };
474                       };
475                       if ($existing_config) {
476                               print "$separator", "$existing_config";
477                               $separator = ", ";
478                       } else {
479                               print "$separator", "n";
480                               $separator = ", ";
481                       }
482               }
483       } else {
484               print "none";
485       }
486
487       print "\n";
488
489       if ($config_format) {
490               for $configs (@configs) {
491                       $not = $configs =~ /^!/;
492                       $configs =~ s/^!//;
493                       my $existing_config = $existing_config{$configs};
494
495                       if ($not) {
496                               if ($configs !~ /CONFIG_/) {
497                                       print "# $configs\n";
498                               } elsif ($existing_config eq "m") {
499                                       print "# $configs is m\n";
500                                       print "# $configs=n\n";
501                               } elsif ($existing_config eq "y") {
502                                       print "# $configs is set\n";
503                                       print "# $configs=n\n";
504                               } else {
505                                       print "# $configs is not set\n";
506                                       print "# $configs=n\n";
507                               }
508
509                       } else {
510                               if ($configs !~ /CONFIG_/) {
511                                       print "# $configs\n";
512                               } elsif ($existing_config eq "m") {
513                                       print "# $configs is m\n";
514                                       print "# $configs=y\n";
515                               } elsif ($existing_config eq "y") {
516                                       print "# $configs is set\n";
517                                       print "# $configs=y\n";
518                               } else {
519                                       print "# $configs is not set\n";
520                                       print "# $configs=y\n";
521                               }
522                       }
523               }
524       }
525
526       return 1;
527}
528
529
530sub scan_makefile
531{
532       my $pn_arg_ref    = shift;
533       my $driver        = shift;
534
535       # ----- Find Kconfig symbols that enable driver
536
537       my ($dir, $base) = $driver =~ m{(.*)/(.*).c};
538
539       my $makefile = $dir . "/Makefile";
540       if (! -r $makefile) {
541               $makefile = $dir . "/Kbuild";
542       }
543       if (! -r $makefile) {
544               my $config;
545
546               $config = 'no_makefile';
547               push @{ $driver_config{$driver} }, $config;
548               return;
549       }
550
551       if (!open(MAKEFILE_FILE, "<", "$makefile")) {
552               return;
553       }
554
555       my $line;
556       my @config;
557       my @if_config;
558       my @make_var;
559
560       NEXT_LINE:
561       while ($next_line = <MAKEFILE_FILE>) {
562               my $config;
563               my $if_config;
564               my $ifdef;
565               my $ifeq;
566               my $ifndef;
567               my $ifneq;
568               my $ifdef_config;
569               my $ifeq_config;
570               my $ifndef_config;
571               my $ifneq_config;
572
573               chomp($next_line);
574               $line = $line . $next_line;
575               if ($next_line =~ /\\$/) {
576                       $line =~ s/\\$/ /;
577                       next NEXT_LINE;
578               }
579               if ($line =~ /^\s*#/) {
580                       $line = "";
581                       next NEXT_LINE;
582               }
583
584               # -----  condition ... else ... endif
585
586               if ($line =~ /^([ ]\s*|)else\b/) {
587                       $if_config = "!" . pop @if_config;
588                       $if_config =~ s/^!!//;
589                       push @if_config, $if_config;
590                       $line =~ s/^([ ]\s*|)else\b//;
591               }
592
593               ($null, $ifeq_config,  $ifeq_config_val )  = $line =~ /^([ ]\s*|)ifeq\b.*\b(CONFIG_[A-Za-z0-9_]*)(.*)/;
594               ($null, $ifneq_config, $ifneq_config_val)  = $line =~ /^([ ]\s*|)ifneq\b.*\b(CONFIG_[A-Za-z0-9_]*)(.*)/;
595               ($null, $ifdef_config)                     = $line =~ /^([ ]\s*|)ifdef\b.*\b(CONFIG_[A-Za-z0-9_]*)/;
596               ($null, $ifndef_config)                    = $line =~ /^([ ]\s*|)ifndef\b.*\b(CONFIG_[A-Za-z0-9_]*)/;
597
598               ($null, $ifeq)   = $line =~ /^([ ]\s*|)ifeq\b\s*(.*)/;
599               ($null, $ifneq)  = $line =~ /^([ ]\s*|)ifneq\b\s*(.*)/;
600               ($null, $ifdef)  = $line =~ /^([ ]\s*|)ifdef\b\s*(.*)/;
601               ($null, $ifndef) = $line =~ /^([ ]\s*|)ifndef\b\s*(.*)/;
602
603               # Order of tests is important.  Prefer "CONFIG_*" regex match over
604               # less specific regex match.
605               if ($ifdef_config) {
606                       $if_config = $ifdef_config;
607               } elsif ($ifeq_config) {
608                       if ($ifeq_config_val =~ /y/) {
609                               $if_config = $ifeq_config;
610                       } else {
611                               $if_config = "!" . $ifeq_config;
612                       }
613               } elsif ($ifndef_config) {
614                       $if_config = "!" . $ifndef_config;
615               } elsif ($ifneq_config) {
616                       if ($ifneq_config_val =~ /y/) {
617                               $if_config = "!" . $ifneq_config;
618                       } else {
619                               $if_config = $ifneq_config;
620                       }
621               } elsif ($ifdef) {
622                       $if_config = $ifdef;
623               } elsif ($ifeq) {
624                       $if_config = $ifeq;
625               } elsif ($ifndef) {
626                       $if_config = "!" . $ifndef;
627               } elsif ($ifneq) {
628                       $if_config = "!" . $ifneq;
629               } else {
630                       $if_config = "";
631               }
632               $if_config =~ s/^!!//;
633
634               if ($if_config) {
635                       push @if_config, $if_config;
636                       $line = "";
637                       next NEXT_LINE;
638               }
639
640               if ($line =~ /^([ ]\s*|)endif\b/) {
641                       pop @if_config;
642                       $line = "";
643                       next NEXT_LINE;
644               }
645
646               # ----- simple CONFIG_* = *.[co]  or  xxx [+:?]*= *.[co]
647               # Most makefiles select on *.o, but
648               # arch/powerpc/boot/Makefile selects on *.c
649
650               ($config) = $line =~ /(CONFIG_[A-Za-z0-9_]+).*\b$base.[co]\b/;
651
652               # ----- match a make variable instead of *.[co]
653               # Recursively expanded variables are not handled.
654
655               if (!$config) {
656                       my $make_var;
657                       ($make_var) = $line =~ /\s*(\S+?)\s*[+:\?]*=.*\b$base.[co]\b/;
658                       if ($make_var) {
659                               if ($make_var =~ /[a-zA-Z0-9]+-[ym]/) {
660                                       $config = $make_var;
661                               } elsif ($make_var =~ /[a-zA-Z0-9]+-objs/) {
662                                       $config = $make_var;
663                               } else {
664                                       push @make_var, $make_var;
665                               }
666                       }
667               }
668
669               if (!$config) {
670                       for $make_var (@make_var) {
671                               ($config) = $line =~ /(CONFIG_[A-Za-z0-9_]+).*\b$make_var\b/;
672                               last if ($config);
673                       }
674               }
675
676               if (!$config) {
677                       for $make_var (@make_var) {
678                               ($config) = $line =~ /\s*(\S+?)\s*[+:\?]*=.*\b$make_var\b/;
679                               last if ($config);
680                       }
681               }
682
683               # ----- next if no config found
684
685               if (!$config) {
686                       $line = "";
687                       next NEXT_LINE;
688               }
689
690               for $if_config (@if_config) {
691                       $config = $if_config . " && " . $config;
692               }
693
694               push @{ $driver_config{$driver} }, $config;
695
696               $line = "";
697       }
698
699       close(MAKEFILE_FILE);
700
701}
702
703
704sub find_kconfig
705{
706       my $pn_arg_ref    = shift;
707       my $driver        = shift;
708
709       my $lines_printed = 0;
710       my @configs;
711
712       if (!@{ $driver_config{$driver} }) {
713               &scan_makefile($pn_arg_ref, $driver);
714               if (!@{ $driver_config{$driver} }) {
715                       push @{ $driver_config{$driver} }, "no_config";
716               }
717       }
718
719       @configs = @{ $driver_config{$driver} };
720
721       $$pn_arg_ref{config_cnt} = $#configs + 1;
722       for my $config (@configs) {
723               $$pn_arg_ref{config} = $config;
724               $lines_printed += &print_node($pn_arg_ref);
725       }
726
727       return $lines_printed;
728}
729
730
731sub handle_compatible()
732{
733       my $full_node     = shift;
734       my $node          = shift;
735       my $compatible    = shift;
736       my $node_enabled  = shift;
737
738       my $compat;
739       my $lines_printed = 0;
740       my %pn_arg        = ();
741
742       return if (!$node or !$compatible);
743
744       # Do not process compatible property of root node,
745       # it is used to match board, not to bind a driver.
746       return if ($node eq "/");
747
748       $pn_arg{full_node}    = $full_node;
749       $pn_arg{node}         = $node;
750       $pn_arg{node_enabled} = $node_enabled;
751
752       my @compatibles = split('", "', $compatible);
753
754       $compatibles[0] =~ s/^"//;
755       $compatibles[$#compatibles] =~ s/"$//;
756
757       $pn_arg{compatible_cnt} = $#compatibles + 1;
758
759       COMPAT:
760       for $compat (@compatibles) {
761
762               $pn_arg{compat}     = $compat;
763               $pn_arg{driver_cnt} = 0;
764               $pn_arg{white_list} = 0;
765
766               if (exists($compat_white_list{$compat})) {
767                       $pn_arg{white_list} = 1;
768                       $pn_arg{driver}     = "no_driver";
769                       $pn_arg{config_cnt} = 1;
770                       $pn_arg{config}     = "no_config";
771                       $lines_printed += &print_node(\%pn_arg);
772                       next COMPAT;
773               }
774
775               # ----- if compat previously seen, use cached info
776
777               if (exists($compat_driver{$compat})) {
778                       for my $driver (@{ $compat_driver{$compat} }) {
779                               $pn_arg{driver}     = $driver;
780                               $pn_arg{driver_cnt} = $driver_count{$compat};
781                               $pn_arg{config_cnt} = $#{ $driver_config{$driver}} + 1;
782
783                               for my $config (@{ $driver_config{$driver} }) {
784                                       $pn_arg{config} = $config;
785                                       $lines_printed += &print_node(\%pn_arg);
786                               }
787
788                               if (!@{ $driver_config{$driver} }) {
789                                       # no config cached yet
790                                       # $driver in %driver_hard_code_list
791                                       # but not %driver_config_hard_code_list
792                                       $lines_printed += &find_kconfig(\%pn_arg, $driver);
793                               }
794                       }
795                       next COMPAT;
796               }
797
798
799               # ----- Find drivers (source files that contain compatible)
800
801               # this will miss arch/sparc/include/asm/parport.h
802               # It is better to move the compatible out of the .h
803               # than to add *.h. to the files list, because *.h generates
804               # a lot of false negatives.
805               my $files = '"*.c"';
806               my $drivers = `git grep -l '"$compat"' -- $files`;
807               chomp($drivers);
808               if ($drivers eq "") {
809                       $pn_arg{driver} = "no_driver";
810                       $pn_arg{config_cnt} = 1;
811                       $pn_arg{config} = "no_config";
812                       push @{ $compat_driver{$compat} }, "no_driver";
813                       $lines_printed += &print_node(\%pn_arg);
814                       next COMPAT;
815               }
816
817               my @drivers = split("\n", $drivers);
818               $driver_count{$compat} = $#drivers + 1;
819               $pn_arg{driver_cnt}    = $#drivers + 1;
820
821               DRIVER:
822               for my $driver (@drivers) {
823                       push @{ $compat_driver{$compat} }, $driver;
824                       $pn_arg{driver} = $driver;
825
826                       # ----- if driver previously seen, use cached info
827
828                       $pn_arg{config_cnt} = $#{ $driver_config{$driver} } + 1;
829                       for my $config (@{ $driver_config{$driver} }) {
830                               $pn_arg{config} = $config;
831                               $lines_printed += &print_node(\%pn_arg);
832                       }
833                       if (@{ $driver_config{$driver} }) {
834                               next DRIVER;
835                       }
836
837                       if ($black_list_driver) {
838                               for $black (@black_list_driver) {
839                                       next DRIVER if ($driver =~ /^$black$/);
840                               }
841                       }
842
843
844                       # ----- Find Kconfig symbols that enable driver
845
846                       $lines_printed += &find_kconfig(\%pn_arg, $driver);
847
848               }
849       }
850
851       # White space (line) between nodes for readability.
852       # Each node may report several compatibles.
853       # For each compatible, multiple drivers may be reported.
854       # For each driver, multiple CONFIG_ options may be reported.
855       if ($lines_printed) {
856               print "\n";
857       }
858}
859
860sub read_dts()
861{
862       my $file         = shift;
863
864       my $compatible   = "";
865       my $line;
866       my $node         = "";
867       my $node_enabled = "";
868
869       if (! -r $file) {
870               print STDERR "file '$file' is not readable or does not exist\n";
871               exit 3;
872       }
873
874       if (!open(DT_FILE, "-|", "$dtx_diff $file")) {
875               print STDERR "\n";
876               print STDERR "shell command failed:\n";
877               print STDERR "   $dtx_diff $file\n";
878               print STDERR "\n";
879               exit 3;
880       }
881
882       FILE:
883       while ($line = <DT_FILE>) {
884               chomp($line);
885
886               if ($line =~ /{/) {
887
888                       &handle_compatible($full_node, $node, $compatible,
889                                          $node_enabled);
890
891                       while ($end_node_count-- > 0) {
892                               pop @full_node;
893                       };
894                       $end_node_count = 0;
895                       $full_node = @full_node[-1];
896
897                       $node = $line;
898                       $node =~ s/^\s*(.*)\s+\{.*/$1/;
899                       $node =~ s/.*: //;
900                       if ($node eq '/' ) {
901                               $full_node = '/';
902                       } elsif ($full_node ne '/') {
903                               $full_node = $full_node . '/' . $node;
904                       } else {
905                               $full_node = '/' . $node;
906                       }
907                       push @full_node, $full_node;
908
909                       $compatible = "";
910                       $node_enabled = "";
911                       next FILE;
912               }
913
914               if ($line =~ /}/) {
915                       $end_node_count++;
916               }
917
918               if ($line =~ /(\s+|^)status =/) {
919                       $node_enabled = $line;
920                       $node_enabled =~ s/^\t*//;
921                       $node_enabled =~ s/^status = "//;
922                       $node_enabled =~ s/";$//;
923                       next FILE;
924               }
925
926               if ($line =~ /(\s+|^)compatible =/) {
927                       # Extract all compatible entries for this device
928                       # White space matching here and in handle_compatible() is
929                       # precise, because input format is the output of dtc,
930                       # which is invoked by dtx_diff.
931                       $compatible = $line;
932                       $compatible =~ s/^\t*//;
933                       $compatible =~ s/^compatible = //;
934                       $compatible =~ s/;$//;
935               }
936       }
937
938       &handle_compatible($full_node, $node, $compatible, $node_enabled);
939
940       close(DT_FILE);
941}
942
943
944sub read_config_file()
945{
946       if (! -r $config_file) {
947               print STDERR "file '$config_file' is not readable or does not exist\n";
948               exit 2;
949       }
950
951       if (!open(CONFIG_FILE, "<", "$config_file")) {
952               print STDERR "open $config_file failed\n";
953               exit 2;
954       }
955
956       my @line;
957
958       LINE:
959       while ($line = <CONFIG_FILE>) {
960               chomp($line);
961               next LINE if ($line =~ /^\s*#/);
962               next LINE if ($line =~ /^\s*$/);
963               @line = split /=/, $line;
964               $existing_config{@line[0]} = @line[1];
965       }
966
967       close(CONFIG_FILE);
968}
969
970
971sub cmd_line_err()
972{
973       my $msg = shift;
974
975       print STDERR "\n";
976       print STDERR "   ERROR processing command line options\n";
977       print STDERR "         $msg\n" if ($msg ne "");
978       print STDERR "\n";
979       print STDERR "   For help, type '$script_name --help'\n";
980       print STDERR "\n";
981}
982
983
984# -----------------------------------------------------------------------------
985# program entry point
986
987Getopt::Long::Configure("no_ignore_case", "bundling");
988
989if (!GetOptions(
990       "c=s"               => \$config_file,
991       "config=s"          => \$config_file,
992       "config-format"     => \$config_format,
993       "exclude-flag=s"    => \@exclude_flag,
994       "h"                 => \$help,
995       "help"              => \$help,
996       "black-list-driver" => \$black_list_driver,
997       "white-list-config" => \$white_list_config,
998       "white-list-driver" => \$white_list_driver,
999       "include-flag=s"    => \@include_flag,
1000       "include-suspect"   => \$include_suspect,
1001       "short-name"        => \$short_name,
1002       "show-lists"        => \$show_lists,
1003       "version"           => \$version,
1004       )) {
1005
1006       &cmd_line_err();
1007
1008       exit 1;
1009}
1010
1011
1012my $exit_after_messages = 0;
1013
1014if ($version) {
1015       print STDERR "\n$script_name  $VUFX\n\n";
1016       $exit_after_messages = 1;
1017}
1018
1019
1020if ($help) {
1021       &usage;
1022       $exit_after_messages = 1;
1023}
1024
1025
1026if ($show_lists) {
1027
1028       print "\n";
1029       print "These compatibles are hard coded to have no driver.\n";
1030       print "\n";
1031       for my $compat (sort keys %compat_white_list) {
1032               print "   $compat\n";
1033       }
1034
1035
1036       print "\n\n";
1037       print "The driver for these compatibles is hard coded (white list).\n";
1038       print "\n";
1039       my $max_compat_len = 0;
1040       for my $compat (sort keys %driver_hard_code_list) {
1041               if (length $compat > $max_compat_len) {
1042                       $max_compat_len = length $compat;
1043               }
1044       }
1045       for my $compat (sort keys %driver_hard_code_list) {
1046               if (($driver ne "hardcoded_no_driver") && ($driver ne "no_driver")) {
1047                       my $first = 1;
1048                       for my $driver (@{ $driver_hard_code_list{$compat} }) {
1049                               if ($first) {
1050                                       print "   $compat";
1051                                       print " " x ($max_compat_len - length $compat);
1052                                       $first = 0;
1053                               } else {
1054                                       print "   ", " " x $max_compat_len;
1055                               }
1056                               print "  $driver\n";
1057                       }
1058               }
1059       }
1060
1061
1062       print "\n\n";
1063       print "The configuration option for these drivers is hard coded (white list).\n";
1064       print "\n";
1065       my $max_driver_len = 0;
1066       for my $driver (sort keys %driver_config_hard_code_list) {
1067               if (length $driver > $max_driver_len) {
1068                       $max_driver_len = length $driver;
1069               }
1070       }
1071       for my $driver (sort keys %driver_config_hard_code_list) {
1072               if (($driver ne "hardcoded_no_driver") && ($driver ne "no_driver")) {
1073                       my $first = 1;
1074                       for my $config (@{ $driver_config_hard_code_list{$driver} }) {
1075                               if ($first) {
1076                                       print "   $driver";
1077                                       print " " x ($max_driver_len - length $driver);
1078                                       $first = 0;
1079                               } else {
1080                                       print "   ", " " x $max_driver_len;
1081                               }
1082                               print "  $config\n";
1083                       }
1084               }
1085       }
1086
1087
1088       print "\n\n";
1089       print "These drivers are black listed.\n";
1090       print "\n";
1091       for my $driver (@black_list_driver) {
1092               print "   $driver\n";
1093       }
1094
1095       print "\n";
1096
1097       $exit_after_messages = 1;
1098}
1099
1100
1101if ($exit_after_messages) {
1102       exit 0;
1103}
1104
1105
1106$exclude_flag_pattern = "[";
1107for my $exclude_flag (@exclude_flag) {
1108       $exclude_flag_pattern = $exclude_flag_pattern . $exclude_flag;
1109}
1110$exclude_flag_pattern = $exclude_flag_pattern . "]";
1111# clean up if empty
1112$exclude_flag_pattern =~ s/^\[\]$//;
1113
1114
1115$include_flag_pattern = "[";
1116for my $include_flag (@include_flag) {
1117       $include_flag_pattern = $include_flag_pattern . $include_flag;
1118}
1119$include_flag_pattern = $include_flag_pattern . "]";
1120# clean up if empty
1121$include_flag_pattern =~ s/^\[\]$//;
1122
1123
1124if ($exclude_flag_pattern) {
1125       my $found = 0;
1126       for $pr_flag_value (@pr_flag_value) {
1127               if ($exclude_flag_pattern =~ m/$pr_flag_value/) {
1128                       $found = 1;
1129               }
1130       }
1131       if (!$found) {
1132               &cmd_line_err("invalid value for FLAG in --exclude-flag\n");
1133               exit 1
1134       }
1135}
1136
1137if ($include_flag_pattern) {
1138       my $found = 0;
1139       for $pr_flag_value (@pr_flag_value) {
1140               if ($include_flag_pattern =~ m/$pr_flag_value/) {
1141                       $found = 1;
1142               }
1143       }
1144       if (!$found) {
1145               &cmd_line_err("invalid value for FLAG in --include-flag\n");
1146               exit 1
1147       }
1148}
1149
1150if ($include_suspect) {
1151       $include_flag_pattern =~ s/\[//;
1152       $include_flag_pattern =~ s/\]//;
1153       $include_flag_pattern = "[" . $include_flag_pattern . "A-Z]";
1154}
1155
1156if ($exclude_flag_pattern =~ m/$include_flag_pattern/) {
1157       &cmd_line_err("the same flag appears in both --exclude-flag and --include-flag or --include-suspect\n");
1158       exit 1
1159}
1160
1161
1162# ($#ARGV < 0) is valid for --help, --version
1163if ($#ARGV < 0) {
1164       &cmd_line_err("device-tree... is required");
1165       exit 1
1166}
1167
1168
1169if ($config_file) {
1170       &read_config_file();
1171}
1172
1173
1174# avoid pushing duplicates for this value
1175$driver = "hardcoded_no_driver";
1176for $config ( @{ $driver_config_hard_code_list{$driver} } ) {
1177       push @{ $driver_config{$driver} }, $config;
1178}
1179
1180if ($white_list_driver) {
1181       for my $compat (keys %driver_hard_code_list) {
1182               for my $driver (@{ $driver_hard_code_list{$compat} }) {
1183                       push @{ $compat_driver{$compat} }, $driver;
1184                       if ($driver ne "hardcoded_no_driver") {
1185                               $driver_count{$compat} = scalar @{ $compat_driver{$compat} };
1186                       }
1187               }
1188       }
1189}
1190
1191if ($white_list_config) {
1192       for my $driver (keys %driver_config_hard_code_list) {
1193               if ($driver ne "hardcoded_no_driver") {
1194                       for $config ( @{ $driver_config_hard_code_list{$driver} } ) {
1195                               push @{ $driver_config{$driver} }, $config;
1196                       }
1197               }
1198       }
1199}
1200
1201if (-x "scripts/dtc/dtx_diff") {
1202       $dtx_diff = "scripts/dtc/dtx_diff";
1203} else {
1204
1205       print STDERR "\n";
1206       print STDERR "$script_name must be run from the root directory of a Linux kernel tree\n";
1207       print STDERR "\n";
1208       exit 3;
1209}
1210
1211for $file (@ARGV) {
1212       &read_dts($file);
1213}
1214