tree 6cd57dfec304a5cb049173dac6050bb0f13e6876
parent 34d99219726ff4d3425b360d1e8d081627a73a00
author Joe Perches <joe@perches.com> 1311639207 -0700
committer Linus Torvalds <torvalds@linux-foundation.org> 1311652636 -0700

checkpatch.pl: update $logFunctions

Previous behavior allowed only alphabetic prefixes like pr_info to exceed
the 80 column line length limit.

ath6kl wants to add a digit into the prefix, so allow numbers as well as
digits in the <prefix>_<level> printks.

<prefix>_<level>_ratelimited and <prefix>_<level>_once and WARN_RATELIMIT
and WARN_ONCE may now exceed 80 cols.

Add missing <prefix>_printk type for completeness.

Signed-off-by: Joe Perches <joe@perches.com>
Cc: Andy Whitcroft <apw@canonical.com>
Cc: Kalle Valo <kvalo@qca.qualcomm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
