4 files changed, 309 insertions, 217 deletions
diff --git a/scripts/checkpatch.pl b/scripts/checkpatch.pl
index 8fda3b3f7be8..e3bfcbe8a520 100755
--- a/scripts/checkpatch.pl
+++ b/scripts/checkpatch.pl
@@ -227,7 +227,7 @@ our $Inline	= qr{inline|__always_inline|noinline};
 our $Member     = qr{->$Ident|\.$Ident|\[[^]]*\]};
 our $Lval       = qr{$Ident(?:$Member)*};
-our $Constant   = qr{(?:[0-9]+|0x[0-9a-fA-F]+)[UL]*};
+our $Constant   = qr{(?i:(?:[0-9]+|0x[0-9a-f]+)[ul]*)};
 our $Assignment = qr{(?:\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=)};
 our $Compare    = qr{<=|>=|==|!=|<|>};
 our $Operators  = qr{
@@ -315,7 +315,7 @@ sub build_types {
        $NonptrType     = qr{
                        (?:$Modifier\s+|const\s+)*
                        (?:
-                                (?:typeof|__typeof__)\s*\(\s*\**\s*$Ident\s*\)|
+                                (?:typeof|__typeof__)\s*\([^\)]*\)|
                                (?:$typeTypedefs\b)|
                                (?:${all}\b)
                        )
@@ -334,6 +334,7 @@ our $match_balanced_parentheses = qr/(\((?:[^\(\)]+|(-1))*\))/;
 our $Typecast   = qr{\s*(\(\s*$NonptrType\s*\)){0,1}\s*};
 our $LvalOrFunc = qr{($Lval)\s*($match_balanced_parentheses{0,1})\s*};
+our $FuncArg = qr{$Typecast{0,1}($LvalOrFunc|$Constant)};
 sub deparenthesize {
        my ($string) = @_;
@@ -676,6 +677,10 @@ sub ctx_statement_block {
                        if ($off >= $len) {
                                last;
                        }
+                        if ($level == 0 && substr($blk, $off) =~ /^.\s*#\s*define/) {
+                                $level++;
+                                $type = '#';
+                        }
                }
                $p = $c;
                $c = substr($blk, $off, 1);
@@ -738,6 +743,13 @@ sub ctx_statement_block {
                                last;
                        }
                }
+                # Preprocessor commands end at the newline unless escaped.
+                if ($type eq '#' && $c eq "\n" && $p ne "\\") {
+                        $level--;
+                        $type = '';
+                        $off++;
+                        last;
+                }
                $off++;
        }
        # We are truly at the end, so shuffle to the next line.
@@ -1020,7 +1032,7 @@ sub annotate_values {
                } elsif ($cur =~ /^(\(\s*$Type\s*)\)/ && $av_pending eq '_') {
                        print "CAST($1)\n" if ($dbg_values > 1);
                        push(@av_paren_type, $type);
-                        $type = 'C';
+                        $type = 'c';
                } elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\(|\s*$)/) {
                        print "DECLARE($1)\n" if ($dbg_values > 1);
@@ -1212,7 +1224,9 @@ sub possible {
                        case|
                        else|
                        asm|__asm__|
-                        do
+                        do|
+                        \#|
+                        \#\#|
                )(?:\s|$)|
                ^(?:typedef|struct|enum)\b
            )}x;
@@ -1359,6 +1373,7 @@ sub process {
        my %suppress_ifbraces;
        my %suppress_whiletrailers;
        my %suppress_export;
+        my $suppress_statement = 0;
        # Pre-scan the patch sanitizing the lines.
        # Pre-scan the patch looking for any __setup documentation.
@@ -1468,6 +1483,7 @@ sub process {
                        %suppress_ifbraces = ();
                        %suppress_whiletrailers = ();
                        %suppress_export = ();
+                        $suppress_statement = 0;
                        next;
 # track the line number as we move through the hunk, note that
@@ -1504,9 +1520,11 @@ sub process {
                if ($line =~ /^diff --git.*?(\S+)$/) {
                        $realfile = $1;
                        $realfile =~ s@^([^/]*)/@@;
+                        $in_commit_log = 0;
                } elsif ($line =~ /^\+\+\+\s+(\S+)/) {
                        $realfile = $1;
                        $realfile =~ s@^([^/]*)/@@;
+                        $in_commit_log = 0;
                        $p1_prefix = $1;
                        if (!$file && $tree && $p1_prefix ne '' &&
@@ -1546,7 +1564,8 @@ sub process {
                }
 # Check signature styles
-                if ($line =~ /^(\s*)($signature_tags)(\s*)(.*)/) {
+                if (!$in_header_lines &&
+                    $line =~ /^(\s*)($signature_tags)(\s*)(.*)/) {
                        my $space_before = $1;
                        my $sign_off = $2;
                        my $space_after = $3;
@@ -1623,7 +1642,7 @@ sub process {
 # Check if it's the start of a commit log
 # (not a header line and we haven't seen the patch filename)
                if ($in_header_lines && $realfile =~ /^$/ &&
-                    $rawline !~ /^(commit\b|from\b|\w+:).+$/i) {
+                    $rawline !~ /^(commit\b|from\b|[\w-]+:).+$/i) {
                        $in_header_lines = 0;
                        $in_commit_log = 1;
                }
@@ -1655,19 +1674,26 @@ sub process {
 # Only applies when adding the entry originally, after that we do not have
 # sufficient context to determine whether it is indeed long enough.
                if ($realfile =~ /Kconfig/ &&
-                    $line =~ /\+\s*(?:---)?help(?:---)?$/) {
+                    $line =~ /.\s*config\s+/) {
                        my $length = 0;
                        my $cnt = $realcnt;
                        my $ln = $linenr + 1;
                        my $f;
+                        my $is_start = 0;
                        my $is_end = 0;
-                        while ($cnt > 0 && defined $lines[$ln - 1]) {
+                        for (; $cnt > 0 && defined $lines[$ln - 1]; $ln++) {
                                $f = $lines[$ln - 1];
                                $cnt-- if ($lines[$ln - 1] !~ /^-/);
                                $is_end = $lines[$ln - 1] =~ /^\+/;
-                                $ln++;
                                next if ($f =~ /^-/);
+                                if ($lines[$ln - 1] =~ /.\s*(?:bool|tristate)\s*\"/) {
+                                        $is_start = 1;
+                                } elsif ($lines[$ln - 1] =~ /.\s*(?:---)?help(?:---)?$/) {
+                                        $length = -1;
+                                }
                                $f =~ s/^.//;
                                $f =~ s/#.*//;
                                $f =~ s/^\s+//;
@@ -1679,8 +1705,8 @@ sub process {
                                $length++;
                        }
                        WARN("CONFIG_DESCRIPTION",
-                             "please write a paragraph that describes the config symbol fully\n" . $herecurr) if ($is_end && $length < 4);
+                             "please write a paragraph that describes the config symbol fully\n" . $herecurr) if ($is_start && $is_end && $length < 4);
-                        #print "is_end<$is_end> length<$length>\n";
+                        #print "is_start<$is_start> is_end<$is_end> length<$length>\n";
                }
                if (($realfile =~ /Makefile.*/ || $realfile =~ /Kbuild.*/) &&
@@ -1792,12 +1818,24 @@ sub process {
 # Check for potential 'bare' types
                my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
                    $realline_next);
-                if ($realcnt && $line =~ /.\s*\S/) {
+#print "LINE<$line>\n";
+                if ($linenr >= $suppress_statement &&
+                    $realcnt && $line =~ /.\s*\S/) {
                        ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
                                ctx_statement_block($linenr, $realcnt, 0);
                        $stat =~ s/\n./\n /g;
                        $cond =~ s/\n./\n /g;
+#print "linenr<$linenr> <$stat>\n";
+                        # If this statement has no statement boundaries within
+                        # it there is no point in retrying a statement scan
+                        # until we hit end of it.
+                        my $frag = $stat; $frag =~ s/;+\s*$//;
+                        if ($frag !~ /(?:{|;)/) {
+#print "skip<$line_nr_next>\n";
+                                $suppress_statement = $line_nr_next;
+                        }
                        # Find the real next line.
                        $realline_next = $line_nr_next;
                        if (defined $realline_next &&
@@ -1923,6 +1961,9 @@ sub process {
 # Check relative indent for conditionals and blocks.
                if ($line =~ /\b(?:(?:if|while|for)\s*\(|do\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
+                        ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
+                                ctx_statement_block($linenr, $realcnt, 0)
+                                        if (!defined $stat);
                        my ($s, $c) = ($stat, $cond);
                        substr($s, 0, length($c), '');
@@ -2090,7 +2131,7 @@ sub process {
                        #   XXX(foo);
                        #   EXPORT_SYMBOL(something_foo);
                        my $name = $1;
-                        if ($stat =~ /^.([A-Z_]+)\s*\(\s*($Ident)/ &&
+                        if ($stat =~ /^(?:.\s*}\s*\n)?.([A-Z_]+)\s*\(\s*($Ident)/ &&
                            $name =~ /^${Ident}_$2/) {
 #print "FOO C name<$name>\n";
                                $suppress_export{$realline_next} = 1;
@@ -2168,8 +2209,9 @@ sub process {
 # * goes on variable not on type
                # (char*[ const])
-                if ($line =~ m{\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\)}) {
+                while ($line =~ m{(\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\))}g) {
-                        my ($from, $to) = ($1, $1);
+                        #print "AA<$1>\n";
+                        my ($from, $to) = ($2, $2);
                        # Should start with a space.
                        $to =~ s/^(\S)/ $1/;
@@ -2184,8 +2226,10 @@ sub process {
                                ERROR("POINTER_LOCATION",
                                      "\"(foo$from)\" should be \"(foo$to)\"\n" .  $herecurr);
                        }
-                } elsif ($line =~ m{\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident)}) {
+                }
-                        my ($from, $to, $ident) = ($1, $1, $2);
+                while ($line =~ m{(\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident))}g) {
+                        #print "BB<$1>\n";
+                        my ($from, $to, $ident) = ($2, $2, $3);
                        # Should start with a space.
                        $to =~ s/^(\S)/ $1/;
@@ -2568,7 +2612,7 @@ sub process {
                        # Flatten any parentheses
                        $value =~ s/\(/ \(/g;
                        $value =~ s/\)/\) /g;
-                        while ($value =~ s/\[[^\{\}]*\]/1/ ||
+                        while ($value =~ s/\[[^\[\]]*\]/1/ ||
                               $value !~ /(?:$Ident|-?$Constant)\s*
                                             $Compare\s*
                                             (?:$Ident|-?$Constant)/x &&
@@ -2593,28 +2637,6 @@ sub process {
                        }
                }
-# typecasts on min/max could be min_t/max_t
-                if ($line =~ /^\+(?:.*?)\b(min|max)\s*\($Typecast{0,1}($LvalOrFunc)\s*,\s*$Typecast{0,1}($LvalOrFunc)\s*\)/) {
-                        if (defined $2 || defined $8) {
-                                my $call = $1;
-                                my $cast1 = deparenthesize($2);
-                                my $arg1 = $3;
-                                my $cast2 = deparenthesize($8);
-                                my $arg2 = $9;
-                                my $cast;
-                                if ($cast1 ne "" && $cast2 ne "") {
-                                        $cast = "$cast1 or $cast2";
-                                } elsif ($cast1 ne "") {
-                                        $cast = $cast1;
-                                } else {
-                                        $cast = $cast2;
-                                }
-                                WARN("MINMAX",
-                                     "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . $herecurr);
-                        }
-                }
 # Need a space before open parenthesis after if, while etc
                if ($line=~/\b(if|while|for|switch)\(/) {
                        ERROR("SPACING", "space required before the open parenthesis '('\n" . $herecurr);
@@ -2623,6 +2645,9 @@ sub process {
 # Check for illegal assignment in if conditional -- and check for trailing
 # statements after the conditional.
                if ($line =~ /do\s*(?!{)/) {
+                        ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
+                                ctx_statement_block($linenr, $realcnt, 0)
+                                        if (!defined $stat);
                        my ($stat_next) = ctx_statement_block($line_nr_next,
                                                $remain_next, $off_next);
                        $stat_next =~ s/\n./\n /g;
@@ -2778,47 +2803,13 @@ sub process {
                        my $cnt = $realcnt;
                        my ($off, $dstat, $dcond, $rest);
                        my $ctx = '';
-                        my $args = defined($1);
-                        # Find the end of the macro and limit our statement
-                        # search to that.
-                        while ($cnt > 0 && defined $lines[$ln - 1] &&
-                                $lines[$ln - 1] =~ /^(?:-|..*\\$)/)
-                        {
-                                $ctx .= $rawlines[$ln - 1] . "\n";
-                                $cnt-- if ($lines[$ln - 1] !~ /^-/);
-                                $ln++;
-                        }
-                        $ctx .= $rawlines[$ln - 1];
                        ($dstat, $dcond, $ln, $cnt, $off) =
-                                ctx_statement_block($linenr, $ln - $linenr + 1, 0);
+                                ctx_statement_block($linenr, $realcnt, 0);
+                        $ctx = $dstat;
                        #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
                        #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
-                        # Extract the remainder of the define (if any) and
+                        $dstat =~ s/^.\s*\#\s*define\s+$Ident(?:\([^\)]*\))?\s*//;
-                        # rip off surrounding spaces, and trailing \'s.
-                        $rest = '';
-                        while ($off != 0 || ($cnt > 0 && $rest =~ /\\\s*$/)) {
-                                #print "ADDING cnt<$cnt> $off <" . substr($lines[$ln - 1], $off) . "> rest<$rest>\n";
-                                if ($off != 0 || $lines[$ln - 1] !~ /^-/) {
-                                        $rest .= substr($lines[$ln - 1], $off) . "\n";
-                                        $cnt--;
-                                }
-                                $ln++;
-                                $off = 0;
-                        }
-                        $rest =~ s/\\\n.//g;
-                        $rest =~ s/^\s*//s;
-                        $rest =~ s/\s*$//s;
-                        # Clean up the original statement.
-                        if ($args) {
-                                substr($dstat, 0, length($dcond), '');
-                        } else {
-                                $dstat =~ s/^.\s*\#\s*define\s+$Ident\s*//;
-                        }
                        $dstat =~ s/$;//g;
                        $dstat =~ s/\\\n.//g;
                        $dstat =~ s/^\s*//s;
@@ -2827,7 +2818,7 @@ sub process {
                        # Flatten any parentheses and braces
                        while ($dstat =~ s/\([^\(\)]*\)/1/ ||
                               $dstat =~ s/\{[^\{\}]*\}/1/ ||
-                               $dstat =~ s/\[[^\{\}]*\]/1/)
+                               $dstat =~ s/\[[^\[\]]*\]/1/)
                        {
                        }
@@ -2844,23 +2835,32 @@ sub process {
                                ^\"|\"$
                        }x;
                        #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
-                        if ($rest ne '' && $rest ne ',') {
+                        if ($dstat ne '' &&
-                                if ($rest !~ /while\s*\(/ &&
+                            $dstat !~ /^(?:$Ident|-?$Constant),$/ &&                    # 10, // foo(),
-                                    $dstat !~ /$exceptions/)
+                            $dstat !~ /^(?:$Ident|-?$Constant);$/ &&                    # foo();
-                                {
+                            $dstat !~ /^(?:$Ident|-?$Constant)$/ &&                     # 10 // foo()
-                                        ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
+                            $dstat !~ /$exceptions/ &&
-                                              "Macros with multiple statements should be enclosed in a do - while loop\n" . "$here\n$ctx\n");
+                            $dstat !~ /^\.$Ident\s*=/ &&                                # .foo =
+                            $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ &&       # do {...} while (...); // do {...} while (...)
+                            $dstat !~ /^for\s*$Constant$/ &&                            # for (...)
+                            $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ &&   # for (...) bar()
+                            $dstat !~ /^do\s*{/ &&                                      # do {...
+                            $dstat !~ /^\({/)                                           # ({...
+                        {
+                                $ctx =~ s/\n*$//;
+                                my $herectx = $here . "\n";
+                                my $cnt = statement_rawlines($ctx);
+                                for (my $n = 0; $n < $cnt; $n++) {
+                                        $herectx .= raw_line($linenr, $n) . "\n";
                                }
-                        } elsif ($ctx !~ /;/) {
+                                if ($dstat =~ /;/) {
-                                if ($dstat ne '' &&
+                                        ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
-                                    $dstat !~ /^(?:$Ident|-?$Constant)$/ &&
+                                              "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");
-                                    $dstat !~ /$exceptions/ &&
+                                } else {
-                                    $dstat !~ /^\.$Ident\s*=/ &&
-                                    $dstat =~ /$Operators/)
-                                {
                                        ERROR("COMPLEX_MACRO",
-                                              "Macros with complex values should be enclosed in parenthesis\n" . "$here\n$ctx\n");
+                                              "Macros with complex values should be enclosed in parenthesis\n" . "$herectx");
                                }
                        }
                }
@@ -3111,6 +3111,12 @@ sub process {
                             "__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr);
                }
+# Check for __attribute__ format(printf, prefer __printf
+                if ($line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf/) {
+                        WARN("PREFER_PRINTF",
+                             "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr);
+                }
 # check for sizeof(&)
                if ($line =~ /\bsizeof\s*\(\s*\&/) {
                        WARN("SIZEOF_ADDRESS",
@@ -3123,6 +3129,46 @@ sub process {
                             "Avoid line continuations in quoted strings\n" . $herecurr);
                }
+# Check for misused memsets
+                if (defined $stat &&
+                    $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/s) {
+                        my $ms_addr = $2;
+                        my $ms_val = $8;
+                        my $ms_size = $14;
+                        if ($ms_size =~ /^(0x|)0$/i) {
+                                ERROR("MEMSET",
+                                      "memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n");
+                        } elsif ($ms_size =~ /^(0x|)1$/i) {
+                                WARN("MEMSET",
+                                     "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");
+                        }
+                }
+# typecasts on min/max could be min_t/max_t
+                if (defined $stat &&
+                    $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
+                        if (defined $2 || defined $8) {
+                                my $call = $1;
+                                my $cast1 = deparenthesize($2);
+                                my $arg1 = $3;
+                                my $cast2 = deparenthesize($8);
+                                my $arg2 = $9;
+                                my $cast;
+                                if ($cast1 ne "" && $cast2 ne "") {
+                                        $cast = "$cast1 or $cast2";
+                                } elsif ($cast1 ne "") {
+                                        $cast = $cast1;
+                                } else {
+                                        $cast = $cast2;
+                                }
+                                WARN("MINMAX",
+                                     "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");
+                        }
+                }
 # check for new externs in .c files.
                if ($realfile =~ /\.c$/ && defined $stat &&
                    $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
@@ -3294,12 +3340,6 @@ sub process {
                        WARN("EXPORTED_WORLD_WRITABLE",
                             "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
                }
-                # Check for memset with swapped arguments
-                if ($line =~ /memset.*\,(\ |)(0x|)0(\ |0|)\);/) {
-                        ERROR("MEMSET",
-                              "memset size is 3rd argument, not the second.\n" . $herecurr);
-                }
        }
        # If we have no input at all, then there is nothing to report on
diff --git a/scripts/get_maintainer.pl b/scripts/get_maintainer.pl
index 4594f3341051..f32a04c4c5bc 100755
--- a/scripts/get_maintainer.pl
+++ b/scripts/get_maintainer.pl
@@ -95,7 +95,7 @@ my %VCS_cmds_git = (
    "execute_cmd" => \&git_execute_cmd,
    "available" => '(which("git") ne "") && (-d ".git")',
    "find_signers_cmd" =>
-        "git log --no-color --since=\$email_git_since " .
+        "git log --no-color --follow --since=\$email_git_since " .
            '--format="GitCommit: %H%n' .
                      'GitAuthor: %an <%ae>%n' .
                      'GitDate: %aD%n' .
diff --git a/scripts/mod/file2alias.c b/scripts/mod/file2alias.c
index f936d1fa969d..c0e14b3f2306 100644
--- a/scripts/mod/file2alias.c
+++ b/scripts/mod/file2alias.c
@@ -28,6 +28,7 @@ typedef Elf64_Addr	kernel_ulong_t;
 #endif
 #include <ctype.h>
+#include <stdbool.h>
 typedef uint32_t        __u32;
 typedef uint16_t        __u16;
@@ -38,6 +39,35 @@ typedef unsigned char	__u8;
 * we handle those differences explicitly below */
 #include "../../include/linux/mod_devicetable.h"
+/* This array collects all instances that use the generic do_table */
+struct devtable {
+        const char *device_id; /* name of table, __mod_<name>_device_table. */
+        unsigned long id_size;
+        void *function;
+};
+/* We construct a table of pointers in an ELF section (pointers generally
+ * go unpadded by gcc).  ld creates boundary syms for us. */
+extern struct devtable *__start___devtable[], *__stop___devtable[];
+#define ___cat(a,b) a ## b
+#define __cat(a,b) ___cat(a,b)
+#if __GNUC__ == 3 && __GNUC_MINOR__ < 3
+# define __used                 __attribute__((__unused__))
+#else
+# define __used                 __attribute__((__used__))
+#endif
+/* Add a table entry.  We test function type matches while we're here. */
+#define ADD_TO_DEVTABLE(device_id, type, function) \
+        static struct devtable __cat(devtable,__LINE__) = {     \
+                device_id + 0*sizeof((function)((const char *)NULL,     \
+                                                (type *)NULL,           \
+                                                (char *)NULL)),         \
+                sizeof(type), (function) };                             \
+        static struct devtable *__attribute__((section("__devtable"))) \
+                __used __cat(devtable_ptr,__LINE__) = &__cat(devtable,__LINE__)
 #define ADD(str, sep, cond, field)                              \
 do {                                                            \
        strcat(str, sep);                                       \
@@ -289,6 +319,7 @@ static int do_hid_entry(const char *filename,
        return 1;
 }
+ADD_TO_DEVTABLE("hid", struct hid_device_id, do_hid_entry);
 /* Looks like: ieee1394:venNmoNspNverN */
 static int do_ieee1394_entry(const char *filename,
@@ -313,6 +344,7 @@ static int do_ieee1394_entry(const char *filename,
        add_wildcard(alias);
        return 1;
 }
+ADD_TO_DEVTABLE("ieee1394", struct ieee1394_device_id, do_ieee1394_entry);
 /* Looks like: pci:vNdNsvNsdNbcNscNiN. */
 static int do_pci_entry(const char *filename,
@@ -356,6 +388,7 @@ static int do_pci_entry(const char *filename,
        add_wildcard(alias);
        return 1;
 }
+ADD_TO_DEVTABLE("pci", struct pci_device_id, do_pci_entry);
 /* looks like: "ccw:tNmNdtNdmN" */
 static int do_ccw_entry(const char *filename,
@@ -379,6 +412,7 @@ static int do_ccw_entry(const char *filename,
        add_wildcard(alias);
        return 1;
 }
+ADD_TO_DEVTABLE("ccw", struct ccw_device_id, do_ccw_entry);
 /* looks like: "ap:tN" */
 static int do_ap_entry(const char *filename,
@@ -387,6 +421,7 @@ static int do_ap_entry(const char *filename,
        sprintf(alias, "ap:t%02X*", id->dev_type);
        return 1;
 }
+ADD_TO_DEVTABLE("ap", struct ap_device_id, do_ap_entry);
 /* looks like: "css:tN" */
 static int do_css_entry(const char *filename,
@@ -395,6 +430,7 @@ static int do_css_entry(const char *filename,
        sprintf(alias, "css:t%01X", id->type);
        return 1;
 }
+ADD_TO_DEVTABLE("css", struct css_device_id, do_css_entry);
 /* Looks like: "serio:tyNprNidNexN" */
 static int do_serio_entry(const char *filename,
@@ -414,6 +450,7 @@ static int do_serio_entry(const char *filename,
        add_wildcard(alias);
        return 1;
 }
+ADD_TO_DEVTABLE("serio", struct serio_device_id, do_serio_entry);
 /* looks like: "acpi:ACPI0003 or acpi:PNP0C0B" or "acpi:LNXVIDEO" */
 static int do_acpi_entry(const char *filename,
@@ -422,6 +459,7 @@ static int do_acpi_entry(const char *filename,
        sprintf(alias, "acpi*:%s:*", id->id);
        return 1;
 }
+ADD_TO_DEVTABLE("acpi", struct acpi_device_id, do_acpi_entry);
 /* looks like: "pnp:dD" */
 static void do_pnp_device_entry(void *symval, unsigned long size,
@@ -544,8 +582,7 @@ static int do_pcmcia_entry(const char *filename,
        add_wildcard(alias);
       return 1;
 }
+ADD_TO_DEVTABLE("pcmcia", struct pcmcia_device_id, do_pcmcia_entry);
 static int do_of_entry (const char *filename, struct of_device_id *of, char *alias)
 {
@@ -568,6 +605,7 @@ static int do_of_entry (const char *filename, struct of_device_id *of, char *ali
    add_wildcard(alias);
    return 1;
 }
+ADD_TO_DEVTABLE("of", struct of_device_id, do_of_entry);
 static int do_vio_entry(const char *filename, struct vio_device_id *vio,
                char *alias)
@@ -585,6 +623,7 @@ static int do_vio_entry(const char *filename, struct vio_device_id *vio,
        add_wildcard(alias);
        return 1;
 }
+ADD_TO_DEVTABLE("vio", struct vio_device_id, do_vio_entry);
 #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
@@ -640,6 +679,7 @@ static int do_input_entry(const char *filename, struct input_device_id *id,
                do_input(alias, id->swbit, 0, INPUT_DEVICE_ID_SW_MAX);
        return 1;
 }
+ADD_TO_DEVTABLE("input", struct input_device_id, do_input_entry);
 static int do_eisa_entry(const char *filename, struct eisa_device_id *eisa,
                char *alias)
@@ -650,6 +690,7 @@ static int do_eisa_entry(const char *filename, struct eisa_device_id *eisa,
                strcat(alias, "*");
        return 1;
 }
+ADD_TO_DEVTABLE("eisa", struct eisa_device_id, do_eisa_entry);
 /* Looks like: parisc:tNhvNrevNsvN */
 static int do_parisc_entry(const char *filename, struct parisc_device_id *id,
@@ -669,6 +710,7 @@ static int do_parisc_entry(const char *filename, struct parisc_device_id *id,
        add_wildcard(alias);
        return 1;
 }
+ADD_TO_DEVTABLE("parisc", struct parisc_device_id, do_parisc_entry);
 /* Looks like: sdio:cNvNdN. */
 static int do_sdio_entry(const char *filename,
@@ -685,6 +727,7 @@ static int do_sdio_entry(const char *filename,
        add_wildcard(alias);
        return 1;
 }
+ADD_TO_DEVTABLE("sdio", struct sdio_device_id, do_sdio_entry);
 /* Looks like: ssb:vNidNrevN. */
 static int do_ssb_entry(const char *filename,
@@ -701,6 +744,7 @@ static int do_ssb_entry(const char *filename,
        add_wildcard(alias);
        return 1;
 }
+ADD_TO_DEVTABLE("ssb", struct ssb_device_id, do_ssb_entry);
 /* Looks like: bcma:mNidNrevNclN. */
 static int do_bcma_entry(const char *filename,
@@ -719,6 +763,7 @@ static int do_bcma_entry(const char *filename,
        add_wildcard(alias);
        return 1;
 }
+ADD_TO_DEVTABLE("bcma", struct bcma_device_id, do_bcma_entry);
 /* Looks like: virtio:dNvN */
 static int do_virtio_entry(const char *filename, struct virtio_device_id *id,
@@ -734,6 +779,7 @@ static int do_virtio_entry(const char *filename, struct virtio_device_id *id,
        add_wildcard(alias);
        return 1;
 }
+ADD_TO_DEVTABLE("virtio", struct virtio_device_id, do_virtio_entry);
 /*
 * Looks like: vmbus:guid
@@ -755,6 +801,7 @@ static int do_vmbus_entry(const char *filename, struct hv_vmbus_device_id *id,
        return 1;
 }
+ADD_TO_DEVTABLE("vmbus", struct hv_vmbus_device_id, do_vmbus_entry);
 /* Looks like: i2c:S */
 static int do_i2c_entry(const char *filename, struct i2c_device_id *id,
@@ -764,6 +811,7 @@ static int do_i2c_entry(const char *filename, struct i2c_device_id *id,
        return 1;
 }
+ADD_TO_DEVTABLE("i2c", struct i2c_device_id, do_i2c_entry);
 /* Looks like: spi:S */
 static int do_spi_entry(const char *filename, struct spi_device_id *id,
@@ -773,6 +821,17 @@ static int do_spi_entry(const char *filename, struct spi_device_id *id,
        return 1;
 }
+ADD_TO_DEVTABLE("spi", struct spi_device_id, do_spi_entry);
+/* Looks like: mcp:S */
+static int do_mcp_entry(const char *filename, struct mcp_device_id *id,
+                        char *alias)
+{
+        sprintf(alias, MCP_MODULE_PREFIX "%s", id->name);
+        return 1;
+}
+ADD_TO_DEVTABLE("mcp", struct mcp_device_id, do_mcp_entry); 
 static const struct dmifield {
        const char *prefix;
@@ -827,6 +886,7 @@ static int do_dmi_entry(const char *filename, struct dmi_system_id *id,
        strcat(alias, ":");
        return 1;
 }
+ADD_TO_DEVTABLE("dmi", struct dmi_system_id, do_dmi_entry);
 static int do_platform_entry(const char *filename,
                             struct platform_device_id *id, char *alias)
@@ -834,6 +894,7 @@ static int do_platform_entry(const char *filename,
        sprintf(alias, PLATFORM_MODULE_PREFIX "%s", id->name);
        return 1;
 }
+ADD_TO_DEVTABLE("platform", struct platform_device_id, do_platform_entry);
 static int do_mdio_entry(const char *filename,
                         struct mdio_device_id *id, char *alias)
@@ -856,6 +917,7 @@ static int do_mdio_entry(const char *filename,
        return 1;
 }
+ADD_TO_DEVTABLE("mdio", struct mdio_device_id, do_mdio_entry);
 /* Looks like: zorro:iN. */
 static int do_zorro_entry(const char *filename, struct zorro_device_id *id,
@@ -866,6 +928,7 @@ static int do_zorro_entry(const char *filename, struct zorro_device_id *id,
        ADD(alias, "i", id->id != ZORRO_WILDCARD, id->id);
        return 1;
 }
+ADD_TO_DEVTABLE("zorro", struct zorro_device_id, do_zorro_entry);
 /* looks like: "pnp:dD" */
 static int do_isapnp_entry(const char *filename,
@@ -879,16 +942,84 @@ static int do_isapnp_entry(const char *filename,
                (id->function >> 12) & 0x0f, (id->function >> 8) & 0x0f);
        return 1;
 }
+ADD_TO_DEVTABLE("isa", struct isapnp_device_id, do_isapnp_entry);
-/* Ignore any prefix, eg. some architectures prepend _ */
+/*
-static inline int sym_is(const char *symbol, const char *name)
+ * Append a match expression for a single masked hex digit.
+ * outp points to a pointer to the character at which to append.
+ *      *outp is updated on return to point just after the appended text,
+ *      to facilitate further appending.
+ */
+static void append_nibble_mask(char **outp,
+                               unsigned int nibble, unsigned int mask)
 {
-        const char *match;
+        char *p = *outp;
+        unsigned int i;
-        match = strstr(symbol, name);
+        switch (mask) {
-        if (!match)
+        case 0:
-                return 0;
+                *p++ = '?';
-        return match[strlen(name)] == '\0';
+                break;
+        case 0xf:
+                p += sprintf(p, "%X",  nibble);
+                break;
+        default:
+                /*
+                 * Dumbly emit a match pattern for all possible matching
+                 * digits.  This could be improved in some cases using ranges,
+                 * but it has the advantage of being trivially correct, and is
+                 * often optimal.
+                 */
+                *p++ = '[';
+                for (i = 0; i < 0x10; i++)
+                        if ((i & mask) == nibble)
+                                p += sprintf(p, "%X", i);
+                *p++ = ']';
+        }
+        /* Ensure that the string remains NUL-terminated: */
+        *p = '\0';
+        /* Advance the caller's end-of-string pointer: */
+        *outp = p;
+}
+/*
+ * looks like: "amba:dN"
+ *
+ * N is exactly 8 digits, where each is an upper-case hex digit, or
+ *      a ? or [] pattern matching exactly one digit.
+ */
+static int do_amba_entry(const char *filename,
+                         struct amba_id *id, char *alias)
+{
+        unsigned int digit;
+        char *p = alias;
+        if ((id->id & id->mask) != id->id)
+                fatal("%s: Masked-off bit(s) of AMBA device ID are non-zero: "
+                      "id=0x%08X, mask=0x%08X.  Please fix this driver.\n",
+                      filename, id->id, id->mask);
+        p += sprintf(alias, "amba:d");
+        for (digit = 0; digit < 8; digit++)
+                append_nibble_mask(&p,
+                                   (id->id >> (4 * (7 - digit))) & 0xf,
+                                   (id->mask >> (4 * (7 - digit))) & 0xf);
+        return 1;
+}
+ADD_TO_DEVTABLE("amba", struct amba_id, do_amba_entry);
+/* Does namelen bytes of name exactly match the symbol? */
+static bool sym_is(const char *name, unsigned namelen, const char *symbol)
+{
+        if (namelen != strlen(symbol))
+                return false;
+        return memcmp(name, symbol, namelen) == 0;
 }
 static void do_table(void *symval, unsigned long size,
@@ -921,11 +1052,25 @@ void handle_moddevtable(struct module *mod, struct elf_info *info,
 {
        void *symval;
        char *zeros = NULL;
+        const char *name;
+        unsigned int namelen;
        /* We're looking for a section relative symbol */
        if (!sym->st_shndx || get_secindex(info, sym) >= info->num_sections)
                return;
+        /* All our symbols are of form <prefix>__mod_XXX_device_table. */
+        name = strstr(symname, "__mod_");
+        if (!name)
+                return;
+        name += strlen("__mod_");
+        namelen = strlen(name);
+        if (namelen < strlen("_device_table"))
+                return;
+        if (strcmp(name + namelen - strlen("_device_table"), "_device_table"))
+                return;
+        namelen -= strlen("_device_table");
        /* Handle all-NULL symbols allocated into .bss */
        if (info->sechdrs[get_secindex(info, sym)].sh_type & SHT_NOBITS) {
                zeros = calloc(1, sym->st_size);
@@ -936,117 +1081,24 @@ void handle_moddevtable(struct module *mod, struct elf_info *info,
                        + sym->st_value;
        }
-        if (sym_is(symname, "__mod_pci_device_table"))
+        /* First handle the "special" cases */
-                do_table(symval, sym->st_size,
+        if (sym_is(name, namelen, "usb"))
-                         sizeof(struct pci_device_id), "pci",
-                         do_pci_entry, mod);
-        else if (sym_is(symname, "__mod_usb_device_table"))
-                /* special case to handle bcdDevice ranges */
                do_usb_table(symval, sym->st_size, mod);
-        else if (sym_is(symname, "__mod_hid_device_table"))
+        else if (sym_is(name, namelen, "pnp"))
-                do_table(symval, sym->st_size,
-                         sizeof(struct hid_device_id), "hid",
-                         do_hid_entry, mod);
-        else if (sym_is(symname, "__mod_ieee1394_device_table"))
-                do_table(symval, sym->st_size,
-                         sizeof(struct ieee1394_device_id), "ieee1394",
-                         do_ieee1394_entry, mod);
-        else if (sym_is(symname, "__mod_ccw_device_table"))
-                do_table(symval, sym->st_size,
-                         sizeof(struct ccw_device_id), "ccw",
-                         do_ccw_entry, mod);
-        else if (sym_is(symname, "__mod_ap_device_table"))
-                do_table(symval, sym->st_size,
-                         sizeof(struct ap_device_id), "ap",
-                         do_ap_entry, mod);
-        else if (sym_is(symname, "__mod_css_device_table"))
-                do_table(symval, sym->st_size,
-                         sizeof(struct css_device_id), "css",
-                         do_css_entry, mod);
-        else if (sym_is(symname, "__mod_serio_device_table"))
-                do_table(symval, sym->st_size,
-                         sizeof(struct serio_device_id), "serio",
-                         do_serio_entry, mod);
-        else if (sym_is(symname, "__mod_acpi_device_table"))
-                do_table(symval, sym->st_size,
-                         sizeof(struct acpi_device_id), "acpi",
-                         do_acpi_entry, mod);
-        else if (sym_is(symname, "__mod_pnp_device_table"))
                do_pnp_device_entry(symval, sym->st_size, mod);
-        else if (sym_is(symname, "__mod_pnp_card_device_table"))
+        else if (sym_is(name, namelen, "pnp_card"))
                do_pnp_card_entries(symval, sym->st_size, mod);
-        else if (sym_is(symname, "__mod_pcmcia_device_table"))
+        else {
-                do_table(symval, sym->st_size,
+                struct devtable **p;
-                         sizeof(struct pcmcia_device_id), "pcmcia",
-                         do_pcmcia_entry, mod);
+                for (p = __start___devtable; p < __stop___devtable; p++) {
-        else if (sym_is(symname, "__mod_of_device_table"))
+                        if (sym_is(name, namelen, (*p)->device_id)) {
-                do_table(symval, sym->st_size,
+                                do_table(symval, sym->st_size, (*p)->id_size,
-                         sizeof(struct of_device_id), "of",
+                                         (*p)->device_id, (*p)->function, mod);
-                         do_of_entry, mod);
+                                break;
-        else if (sym_is(symname, "__mod_vio_device_table"))
+                        }
-                do_table(symval, sym->st_size,
+                }
-                         sizeof(struct vio_device_id), "vio",
+        }
-                         do_vio_entry, mod);
-        else if (sym_is(symname, "__mod_input_device_table"))
-                do_table(symval, sym->st_size,
-                         sizeof(struct input_device_id), "input",
-                         do_input_entry, mod);
-        else if (sym_is(symname, "__mod_eisa_device_table"))
-                do_table(symval, sym->st_size,
-                         sizeof(struct eisa_device_id), "eisa",
-                         do_eisa_entry, mod);
-        else if (sym_is(symname, "__mod_parisc_device_table"))
-                do_table(symval, sym->st_size,
-                         sizeof(struct parisc_device_id), "parisc",
-                         do_parisc_entry, mod);
-        else if (sym_is(symname, "__mod_sdio_device_table"))
-                do_table(symval, sym->st_size,
-                         sizeof(struct sdio_device_id), "sdio",
-                         do_sdio_entry, mod);
-        else if (sym_is(symname, "__mod_ssb_device_table"))
-                do_table(symval, sym->st_size,
-                         sizeof(struct ssb_device_id), "ssb",
-                         do_ssb_entry, mod);
-        else if (sym_is(symname, "__mod_bcma_device_table"))
-                do_table(symval, sym->st_size,
-                         sizeof(struct bcma_device_id), "bcma",
-                         do_bcma_entry, mod);
-        else if (sym_is(symname, "__mod_virtio_device_table"))
-                do_table(symval, sym->st_size,
-                         sizeof(struct virtio_device_id), "virtio",
-                         do_virtio_entry, mod);
-        else if (sym_is(symname, "__mod_vmbus_device_table"))
-                do_table(symval, sym->st_size,
-                         sizeof(struct hv_vmbus_device_id), "vmbus",
-                         do_vmbus_entry, mod);
-        else if (sym_is(symname, "__mod_i2c_device_table"))
-                do_table(symval, sym->st_size,
-                         sizeof(struct i2c_device_id), "i2c",
-                         do_i2c_entry, mod);
-        else if (sym_is(symname, "__mod_spi_device_table"))
-                do_table(symval, sym->st_size,
-                         sizeof(struct spi_device_id), "spi",
-                         do_spi_entry, mod);
-        else if (sym_is(symname, "__mod_dmi_device_table"))
-                do_table(symval, sym->st_size,
-                         sizeof(struct dmi_system_id), "dmi",
-                         do_dmi_entry, mod);
-        else if (sym_is(symname, "__mod_platform_device_table"))
-                do_table(symval, sym->st_size,
-                         sizeof(struct platform_device_id), "platform",
-                         do_platform_entry, mod);
-        else if (sym_is(symname, "__mod_mdio_device_table"))
-                do_table(symval, sym->st_size,
-                         sizeof(struct mdio_device_id), "mdio",
-                         do_mdio_entry, mod);
-        else if (sym_is(symname, "__mod_zorro_device_table"))
-                do_table(symval, sym->st_size,
-                         sizeof(struct zorro_device_id), "zorro",
-                         do_zorro_entry, mod);
-        else if (sym_is(symname, "__mod_isapnp_device_table"))
-                do_table(symval, sym->st_size,
-                        sizeof(struct isapnp_device_id), "isa",
-                        do_isapnp_entry, mod);
        free(zeros);
 }
diff --git a/scripts/package/Makefile b/scripts/package/Makefile
index bc6aa003860e..87bf08076b11 100644
--- a/scripts/package/Makefile
+++ b/scripts/package/Makefile
@@ -141,7 +141,7 @@ perf-%pkg: FORCE
 help: FORCE
        @echo '  rpm-pkg             - Build both source and binary RPM kernel packages'
        @echo '  binrpm-pkg          - Build only the binary kernel package'
-        @echo '  deb-pkg             - Build the kernel as an deb package'
+        @echo '  deb-pkg             - Build the kernel as a deb package'
        @echo '  tar-pkg             - Build the kernel as an uncompressed tarball'
        @echo '  targz-pkg           - Build the kernel as a gzip compressed tarball'
        @echo '  tarbz2-pkg          - Build the kernel as a bzip2 compressed tarball'