tree b6a5c9e77308a964f09b721252d46443807e53f4
parent 993a06b6144d54ae2ad83cc25c18acb9d1720ad0
author Heinrich Schuchardt <xypron.glpk@gmx.de> 1602937918 +0200
committer Tom Rini <trini@konsulko.com> 1603821053 -0400

log: allow for message continuation

Some drivers use macro pr_cont() for continuing a message sent via printk.
Hence if we want to convert printk messaging to using the logging system,
we must support continuation of log messages too.

As pr_cont() does not provide a message level we need a means of
remembering the last log level.

With the patch a pseudo log level LOGL_CONT as well as a pseudo log
category LOGC_CONT are introduced. Using these results in the application
of the same log level and category as in the previous log message.

Signed-off-by: Heinrich Schuchardt <xypron.glpk@gmx.de>
Reviewed-by: Simon Glass <sjg@chromium.org>
