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