payloads/coreinfo/coreboot_module.c

   1 /* SPDX-License-Identifier: GPL-2.0-only */
   2
   3 #include "coreinfo.h"
   4 #include <coreboot_tables.h>
   5
   6 #if CONFIG(MODULE_COREBOOT)
   7
   8 #define MAX_MEMORY_COUNT 5
   9
  10 static struct {
  11         int mem_count;
  12         int mem_actual;
  13
  14         struct cb_memory_range range[MAX_MEMORY_COUNT];
  15
  16         char vendor[32];
  17         char part[32];
  18
  19         char strings[10][64];
  20
  21         struct cb_serial serial;
  22         struct cb_console console;
  23 } cb_info;
  24
  25 static int tables_good = 0;
  26
  27 static int coreboot_module_redraw(WINDOW *win)
  28 {
  29         int row = 2;
  30         int i;
  31
  32         print_module_title(win, "coreboot Tables");
  33
  34         if (tables_good) {
  35                 mvwprintw(win, row++, 1, "No coreboot tables were found");
  36                 return 0;
  37         }
  38
  39         mvwprintw(win, row++, 1, "Vendor: %s", cb_info.vendor);
  40         mvwprintw(win, row++, 1, "Part: %s", cb_info.part);
  41
  42         mvwprintw(win, row++, 1, "Version: %s%s",
  43                   cb_info.strings[CB_TAG_VERSION - 0x4],
  44                   cb_info.strings[CB_TAG_EXTRA_VERSION - 0x4]);
  45
  46         mvwprintw(win, row++, 1, "Built: %s (%s@%s.%s)",
  47                   cb_info.strings[CB_TAG_BUILD - 0x4],
  48                   cb_info.strings[CB_TAG_COMPILE_BY - 0x04],
  49                   cb_info.strings[CB_TAG_COMPILE_HOST - 0x04],
  50                   cb_info.strings[CB_TAG_COMPILE_DOMAIN - 0x04]);
  51
  52         if (cb_info.serial.tag != 0x0) {
  53                 mvwprintw(win, row++, 1, "Serial Port I/O base: 0x%x",
  54                           cb_info.serial.baseaddr);
  55         }
  56
  57         if (cb_info.console.tag != 0x0) {
  58                 mvwprintw(win, row++, 1, "Default Output Console: ");
  59
  60                 switch (cb_info.console.type) {
  61                 case CB_TAG_CONSOLE_SERIAL8250:
  62                         wprintw(win, "Serial Port");
  63                         break;
  64                 case CB_TAG_CONSOLE_VGA:
  65                         wprintw(win, "VGA");
  66                         break;
  67                 case CB_TAG_CONSOLE_BTEXT:
  68                         wprintw(win, "BTEXT");
  69                         break;
  70                 case CB_TAG_CONSOLE_LOGBUF:
  71                         wprintw(win, "Log Buffer");
  72                         break;
  73                 case CB_TAG_CONSOLE_SROM:
  74                         wprintw(win, "Serial ROM");
  75                         break;
  76                 case CB_TAG_CONSOLE_EHCI:
  77                         wprintw(win, "USB Debug");
  78                         break;
  79                 }
  80         }
  81
  82         row++;
  83         mvwprintw(win, row++, 1, "-- Memory Map --");
  84
  85         for (i = 0; i < cb_info.mem_count; i++) {
  86                 switch (cb_info.range[i].type) {
  87                 case CB_MEM_RAM:
  88                         mvwprintw(win, row++, 3, "     RAM: ");
  89                         break;
  90                 case CB_MEM_RESERVED:
  91                         mvwprintw(win, row++, 3, "Reserved: ");
  92                         break;
  93                 case CB_MEM_TABLE:
  94                         mvwprintw(win, row++, 3, "   Table: ");
  95                 }
  96
  97                 wprintw(win, "%16.16llx - %16.16llx", cb_info.range[i].start,
  98                         cb_info.range[i].start + cb_info.range[i].size - 1);
  99         }
 100
 101         return 0;
 102 }
 103
 104 static void parse_memory(unsigned char *ptr)
 105 {
 106         struct cb_memory *mem = (struct cb_memory *)ptr;
 107         int max = (MEM_RANGE_COUNT(mem) > MAX_MEMORY_COUNT)
 108             ? MAX_MEMORY_COUNT : MEM_RANGE_COUNT(mem);
 109         int i;
 110
 111         for (i = 0; i < max; i++) {
 112                 struct cb_memory_range *range =
 113                     (struct cb_memory_range *)MEM_RANGE_PTR(mem, i);
 114
 115                 memcpy(&cb_info.range[i], range, sizeof(*range));
 116         }
 117
 118         cb_info.mem_count = max;
 119         cb_info.mem_actual = MEM_RANGE_COUNT(mem);
 120 }
 121
 122 static void parse_mainboard(unsigned char *ptr)
 123 {
 124         struct cb_mainboard *mb = (struct cb_mainboard *)ptr;
 125
 126         strncpy(cb_info.vendor, cb_mb_vendor_string(mb), sizeof(cb_info.vendor) - 1);
 127         strncpy(cb_info.part, cb_mb_part_string(mb), sizeof(cb_info.part) - 1);
 128 }
 129
 130 static void parse_strings(unsigned char *ptr)
 131 {
 132         struct cb_string *string = (struct cb_string *)ptr;
 133         int index = string->tag - CB_TAG_VERSION;
 134
 135         strncpy(cb_info.strings[index], (const char *)string->string, 63);
 136         cb_info.strings[index][63] = 0;
 137 }
 138
 139 static void parse_serial(unsigned char *ptr)
 140 {
 141         memcpy(&cb_info.serial, (struct cb_serial *)ptr,
 142                sizeof(struct cb_serial));
 143 }
 144
 145 static void parse_console(unsigned char *ptr)
 146 {
 147         memcpy(&cb_info.console, (struct cb_console *)ptr,
 148                sizeof(struct cb_console));
 149 }
 150
 151 static int parse_header(void *addr, int len)
 152 {
 153         struct cb_header *header;
 154         unsigned char *ptr = (unsigned char *)addr;
 155         int i;
 156
 157         for (i = 0; i < len; i += 16, ptr += 16) {
 158                 header = (struct cb_header *)ptr;
 159
 160                 if (!strncmp((const char *)header->signature, "LBIO", 4))
 161                         break;
 162         }
 163
 164         /* We walked the entire space and didn't find anything. */
 165         if (i >= len)
 166                 return -1;
 167
 168         if (!header->table_bytes)
 169                 return 0;
 170
 171         /* FIXME: Check the checksum. */
 172
 173         if (cb_checksum(header, sizeof(*header)))
 174                 return -1;
 175
 176         if (cb_checksum((ptr + sizeof(*header)), header->table_bytes)
 177             != header->table_checksum)
 178                 return -1;
 179
 180         /* Now, walk the tables. */
 181         ptr += header->header_bytes;
 182
 183         for (u32 j = 0; j < header->table_entries; j++) {
 184                 struct cb_record *rec = (struct cb_record *)ptr;
 185
 186                 switch (rec->tag) {
 187                 case CB_TAG_FORWARD:
 188                         return parse_header((void *)(unsigned long)((struct cb_forward *)rec)->forward, 1);
 189                 case CB_TAG_MEMORY:
 190                         parse_memory(ptr);
 191                         break;
 192                 case CB_TAG_MAINBOARD:
 193                         parse_mainboard(ptr);
 194                         break;
 195                 case CB_TAG_VERSION:
 196                 case CB_TAG_EXTRA_VERSION:
 197                 case CB_TAG_BUILD:
 198                 case CB_TAG_COMPILE_TIME:
 199                 case CB_TAG_COMPILE_BY:
 200                 case CB_TAG_COMPILE_HOST:
 201                 case CB_TAG_COMPILE_DOMAIN:
 202                 case CB_TAG_COMPILER:
 203                 case CB_TAG_LINKER:
 204                 case CB_TAG_ASSEMBLER:
 205                         parse_strings(ptr);
 206                         break;
 207                 case CB_TAG_SERIAL:
 208                         parse_serial(ptr);
 209                         break;
 210                 case CB_TAG_CONSOLE:
 211                         parse_console(ptr);
 212                         break;
 213                 default:
 214                         break;
 215                 }
 216
 217                 ptr += rec->size;
 218         }
 219
 220         return 1;
 221 }
 222
 223 static int coreboot_module_init(void)
 224 {
 225         int ret = parse_header((void *)0x00000, 0x1000);
 226
 227         if (ret != 1)
 228                 ret = parse_header((void *)0xf0000, 0x1000);
 229
 230         /* Return error if we couldn't find it at either address. */
 231         tables_good = (ret == 1) ? 0 : -1;
 232         return tables_good;
 233 }
 234
 235 struct coreinfo_module coreboot_module = {
 236         .name = "coreboot",
 237         .init = coreboot_module_init,
 238         .redraw = coreboot_module_redraw,
 239 };
 240
 241 #else
 242
 243 struct coreinfo_module coreboot_module = {
 244 };
 245
 246 #endif