src/console/printk.c

   1 /* SPDX-License-Identifier: GPL-2.0-only */
   2
   3 /*
   4  * blatantly copied from linux/kernel/printk.c
   5  */
   6
   7 #include <console/cbmem_console.h>
   8 #include <console/console.h>
   9 #include <console/streams.h>
  10 #include <console/vtxprintf.h>
  11 #include <smp/spinlock.h>
  12 #include <smp/node.h>
  13 #include <timer.h>
  14 #include <types.h>
  15
  16 DECLARE_SPIN_LOCK(console_lock)
  17
  18 #define TRACK_CONSOLE_TIME (!ENV_SMM && CONFIG(HAVE_MONOTONIC_TIMER))
  19
  20 static struct mono_time mt_start, mt_stop;
  21 static long console_usecs;
  22
  23 static void console_time_run(void)
  24 {
  25         if (TRACK_CONSOLE_TIME && boot_cpu())
  26                 timer_monotonic_get(&mt_start);
  27 }
  28
  29 static void console_time_stop(void)
  30 {
  31         if (TRACK_CONSOLE_TIME && boot_cpu()) {
  32                 timer_monotonic_get(&mt_stop);
  33                 console_usecs += mono_time_diff_microseconds(&mt_start, &mt_stop);
  34         }
  35 }
  36
  37 void console_time_report(void)
  38 {
  39         if (!TRACK_CONSOLE_TIME)
  40                 return;
  41
  42         printk(BIOS_DEBUG, "BS: " ENV_STRING " times (exec / console): total (unknown) / %ld ms\n",
  43                 DIV_ROUND_CLOSEST(console_usecs, USECS_PER_MSEC));
  44 }
  45
  46 long console_time_get_and_reset(void)
  47 {
  48         if (!TRACK_CONSOLE_TIME)
  49                 return 0;
  50
  51         long elapsed = console_usecs;
  52         console_usecs = 0;
  53         return elapsed;
  54 }
  55
  56 void do_putchar(unsigned char byte)
  57 {
  58         console_time_run();
  59         console_tx_byte(byte);
  60         console_time_stop();
  61 }
  62
  63 union log_state {
  64         void *as_ptr;
  65         struct {
  66                 uint8_t level;
  67                 uint8_t speed;
  68         };
  69 };
  70
  71 #define LOG_FAST(state) (HAS_ONLY_FAST_CONSOLES || ((state).speed == CONSOLE_LOG_FAST))
  72
  73 static void wrap_interactive_printf(const char *fmt, ...)
  74 {
  75         va_list args;
  76         va_start(args, fmt);
  77         vtxprintf(console_interactive_tx_byte, fmt, args, NULL);
  78         va_end(args);
  79 }
  80
  81 static void line_start(union log_state state)
  82 {
  83         if (state.level > BIOS_LOG_PREFIX_MAX_LEVEL)
  84                 return;
  85
  86         /* Stored consoles just get a single control char marker to save space. If we are in
  87            LOG_FAST mode, just write the marker to CBMC and exit -- the rest of this function
  88            implements the LOG_ALL case. */
  89         unsigned char marker = BIOS_LOG_LEVEL_TO_MARKER(state.level);
  90         if (LOG_FAST(state)) {
  91                 __cbmemc_tx_byte(marker);
  92                 return;
  93         }
  94         console_stored_tx_byte(marker, NULL);
  95
  96         /* Interactive consoles get a `[DEBUG]  ` style readable prefix,
  97            and potentially an escape sequence for highlighting. */
  98         if (CONFIG(CONSOLE_USE_ANSI_ESCAPES))
  99                 wrap_interactive_printf(BIOS_LOG_ESCAPE_PATTERN, bios_log_escape[state.level]);
 100         if (CONFIG(CONSOLE_USE_LOGLEVEL_PREFIX))
 101                 wrap_interactive_printf(BIOS_LOG_PREFIX_PATTERN, bios_log_prefix[state.level]);
 102 }
 103
 104 static void line_end(union log_state state)
 105 {
 106         if (CONFIG(CONSOLE_USE_ANSI_ESCAPES) && !LOG_FAST(state))
 107                 wrap_interactive_printf(BIOS_LOG_ESCAPE_RESET);
 108 }
 109
 110 static void wrap_putchar(unsigned char byte, void *data)
 111 {
 112         union log_state state = { .as_ptr = data };
 113         static bool line_started = false;
 114
 115         if (byte == '\n') {
 116                 line_end(state);
 117                 line_started = false;
 118         } else if (!line_started) {
 119                 line_start(state);
 120                 line_started = true;
 121         }
 122
 123         if (LOG_FAST(state))
 124                 __cbmemc_tx_byte(byte);
 125         else
 126                 console_tx_byte(byte);
 127 }
 128
 129 int vprintk(int msg_level, const char *fmt, va_list args)
 130 {
 131         union log_state state = { .level = msg_level };
 132         int i;
 133
 134         if (CONFIG(SQUELCH_EARLY_SMP) && ENV_ROMSTAGE_OR_BEFORE && !boot_cpu())
 135                 return 0;
 136
 137         state.speed = console_log_level(msg_level);
 138         if (state.speed < CONSOLE_LOG_FAST)
 139                 return 0;
 140
 141         spin_lock(&console_lock);
 142
 143         console_time_run();
 144
 145         i = vtxprintf(wrap_putchar, fmt, args, state.as_ptr);
 146         if (LOG_FAST(state))
 147                 console_tx_flush();
 148
 149         console_time_stop();
 150
 151         spin_unlock(&console_lock);
 152
 153         return i;
 154 }
 155
 156 int printk(int msg_level, const char *fmt, ...)
 157 {
 158         va_list args;
 159         int i;
 160
 161         va_start(args, fmt);
 162         i = vprintk(msg_level, fmt, args);
 163         va_end(args);
 164
 165         return i;
 166 }