src/lib/cbmem_console.c

   1 /*
   2  * This file is part of the coreboot project.
   3  *
   4  * Copyright (C) 2011 The ChromiumOS Authors.  All rights reserved.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; version 2 of the License.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
  18  */
  19
  20 #include <console/console.h>
  21 #include <console/cbmem_console.h>
  22 #include <cbmem.h>
  23 #include <arch/early_variables.h>
  24 #include <string.h>
  25
  26 /*
  27  * Structure describing console buffer. It is overlaid on a flat memory area,
  28  * with buffer_body covering the extent of the memory. Once the buffer is
  29  * full, the cursor keeps going but the data is dropped on the floor. This
  30  * allows to tell how much data was lost in the process.
  31  */
  32 struct cbmem_console {
  33         u32 buffer_size;
  34         u32 buffer_cursor;
  35         u8  buffer_body[0];
  36 }  __attribute__ ((__packed__));
  37
  38 static struct cbmem_console *cbmem_console_p CAR_GLOBAL;
  39
  40 #ifdef __PRE_RAM__
  41 /*
  42  * While running from ROM, before DRAM is initialized, some area in cache as
  43  * ram space is used for the console buffer storage. The size and location of
  44  * the area are defined in the config.
  45  */
  46
  47 extern struct cbmem_console preram_cbmem_console;
  48
  49 #else
  50
  51 /*
  52  * When running from RAM, a lot of console output is generated before CBMEM is
  53  * reinitialized. This static buffer is used to store that output temporarily,
  54  * to be concatenated with the CBMEM console buffer contents accumulated
  55  * during the ROM stage, once CBMEM becomes available at RAM stage.
  56  */
  57
  58 #if CONFIG_DYNAMIC_CBMEM
  59 #define STATIC_CONSOLE_SIZE 1024
  60 #else
  61 #define STATIC_CONSOLE_SIZE CONFIG_CONSOLE_CBMEM_BUFFER_SIZE
  62 #endif
  63 static u8 static_console[STATIC_CONSOLE_SIZE];
  64 #endif
  65
  66 static inline struct cbmem_console *current_console(void)
  67 {
  68         return car_get_var(cbmem_console_p);
  69 }
  70
  71 static inline void current_console_set(struct cbmem_console *new_console_p)
  72 {
  73         car_set_var(cbmem_console_p, new_console_p);
  74 }
  75
  76 static inline void init_console_ptr(void *storage, u32 total_space)
  77 {
  78         struct cbmem_console *cbm_cons_p = storage;
  79
  80         /* Initialize the cache-as-ram pointer and underlying structure. */
  81         car_set_var(cbmem_console_p, cbm_cons_p);
  82         cbm_cons_p->buffer_size = total_space - sizeof(struct cbmem_console);
  83         cbm_cons_p->buffer_cursor = 0;
  84 }
  85
  86 void cbmemc_init(void)
  87 {
  88 #ifdef __PRE_RAM__
  89         init_console_ptr(&preram_cbmem_console,
  90                          CONFIG_CONSOLE_PRERAM_BUFFER_SIZE);
  91 #else
  92         /*
  93          * Initializing before CBMEM is available, use static buffer to store
  94          * the log.
  95          */
  96         init_console_ptr(static_console, sizeof(static_console));
  97 #endif
  98 }
  99
 100 void cbmemc_tx_byte(unsigned char data)
 101 {
 102         struct cbmem_console *cbm_cons_p = current_console();
 103         u32 cursor;
 104
 105         if (!cbm_cons_p)
 106                 return;
 107
 108         cursor = cbm_cons_p->buffer_cursor++;
 109         if (cursor < cbm_cons_p->buffer_size)
 110                 cbm_cons_p->buffer_body[cursor] = data;
 111 }
 112
 113 /*
 114  * Copy the current console buffer (either from the cache as RAM area, or from
 115  * the static buffer, pointed at by cbmem_console_p) into the CBMEM console
 116  * buffer space (pointed at by new_cons_p), concatenating the copied data with
 117  * the CBMEM console buffer contents.
 118  *
 119  * If there is overflow - add to the destination area a string, reporting the
 120  * overflow and the number of dropped characters.
 121  */
 122 static void copy_console_buffer(struct cbmem_console *new_cons_p)
 123 {
 124         u32 copy_size, dropped_chars;
 125         u32 cursor = new_cons_p->buffer_cursor;
 126         struct cbmem_console *old_cons_p;
 127
 128         old_cons_p = current_console();
 129
 130         if (old_cons_p->buffer_cursor < old_cons_p->buffer_size)
 131                 copy_size = old_cons_p->buffer_cursor;
 132         else
 133                 copy_size = old_cons_p->buffer_size;
 134
 135         if (cursor > new_cons_p->buffer_size)
 136                 copy_size = 0;
 137         else if (cursor + copy_size > new_cons_p->buffer_size)
 138                 copy_size = new_cons_p->buffer_size - cursor;
 139
 140         dropped_chars = old_cons_p->buffer_cursor - copy_size;
 141         if (dropped_chars) {
 142                 /* Reserve 80 chars to report overflow, if possible. */
 143                 if (copy_size < 80)
 144                         return;
 145                 copy_size -= 80;
 146                 dropped_chars += 80;
 147         }
 148
 149         memcpy(new_cons_p->buffer_body + cursor, old_cons_p->buffer_body,
 150                copy_size);
 151
 152         cursor += copy_size;
 153
 154         if (dropped_chars) {
 155                 const char loss_str1[] = "\n\n*** Log truncated, ";
 156                 const char loss_str2[] = " characters dropped. ***\n\n";
 157
 158                 /*
 159                  * When running from ROM sprintf is not available, a simple
 160                  * itoa implementation is used instead.
 161                  */
 162                 int got_first_digit = 0;
 163
 164                 /* Way more than possible number of dropped characters. */
 165                 u32 mult = 100000;
 166
 167                 strcpy((char *)new_cons_p->buffer_body + cursor, loss_str1);
 168                 cursor += sizeof(loss_str1) - 1;
 169
 170                 while (mult) {
 171                         int digit = dropped_chars / mult;
 172                         if (got_first_digit || digit) {
 173                                 new_cons_p->buffer_body[cursor++] = digit + '0';
 174                                 dropped_chars %= mult;
 175                                 /* Excessive, but keeps it simple */
 176                                 got_first_digit = 1;
 177                         }
 178                         mult /= 10;
 179                 }
 180
 181                 strcpy((char *)new_cons_p->buffer_body + cursor, loss_str2);
 182                 cursor += sizeof(loss_str2) - 1;
 183         }
 184         new_cons_p->buffer_cursor = cursor;
 185 }
 186
 187 void cbmemc_reinit(void)
 188 {
 189         struct cbmem_console *cbm_cons_p = NULL;
 190
 191 #ifdef __PRE_RAM__
 192         if (IS_ENABLED(CONFIG_BROKEN_CAR_MIGRATE))
 193                 return;
 194 #endif
 195
 196 #ifndef __PRE_RAM__
 197         cbm_cons_p = cbmem_find(CBMEM_ID_CONSOLE);
 198 #endif
 199
 200         if (!cbm_cons_p) {
 201                 cbm_cons_p = cbmem_add(CBMEM_ID_CONSOLE,
 202                                                         CONFIG_CONSOLE_CBMEM_BUFFER_SIZE);
 203
 204                 if (!cbm_cons_p) {
 205                         current_console_set(NULL);
 206                         return;
 207                 }
 208
 209                 cbm_cons_p->buffer_size = CONFIG_CONSOLE_CBMEM_BUFFER_SIZE -
 210                         sizeof(struct cbmem_console);
 211
 212                 cbm_cons_p->buffer_cursor = 0;
 213         }
 214
 215         copy_console_buffer(cbm_cons_p);
 216
 217         current_console_set(cbm_cons_p);
 218 }
 219
 220 /* Call cbmemc_reinit() at CAR migration time. */
 221 CAR_MIGRATE(cbmemc_reinit)