cmd/log.c

   1 /*
   2  * (C) Copyright 2002-2007
   3  * Detlev Zundel, DENX Software Engineering, dzu@denx.de.
   4  *
   5  * Code used from linux/kernel/printk.c
   6  * Copyright (C) 1991, 1992  Linus Torvalds
   7  *
   8  * SPDX-License-Identifier:     GPL-2.0+
   9  *
  10  * Comments:
  11  *
  12  * After relocating the code, the environment variable "loglevel" is
  13  * copied to console_loglevel.  The functionality is similar to the
  14  * handling in the Linux kernel, i.e. messages logged with a priority
  15  * less than console_loglevel are also output to stdout.
  16  *
  17  * If you want messages with the default level (e.g. POST messages) to
  18  * appear on stdout also, make sure the environment variable
  19  * "loglevel" is set at boot time to a number higher than
  20  * default_message_loglevel below.
  21  */
  22
  23 /*
  24  * Logbuffer handling routines
  25  */
  26
  27 #include <common.h>
  28 #include <command.h>
  29 #include <stdio_dev.h>
  30 #include <post.h>
  31 #include <logbuff.h>
  32
  33 DECLARE_GLOBAL_DATA_PTR;
  34
  35 /* Local prototypes */
  36 static void logbuff_putc(struct stdio_dev *dev, const char c);
  37 static void logbuff_puts(struct stdio_dev *dev, const char *s);
  38 static int logbuff_printk(const char *line);
  39
  40 static char buf[1024];
  41
  42 /* This combination will not print messages with the default loglevel */
  43 static unsigned console_loglevel = 3;
  44 static unsigned default_message_loglevel = 4;
  45 static unsigned log_version = 1;
  46 #ifdef CONFIG_ALT_LB_ADDR
  47 static volatile logbuff_t *log;
  48 #else
  49 static logbuff_t *log;
  50 #endif
  51 static char *lbuf;
  52
  53 unsigned long __logbuffer_base(void)
  54 {
  55         return CONFIG_SYS_SDRAM_BASE + get_effective_memsize() - LOGBUFF_LEN;
  56 }
  57 unsigned long logbuffer_base(void)
  58 __attribute__((weak, alias("__logbuffer_base")));
  59
  60 void logbuff_init_ptrs(void)
  61 {
  62         unsigned long tag, post_word;
  63         char *s;
  64
  65 #ifdef CONFIG_ALT_LB_ADDR
  66         log = (logbuff_t *)CONFIG_ALT_LH_ADDR;
  67         lbuf = (char *)CONFIG_ALT_LB_ADDR;
  68 #else
  69         log = (logbuff_t *)(logbuffer_base()) - 1;
  70         lbuf = (char *)log->buf;
  71 #endif
  72
  73         /* Set up log version */
  74         s = env_get("logversion");
  75         if (s)
  76                 log_version = (int)simple_strtoul(s, NULL, 10);
  77
  78         if (log_version == 2)
  79                 tag = log->v2.tag;
  80         else
  81                 tag = log->v1.tag;
  82         post_word = post_word_load();
  83 #ifdef CONFIG_POST
  84         /* The post routines have setup the word so we can simply test it */
  85         if (tag != LOGBUFF_MAGIC || (post_word & POST_COLDBOOT))
  86                 logbuff_reset();
  87 #else
  88         /* No post routines, so we do our own checking                    */
  89         if (tag != LOGBUFF_MAGIC || post_word != LOGBUFF_MAGIC) {
  90                 logbuff_reset ();
  91                 post_word_store (LOGBUFF_MAGIC);
  92         }
  93 #endif
  94         if (log_version == 2 && (long)log->v2.start > (long)log->v2.con)
  95                 log->v2.start = log->v2.con;
  96
  97         /* Initialize default loglevel if present */
  98         s = env_get("loglevel");
  99         if (s)
 100                 console_loglevel = (int)simple_strtoul(s, NULL, 10);
 101
 102         gd->flags |= GD_FLG_LOGINIT;
 103 }
 104
 105 void logbuff_reset(void)
 106 {
 107 #ifndef CONFIG_ALT_LB_ADDR
 108         memset(log, 0, sizeof(logbuff_t));
 109 #endif
 110         if (log_version == 2) {
 111                 log->v2.tag = LOGBUFF_MAGIC;
 112 #ifdef CONFIG_ALT_LB_ADDR
 113                 log->v2.start = 0;
 114                 log->v2.con = 0;
 115                 log->v2.end = 0;
 116                 log->v2.chars = 0;
 117 #endif
 118         } else {
 119                 log->v1.tag = LOGBUFF_MAGIC;
 120 #ifdef CONFIG_ALT_LB_ADDR
 121                 log->v1.dummy = 0;
 122                 log->v1.start = 0;
 123                 log->v1.size = 0;
 124                 log->v1.chars = 0;
 125 #endif
 126         }
 127 }
 128
 129 int drv_logbuff_init(void)
 130 {
 131         struct stdio_dev logdev;
 132         int rc;
 133
 134         /* Device initialization */
 135         memset (&logdev, 0, sizeof (logdev));
 136
 137         strcpy (logdev.name, "logbuff");
 138         logdev.ext   = 0;                       /* No extensions */
 139         logdev.flags = DEV_FLAGS_OUTPUT;        /* Output only */
 140         logdev.putc  = logbuff_putc;            /* 'putc' function */
 141         logdev.puts  = logbuff_puts;            /* 'puts' function */
 142
 143         rc = stdio_register(&logdev);
 144
 145         return (rc == 0) ? 1 : rc;
 146 }
 147
 148 static void logbuff_putc(struct stdio_dev *dev, const char c)
 149 {
 150         char buf[2];
 151         buf[0] = c;
 152         buf[1] = '\0';
 153         logbuff_printk(buf);
 154 }
 155
 156 static void logbuff_puts(struct stdio_dev *dev, const char *s)
 157 {
 158         logbuff_printk (s);
 159 }
 160
 161 void logbuff_log(char *msg)
 162 {
 163         if ((gd->flags & GD_FLG_LOGINIT)) {
 164                 logbuff_printk(msg);
 165         } else {
 166                 /*
 167                  * Can happen only for pre-relocated errors as logging
 168                  * at that stage should be disabled
 169                  */
 170                 puts (msg);
 171         }
 172 }
 173
 174 /*
 175  * Subroutine:  do_log
 176  *
 177  * Description: Handler for 'log' command..
 178  *
 179  * Inputs:      argv[1] contains the subcommand
 180  *
 181  * Return:      None
 182  *
 183  */
 184 int do_log(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 185 {
 186         struct stdio_dev *sdev = NULL;
 187         char *s;
 188         unsigned long i, start, size;
 189
 190         if (strcmp(argv[1], "append") == 0) {
 191                 /* Log concatenation of all arguments separated by spaces */
 192                 for (i = 2; i < argc; i++) {
 193                         logbuff_printk(argv[i]);
 194                         logbuff_putc(sdev, (i < argc - 1) ? ' ' : '\n');
 195                 }
 196                 return 0;
 197         }
 198
 199         switch (argc) {
 200
 201         case 2:
 202                 if (strcmp(argv[1], "show") == 0) {
 203                         if (log_version == 2) {
 204                                 start = log->v2.start;
 205                                 size = log->v2.end - log->v2.start;
 206                         } else {
 207                                 start = log->v1.start;
 208                                 size = log->v1.size;
 209                         }
 210                         if (size > LOGBUFF_LEN)
 211                                 size = LOGBUFF_LEN;
 212                         for (i = 0; i < size; i++) {
 213                                 s = lbuf + ((start + i) & LOGBUFF_MASK);
 214                                 putc(*s);
 215                         }
 216                         return 0;
 217                 } else if (strcmp(argv[1], "reset") == 0) {
 218                         logbuff_reset();
 219                         return 0;
 220                 } else if (strcmp(argv[1], "info") == 0) {
 221                         printf("Logbuffer   at  %08lx\n", (unsigned long)lbuf);
 222                         if (log_version == 2) {
 223                                 printf("log_start    =  %08lx\n",
 224                                         log->v2.start);
 225                                 printf("log_end      =  %08lx\n", log->v2.end);
 226                                 printf("log_con      =  %08lx\n", log->v2.con);
 227                                 printf("logged_chars =  %08lx\n",
 228                                         log->v2.chars);
 229                         }
 230                         else {
 231                                 printf("log_start    =  %08lx\n",
 232                                         log->v1.start);
 233                                 printf("log_size     =  %08lx\n",
 234                                         log->v1.size);
 235                                 printf("logged_chars =  %08lx\n",
 236                                         log->v1.chars);
 237                         }
 238                         return 0;
 239                 }
 240                 return CMD_RET_USAGE;
 241
 242         default:
 243                 return CMD_RET_USAGE;
 244         }
 245 }
 246
 247 U_BOOT_CMD(
 248         log,     255,   1,      do_log,
 249         "manipulate logbuffer",
 250         "info   - show pointer details\n"
 251         "log reset  - clear contents\n"
 252         "log show   - show contents\n"
 253         "log append <msg> - append <msg> to the logbuffer"
 254 );
 255
 256 static int logbuff_printk(const char *line)
 257 {
 258         int i;
 259         char *msg, *p, *buf_end;
 260         int line_feed;
 261         static signed char msg_level = -1;
 262
 263         strcpy(buf + 3, line);
 264         i = strlen(line);
 265         buf_end = buf + 3 + i;
 266         for (p = buf + 3; p < buf_end; p++) {
 267                 msg = p;
 268                 if (msg_level < 0) {
 269                         if (
 270                                 p[0] != '<' ||
 271                                 p[1] < '0' ||
 272                                 p[1] > '7' ||
 273                                 p[2] != '>'
 274                         ) {
 275                                 p -= 3;
 276                                 p[0] = '<';
 277                                 p[1] = default_message_loglevel + '0';
 278                                 p[2] = '>';
 279                         } else {
 280                                 msg += 3;
 281                         }
 282                         msg_level = p[1] - '0';
 283                 }
 284                 line_feed = 0;
 285                 for (; p < buf_end; p++) {
 286                         if (log_version == 2) {
 287                                 lbuf[log->v2.end & LOGBUFF_MASK] = *p;
 288                                 log->v2.end++;
 289                                 if (log->v2.end - log->v2.start > LOGBUFF_LEN)
 290                                         log->v2.start++;
 291                                 log->v2.chars++;
 292                         } else {
 293                                 lbuf[(log->v1.start + log->v1.size) &
 294                                          LOGBUFF_MASK] = *p;
 295                                 if (log->v1.size < LOGBUFF_LEN)
 296                                         log->v1.size++;
 297                                 else
 298                                         log->v1.start++;
 299                                 log->v1.chars++;
 300                         }
 301                         if (*p == '\n') {
 302                                 line_feed = 1;
 303                                 break;
 304                         }
 305                 }
 306                 if (msg_level < console_loglevel) {
 307                         printf("%s", msg);
 308                 }
 309                 if (line_feed)
 310                         msg_level = -1;
 311         }
 312         return i;
 313 }