1 /* 2 * Copyright (c) 2017-2020, ARM Limited and Contributors. All rights reserved. 3 * 4 * SPDX-License-Identifier: BSD-3-Clause 5 */ 6 7 #include <assert.h> 8 #include <string.h> 9 10 #include <drivers/coreboot/cbmem_console.h> 11 #include <common/debug.h> 12 #include <lib/coreboot.h> 13 #include <lib/mmio.h> 14 #include <lib/xlat_tables/xlat_tables_v2.h> 15 16 /* 17 * Structures describing coreboot's in-memory descriptor tables. See 18 * <coreboot>/src/commonlib/include/commonlib/coreboot_tables.h for 19 * canonical implementation. 20 */ 21 22 typedef struct { 23 char signature[4]; 24 uint32_t header_bytes; 25 uint32_t header_checksum; 26 uint32_t table_bytes; 27 uint32_t table_checksum; 28 uint32_t table_entries; 29 } cb_header_t; 30 31 typedef enum { 32 CB_TAG_MEMORY = 0x1, 33 CB_TAG_SERIAL = 0xf, 34 CB_TAG_CBMEM_CONSOLE = 0x17, 35 } cb_tag_t; 36 37 typedef struct { 38 uint32_t tag; 39 uint32_t size; 40 union { 41 coreboot_memrange_t memranges[COREBOOT_MAX_MEMRANGES]; 42 coreboot_serial_t serial; 43 uint64_t uint64; 44 }; 45 } cb_entry_t; 46 47 coreboot_memrange_t coreboot_memranges[COREBOOT_MAX_MEMRANGES]; 48 coreboot_serial_t coreboot_serial; 49 uint64_t coreboot_table_addr; 50 uint32_t coreboot_table_size; 51 52 /* 53 * The coreboot table is parsed before the MMU is enabled (i.e. with strongly 54 * ordered memory), so we cannot make unaligned accesses. The table entries 55 * immediately follow one another without padding, so nothing after the header 56 * is guaranteed to be naturally aligned. Therefore, we need to define safety 57 * functions that can read unaligned integers. 58 */ 59 static uint32_t read_le32(uint32_t *p) 60 { 61 uintptr_t addr = (uintptr_t)p; 62 return mmio_read_8(addr) | 63 mmio_read_8(addr + 1) << 8 | 64 mmio_read_8(addr + 2) << 16 | 65 mmio_read_8(addr + 3) << 24; 66 } 67 static uint64_t read_le64(uint64_t *p) 68 { 69 return read_le32((void *)p) | (uint64_t)read_le32((void *)p + 4) << 32; 70 } 71 72 static void expand_and_mmap(uintptr_t baseaddr, size_t size) 73 { 74 uintptr_t pageaddr = round_down(baseaddr, PAGE_SIZE); 75 size_t expanded = round_up(baseaddr - pageaddr + size, PAGE_SIZE); 76 mmap_add_region(pageaddr, pageaddr, expanded, 77 MT_MEMORY | MT_RW | MT_NS | MT_EXECUTE_NEVER); 78 } 79 80 static void setup_cbmem_console(uintptr_t baseaddr) 81 { 82 static console_cbmc_t console; 83 assert(!console.console.base); /* should only have one CBMEM console */ 84 85 /* CBMEM console structure stores its size in first header field. */ 86 uint32_t size = *(uint32_t *)baseaddr; 87 expand_and_mmap(baseaddr, size); 88 console_cbmc_register(baseaddr, &console); 89 console_set_scope(&console.console, CONSOLE_FLAG_BOOT | 90 CONSOLE_FLAG_RUNTIME | 91 CONSOLE_FLAG_CRASH); 92 } 93 94 coreboot_memory_t coreboot_get_memory_type(uintptr_t start, size_t size) 95 { 96 int i; 97 98 for (i = 0; i < COREBOOT_MAX_MEMRANGES; i++) { 99 coreboot_memrange_t *range = &coreboot_memranges[i]; 100 101 if (range->type == CB_MEM_NONE) 102 break; /* end of table reached */ 103 if ((start >= range->start) && 104 (start - range->start < range->size) && 105 (size <= range->size - (start - range->start))) { 106 return range->type; 107 } 108 } 109 110 return CB_MEM_NONE; 111 } 112 113 void coreboot_get_table_location(uint64_t *address, uint32_t *size) 114 { 115 *address = coreboot_table_addr; 116 *size = coreboot_table_size; 117 } 118 119 void coreboot_table_setup(void *base) 120 { 121 cb_header_t *header = base; 122 void *ptr; 123 int i; 124 125 if (strncmp(header->signature, "LBIO", 4)) { 126 ERROR("coreboot table signature corrupt!\n"); 127 return; 128 } 129 coreboot_table_addr = (uint64_t) base; 130 coreboot_table_size = header->header_bytes + header->table_bytes; 131 132 ptr = base + header->header_bytes; 133 for (i = 0; i < header->table_entries; i++) { 134 size_t size; 135 cb_entry_t *entry = ptr; 136 137 if (ptr - base >= header->header_bytes + header->table_bytes) { 138 ERROR("coreboot table exceeds its bounds!\n"); 139 break; 140 } 141 142 switch (read_le32(&entry->tag)) { 143 case CB_TAG_MEMORY: 144 size = read_le32(&entry->size) - 145 offsetof(cb_entry_t, memranges); 146 if (size > sizeof(coreboot_memranges)) { 147 ERROR("Need to truncate coreboot memranges!\n"); 148 size = sizeof(coreboot_memranges); 149 } 150 memcpy(&coreboot_memranges, &entry->memranges, size); 151 break; 152 case CB_TAG_SERIAL: 153 memcpy(&coreboot_serial, &entry->serial, 154 sizeof(coreboot_serial)); 155 break; 156 case CB_TAG_CBMEM_CONSOLE: 157 setup_cbmem_console(read_le64(&entry->uint64)); 158 break; 159 default: 160 /* There are many tags TF doesn't need to care about. */ 161 break; 162 } 163 164 ptr += read_le32(&entry->size); 165 } 166 } 167