src/arch/x86/boot/coreboot_table.c

   1 /*
   2  * This file is part of the coreboot project.
   3  *
   4  * Copyright (C) 2003-2004 Eric Biederman
   5  * Copyright (C) 2005-2010 coresystems GmbH
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License as
   9  * published by the Free Software Foundation; version 2 of
  10  * the License.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
  20  * MA 02110-1301 USA
  21  */
  22
  23 #include <console/console.h>
  24 #include <ip_checksum.h>
  25 #include <boot/tables.h>
  26 #include <boot/coreboot_tables.h>
  27 #include <arch/coreboot_tables.h>
  28 #include <string.h>
  29 #include <version.h>
  30 #include <device/device.h>
  31 #include <stdlib.h>
  32 #include <cbfs.h>
  33 #include <cbmem.h>
  34 #if CONFIG_USE_OPTION_TABLE
  35 #include <option_table.h>
  36 #endif
  37
  38 static struct lb_header *lb_table_init(unsigned long addr)
  39 {
  40         struct lb_header *header;
  41
  42         /* 16 byte align the address */
  43         addr += 15;
  44         addr &= ~15;
  45
  46         header = (void *)addr;
  47         header->signature[0] = 'L';
  48         header->signature[1] = 'B';
  49         header->signature[2] = 'I';
  50         header->signature[3] = 'O';
  51         header->header_bytes = sizeof(*header);
  52         header->header_checksum = 0;
  53         header->table_bytes = 0;
  54         header->table_checksum = 0;
  55         header->table_entries = 0;
  56         return header;
  57 }
  58
  59 static struct lb_record *lb_first_record(struct lb_header *header)
  60 {
  61         struct lb_record *rec;
  62         rec = (void *)(((char *)header) + sizeof(*header));
  63         return rec;
  64 }
  65
  66 static struct lb_record *lb_last_record(struct lb_header *header)
  67 {
  68         struct lb_record *rec;
  69         rec = (void *)(((char *)header) + sizeof(*header) + header->table_bytes);
  70         return rec;
  71 }
  72
  73 #if 0
  74 static struct lb_record *lb_next_record(struct lb_record *rec)
  75 {
  76         rec = (void *)(((char *)rec) + rec->size);
  77         return rec;
  78 }
  79 #endif
  80
  81 static struct lb_record *lb_new_record(struct lb_header *header)
  82 {
  83         struct lb_record *rec;
  84         rec = lb_last_record(header);
  85         if (header->table_entries) {
  86                 header->table_bytes += rec->size;
  87         }
  88         rec = lb_last_record(header);
  89         header->table_entries++;
  90         rec->tag = LB_TAG_UNUSED;
  91         rec->size = sizeof(*rec);
  92         return rec;
  93 }
  94
  95
  96 static struct lb_memory *lb_memory(struct lb_header *header)
  97 {
  98         struct lb_record *rec;
  99         struct lb_memory *mem;
 100         rec = lb_new_record(header);
 101         mem = (struct lb_memory *)rec;
 102         mem->tag = LB_TAG_MEMORY;
 103         mem->size = sizeof(*mem);
 104         return mem;
 105 }
 106
 107 static struct lb_serial *lb_serial(struct lb_header *header)
 108 {
 109 #if CONFIG_CONSOLE_SERIAL8250
 110         struct lb_record *rec;
 111         struct lb_serial *serial;
 112         rec = lb_new_record(header);
 113         serial = (struct lb_serial *)rec;
 114         serial->tag = LB_TAG_SERIAL;
 115         serial->size = sizeof(*serial);
 116         serial->type = LB_SERIAL_TYPE_IO_MAPPED;
 117         serial->baseaddr = CONFIG_TTYS0_BASE;
 118         serial->baud = CONFIG_TTYS0_BAUD;
 119         return serial;
 120 #elif CONFIG_CONSOLE_SERIAL8250MEM
 121         if (uartmem_getbaseaddr()) {
 122                 struct lb_record *rec;
 123                 struct lb_serial *serial;
 124                 rec = lb_new_record(header);
 125                 serial = (struct lb_serial *)rec;
 126                 serial->tag = LB_TAG_SERIAL;
 127                 serial->size = sizeof(*serial);
 128                 serial->type = LB_SERIAL_TYPE_MEMORY_MAPPED;
 129                 serial->baseaddr = uartmem_getbaseaddr();
 130                 serial->baud = CONFIG_TTYS0_BAUD;
 131                 return serial;
 132         } else {
 133                 return NULL;
 134         }
 135 #else
 136         return NULL;
 137 #endif
 138 }
 139
 140 #if CONFIG_CONSOLE_SERIAL8250 || CONFIG_CONSOLE_SERIAL8250MEM || \
 141     CONFIG_CONSOLE_LOGBUF || CONFIG_USBDEBUG
 142 static void add_console(struct lb_header *header, u16 consoletype)
 143 {
 144         struct lb_console *console;
 145
 146         console = (struct lb_console *)lb_new_record(header);
 147         console->tag = LB_TAG_CONSOLE;
 148         console->size = sizeof(*console);
 149         console->type = consoletype;
 150 }
 151 #endif
 152
 153 static void lb_console(struct lb_header *header)
 154 {
 155 #if CONFIG_CONSOLE_SERIAL8250
 156         add_console(header, LB_TAG_CONSOLE_SERIAL8250);
 157 #endif
 158 #if CONFIG_CONSOLE_SERIAL8250MEM
 159         add_console(header, LB_TAG_CONSOLE_SERIAL8250MEM);
 160 #endif
 161 #if CONFIG_CONSOLE_LOGBUF
 162         add_console(header, LB_TAG_CONSOLE_LOGBUF);
 163 #endif
 164 #if CONFIG_USBDEBUG
 165         add_console(header, LB_TAG_CONSOLE_EHCI);
 166 #endif
 167 }
 168
 169 static void lb_framebuffer(struct lb_header *header)
 170 {
 171 #if CONFIG_FRAMEBUFFER_KEEP_VESA_MODE
 172         void fill_lb_framebuffer(struct lb_framebuffer *framebuffer);
 173
 174         struct lb_framebuffer *framebuffer;
 175         framebuffer = (struct lb_framebuffer *)lb_new_record(header);
 176         framebuffer->tag = LB_TAG_FRAMEBUFFER;
 177         framebuffer->size = sizeof(*framebuffer);
 178         fill_lb_framebuffer(framebuffer);
 179 #endif
 180 }
 181
 182 #if CONFIG_COLLECT_TIMESTAMPS
 183 static void lb_tsamp(struct lb_header *header)
 184 {
 185         struct lb_tstamp *tstamp;
 186         void *tstamp_table = cbmem_find(CBMEM_ID_TIMESTAMP);
 187
 188         if (!tstamp_table)
 189                 return;
 190
 191         tstamp = (struct lb_tstamp *)lb_new_record(header);
 192         tstamp->tag = LB_TAG_TIMESTAMPS;
 193         tstamp->size = sizeof(*tstamp);
 194         tstamp->tstamp_tab = tstamp_table;
 195
 196 }
 197 #endif
 198
 199 static struct lb_mainboard *lb_mainboard(struct lb_header *header)
 200 {
 201         struct lb_record *rec;
 202         struct lb_mainboard *mainboard;
 203         rec = lb_new_record(header);
 204         mainboard = (struct lb_mainboard *)rec;
 205         mainboard->tag = LB_TAG_MAINBOARD;
 206
 207         mainboard->size = (sizeof(*mainboard) +
 208                 strlen(mainboard_vendor) + 1 +
 209                 strlen(mainboard_part_number) + 1 +
 210                 3) & ~3;
 211
 212         mainboard->vendor_idx = 0;
 213         mainboard->part_number_idx = strlen(mainboard_vendor) + 1;
 214
 215         memcpy(mainboard->strings + mainboard->vendor_idx,
 216                 mainboard_vendor,      strlen(mainboard_vendor) + 1);
 217         memcpy(mainboard->strings + mainboard->part_number_idx,
 218                 mainboard_part_number, strlen(mainboard_part_number) + 1);
 219
 220         return mainboard;
 221 }
 222
 223 #if CONFIG_USE_OPTION_TABLE
 224 static struct cmos_checksum *lb_cmos_checksum(struct lb_header *header)
 225 {
 226         struct lb_record *rec;
 227         struct cmos_checksum *cmos_checksum;
 228         rec = lb_new_record(header);
 229         cmos_checksum = (struct cmos_checksum *)rec;
 230         cmos_checksum->tag = LB_TAG_OPTION_CHECKSUM;
 231
 232         cmos_checksum->size = (sizeof(*cmos_checksum));
 233
 234         cmos_checksum->range_start = LB_CKS_RANGE_START * 8;
 235         cmos_checksum->range_end = ( LB_CKS_RANGE_END * 8 ) + 7;
 236         cmos_checksum->location = LB_CKS_LOC * 8;
 237         cmos_checksum->type = CHECKSUM_PCBIOS;
 238
 239         return cmos_checksum;
 240 }
 241 #endif
 242
 243 static void lb_strings(struct lb_header *header)
 244 {
 245         static const struct {
 246                 uint32_t tag;
 247                 const char *string;
 248         } strings[] = {
 249                 { LB_TAG_VERSION,        coreboot_version,        },
 250                 { LB_TAG_EXTRA_VERSION,  coreboot_extra_version,  },
 251                 { LB_TAG_BUILD,          coreboot_build,          },
 252                 { LB_TAG_COMPILE_TIME,   coreboot_compile_time,   },
 253                 { LB_TAG_COMPILE_BY,     coreboot_compile_by,     },
 254                 { LB_TAG_COMPILE_HOST,   coreboot_compile_host,   },
 255                 { LB_TAG_COMPILE_DOMAIN, coreboot_compile_domain, },
 256                 { LB_TAG_COMPILER,       coreboot_compiler,       },
 257                 { LB_TAG_LINKER,         coreboot_linker,         },
 258                 { LB_TAG_ASSEMBLER,      coreboot_assembler,      },
 259         };
 260         unsigned int i;
 261         for(i = 0; i < ARRAY_SIZE(strings); i++) {
 262                 struct lb_string *rec;
 263                 size_t len;
 264                 rec = (struct lb_string *)lb_new_record(header);
 265                 len = strlen(strings[i].string);
 266                 rec->tag = strings[i].tag;
 267                 rec->size = (sizeof(*rec) + len + 1 + 3) & ~3;
 268                 memcpy(rec->string, strings[i].string, len+1);
 269         }
 270
 271 }
 272
 273 #if CONFIG_WRITE_HIGH_TABLES == 1
 274 static struct lb_forward *lb_forward(struct lb_header *header, struct lb_header *next_header)
 275 {
 276         struct lb_record *rec;
 277         struct lb_forward *forward;
 278         rec = lb_new_record(header);
 279         forward = (struct lb_forward *)rec;
 280         forward->tag = LB_TAG_FORWARD;
 281         forward->size = sizeof(*forward);
 282         forward->forward = (uint64_t)(unsigned long)next_header;
 283         return forward;
 284 }
 285 #endif
 286
 287 void lb_memory_range(struct lb_memory *mem,
 288         uint32_t type, uint64_t start, uint64_t size)
 289 {
 290         int entries;
 291         entries = (mem->size - sizeof(*mem))/sizeof(mem->map[0]);
 292         mem->map[entries].start = pack_lb64(start);
 293         mem->map[entries].size = pack_lb64(size);
 294         mem->map[entries].type = type;
 295         mem->size += sizeof(mem->map[0]);
 296 }
 297
 298 static void lb_reserve_table_memory(struct lb_header *head)
 299 {
 300         struct lb_record *last_rec;
 301         struct lb_memory *mem;
 302         uint64_t start;
 303         uint64_t end;
 304         int i, entries;
 305
 306         last_rec = lb_last_record(head);
 307         mem = get_lb_mem();
 308         start = (unsigned long)head;
 309         end = (unsigned long)last_rec;
 310         entries = (mem->size - sizeof(*mem))/sizeof(mem->map[0]);
 311         /* Resize the right two memory areas so this table is in
 312          * a reserved area of memory.  Everything has been carefully
 313          * setup so that is all we need to do.
 314          */
 315         for(i = 0; i < entries; i++ ) {
 316                 uint64_t map_start = unpack_lb64(mem->map[i].start);
 317                 uint64_t map_end = map_start + unpack_lb64(mem->map[i].size);
 318                 /* Does this area need to be expanded? */
 319                 if (map_end == start) {
 320                         mem->map[i].size = pack_lb64(end - map_start);
 321                 }
 322                 /* Does this area need to be contracted? */
 323                 else if (map_start == start) {
 324                         mem->map[i].start = pack_lb64(end);
 325                         mem->map[i].size = pack_lb64(map_end - end);
 326                 }
 327         }
 328 }
 329
 330 static unsigned long lb_table_fini(struct lb_header *head, int fixup)
 331 {
 332         struct lb_record *rec, *first_rec;
 333         rec = lb_last_record(head);
 334         if (head->table_entries) {
 335                 head->table_bytes += rec->size;
 336         }
 337
 338         if (fixup)
 339                 lb_reserve_table_memory(head);
 340
 341         first_rec = lb_first_record(head);
 342         head->table_checksum = compute_ip_checksum(first_rec, head->table_bytes);
 343         head->header_checksum = 0;
 344         head->header_checksum = compute_ip_checksum(head, sizeof(*head));
 345         printk(BIOS_DEBUG,
 346                "Wrote coreboot table at: %p, 0x%x bytes, checksum %x\n",
 347                head, head->table_bytes, head->table_checksum);
 348         return (unsigned long)rec + rec->size;
 349 }
 350
 351 static void lb_cleanup_memory_ranges(struct lb_memory *mem)
 352 {
 353         int entries;
 354         int i, j;
 355         entries = (mem->size - sizeof(*mem))/sizeof(mem->map[0]);
 356
 357         /* Sort the lb memory ranges */
 358         for(i = 0; i < entries; i++) {
 359                 uint64_t entry_start = unpack_lb64(mem->map[i].start);
 360                 for(j = i; j < entries; j++) {
 361                         uint64_t temp_start = unpack_lb64(mem->map[j].start);
 362                         if (temp_start < entry_start) {
 363                                 struct lb_memory_range tmp;
 364                                 tmp = mem->map[i];
 365                                 mem->map[i] = mem->map[j];
 366                                 mem->map[j] = tmp;
 367                         }
 368                 }
 369         }
 370
 371         /* Merge adjacent entries */
 372         for(i = 0; (i + 1) < entries; i++) {
 373                 uint64_t start, end, nstart, nend;
 374                 if (mem->map[i].type != mem->map[i + 1].type) {
 375                         continue;
 376                 }
 377                 start  = unpack_lb64(mem->map[i].start);
 378                 end    = start + unpack_lb64(mem->map[i].size);
 379                 nstart = unpack_lb64(mem->map[i + 1].start);
 380                 nend   = nstart + unpack_lb64(mem->map[i + 1].size);
 381                 if ((start <= nstart) && (end > nstart)) {
 382                         if (start > nstart) {
 383                                 start = nstart;
 384                         }
 385                         if (end < nend) {
 386                                 end = nend;
 387                         }
 388                         /* Record the new region size */
 389                         mem->map[i].start = pack_lb64(start);
 390                         mem->map[i].size  = pack_lb64(end - start);
 391
 392                         /* Delete the entry I have merged with */
 393                         memmove(&mem->map[i + 1], &mem->map[i + 2],
 394                                 ((entries - i - 2) * sizeof(mem->map[0])));
 395                         mem->size -= sizeof(mem->map[0]);
 396                         entries -= 1;
 397                         /* See if I can merge with the next entry as well */
 398                         i -= 1;
 399                 }
 400         }
 401 }
 402
 403 static void lb_remove_memory_range(struct lb_memory *mem,
 404         uint64_t start, uint64_t size)
 405 {
 406         uint64_t end;
 407         int entries;
 408         int i;
 409
 410         end = start + size;
 411         entries = (mem->size - sizeof(*mem))/sizeof(mem->map[0]);
 412
 413         /* Remove a reserved area from the memory map */
 414         for(i = 0; i < entries; i++) {
 415                 uint64_t map_start = unpack_lb64(mem->map[i].start);
 416                 uint64_t map_end   = map_start + unpack_lb64(mem->map[i].size);
 417                 if ((start <= map_start) && (end >= map_end)) {
 418                         /* Remove the completely covered range */
 419                         memmove(&mem->map[i], &mem->map[i + 1],
 420                                 ((entries - i - 1) * sizeof(mem->map[0])));
 421                         mem->size -= sizeof(mem->map[0]);
 422                         entries -= 1;
 423                         /* Since the index will disappear revisit what will appear here */
 424                         i -= 1;
 425                 }
 426                 else if ((start > map_start) && (end < map_end)) {
 427                         /* Split the memory range */
 428                         memmove(&mem->map[i + 1], &mem->map[i],
 429                                 ((entries - i) * sizeof(mem->map[0])));
 430                         mem->size += sizeof(mem->map[0]);
 431                         entries += 1;
 432                         /* Update the first map entry */
 433                         mem->map[i].size = pack_lb64(start - map_start);
 434                         /* Update the second map entry */
 435                         mem->map[i + 1].start = pack_lb64(end);
 436                         mem->map[i + 1].size  = pack_lb64(map_end - end);
 437                         /* Don't bother with this map entry again */
 438                         i += 1;
 439                 }
 440                 else if ((start <= map_start) && (end > map_start)) {
 441                         /* Shrink the start of the memory range */
 442                         mem->map[i].start = pack_lb64(end);
 443                         mem->map[i].size  = pack_lb64(map_end - end);
 444                 }
 445                 else if ((start < map_end) && (start > map_start)) {
 446                         /* Shrink the end of the memory range */
 447                         mem->map[i].size = pack_lb64(start - map_start);
 448                 }
 449         }
 450 }
 451
 452 /* This function is used in mainboard specific code, too */
 453 void lb_add_memory_range(struct lb_memory *mem,
 454         uint32_t type, uint64_t start, uint64_t size)
 455 {
 456         lb_remove_memory_range(mem, start, size);
 457         lb_memory_range(mem, type, start, size);
 458         lb_cleanup_memory_ranges(mem);
 459 }
 460
 461 static void lb_dump_memory_ranges(struct lb_memory *mem)
 462 {
 463         int entries;
 464         int i;
 465         entries = (mem->size - sizeof(*mem))/sizeof(mem->map[0]);
 466
 467         printk(BIOS_DEBUG, "coreboot memory table:\n");
 468         for(i = 0; i < entries; i++) {
 469                 uint64_t entry_start = unpack_lb64(mem->map[i].start);
 470                 uint64_t entry_size = unpack_lb64(mem->map[i].size);
 471                 const char *entry_type;
 472
 473                 switch (mem->map[i].type) {
 474                 case LB_MEM_RAM: entry_type="RAM"; break;
 475                 case LB_MEM_RESERVED: entry_type="RESERVED"; break;
 476                 case LB_MEM_ACPI: entry_type="ACPI"; break;
 477                 case LB_MEM_NVS: entry_type="NVS"; break;
 478                 case LB_MEM_UNUSABLE: entry_type="UNUSABLE"; break;
 479                 case LB_MEM_VENDOR_RSVD: entry_type="VENDOR RESERVED"; break;
 480                 case LB_MEM_TABLE: entry_type="CONFIGURATION TABLES"; break;
 481                 default: entry_type="UNKNOWN!"; break;
 482                 }
 483
 484                 printk(BIOS_DEBUG, "%2d. %016llx-%016llx: %s\n",
 485                         i, entry_start, entry_start+entry_size-1, entry_type);
 486
 487         }
 488 }
 489
 490
 491 /* Routines to extract part so the coreboot table or
 492  * information from the coreboot table after we have written it.
 493  * Currently get_lb_mem relies on a global we can change the
 494  * implementaiton.
 495  */
 496 static struct lb_memory *mem_ranges = 0;
 497 struct lb_memory *get_lb_mem(void)
 498 {
 499         return mem_ranges;
 500 }
 501
 502 static void build_lb_mem_range(void *gp, struct device *dev, struct resource *res)
 503 {
 504         struct lb_memory *mem = gp;
 505         lb_memory_range(mem, LB_MEM_RAM, res->base, res->size);
 506 }
 507
 508 static struct lb_memory *build_lb_mem(struct lb_header *head)
 509 {
 510         struct lb_memory *mem;
 511
 512         /* Record where the lb memory ranges will live */
 513         mem = lb_memory(head);
 514         mem_ranges = mem;
 515
 516         /* Build the raw table of memory */
 517         search_global_resources(
 518                 IORESOURCE_MEM | IORESOURCE_CACHEABLE, IORESOURCE_MEM | IORESOURCE_CACHEABLE,
 519                 build_lb_mem_range, mem);
 520         lb_cleanup_memory_ranges(mem);
 521         return mem;
 522 }
 523
 524 static void lb_add_rsvd_range(void *gp, struct device *dev, struct resource *res)
 525 {
 526         struct lb_memory *mem = gp;
 527         lb_add_memory_range(mem, LB_MEM_RESERVED, res->base, res->size);
 528 }
 529
 530 static void add_lb_reserved(struct lb_memory *mem)
 531 {
 532         /* Add reserved ranges */
 533         search_global_resources(
 534                 IORESOURCE_MEM | IORESOURCE_RESERVE, IORESOURCE_MEM | IORESOURCE_RESERVE,
 535                 lb_add_rsvd_range, mem);
 536 }
 537
 538 unsigned long write_coreboot_table(
 539         unsigned long low_table_start, unsigned long low_table_end,
 540         unsigned long rom_table_start, unsigned long rom_table_end)
 541 {
 542         struct lb_header *head;
 543         struct lb_memory *mem;
 544
 545 #if CONFIG_WRITE_HIGH_TABLES
 546         printk(BIOS_DEBUG, "Writing high table forward entry at 0x%08lx\n",
 547                         low_table_end);
 548         head = lb_table_init(low_table_end);
 549         lb_forward(head, (struct lb_header*)rom_table_end);
 550
 551         low_table_end = (unsigned long) lb_table_fini(head, 0);
 552         printk(BIOS_DEBUG, "New low_table_end: 0x%08lx\n", low_table_end);
 553         printk(BIOS_DEBUG, "Now going to write high coreboot table at 0x%08lx\n",
 554                         rom_table_end);
 555
 556         head = lb_table_init(rom_table_end);
 557         rom_table_end = (unsigned long)head;
 558         printk(BIOS_DEBUG, "rom_table_end = 0x%08lx\n", rom_table_end);
 559 #else
 560         if(low_table_end > (0x1000 - sizeof(struct lb_header))) { /* after 4K */
 561                 /* We need to put lbtable on  to [0xf0000,0x100000) */
 562                 head = lb_table_init(rom_table_end);
 563                 rom_table_end = (unsigned long)head;
 564         } else {
 565                 head = lb_table_init(low_table_end);
 566                 low_table_end = (unsigned long)head;
 567         }
 568 #endif
 569
 570         printk(BIOS_DEBUG, "Adjust low_table_end from 0x%08lx to ", low_table_end);
 571         low_table_end += 0xfff; // 4K aligned
 572         low_table_end &= ~0xfff;
 573         printk(BIOS_DEBUG, "0x%08lx \n", low_table_end);
 574
 575         /* The Linux kernel assumes this region is reserved */
 576         printk(BIOS_DEBUG, "Adjust rom_table_end from 0x%08lx to ", rom_table_end);
 577         rom_table_end += 0xffff; // 64K align
 578         rom_table_end &= ~0xffff;
 579         printk(BIOS_DEBUG, "0x%08lx \n", rom_table_end);
 580
 581 #if CONFIG_USE_OPTION_TABLE
 582         {
 583                 struct cmos_option_table *option_table = cbfs_find_file("cmos_layout.bin", 0x1aa);
 584                 if (option_table) {
 585                         struct lb_record *rec_dest = lb_new_record(head);
 586                         /* Copy the option config table, it's already a lb_record... */
 587                         memcpy(rec_dest,  option_table, option_table->size);
 588                         /* Create cmos checksum entry in coreboot table */
 589                         lb_cmos_checksum(head);
 590                 } else {
 591                         printk(BIOS_ERR, "cmos_layout.bin could not be found!\n");
 592                 }
 593         }
 594 #endif
 595         /* Record where RAM is located */
 596         mem = build_lb_mem(head);
 597
 598         /* Record the mptable and the the lb_table (This will be adjusted later) */
 599         lb_add_memory_range(mem, LB_MEM_TABLE,
 600                 low_table_start, low_table_end - low_table_start);
 601
 602         /* Record the pirq table, acpi tables, and maybe the mptable */
 603         lb_add_memory_range(mem, LB_MEM_TABLE,
 604                 rom_table_start, rom_table_end-rom_table_start);
 605
 606 #if CONFIG_WRITE_HIGH_TABLES
 607         printk(BIOS_DEBUG, "Adding high table area\n");
 608         // should this be LB_MEM_ACPI?
 609         lb_add_memory_range(mem, LB_MEM_TABLE,
 610                 high_tables_base, high_tables_size);
 611 #endif
 612
 613         /* Add reserved regions */
 614         add_lb_reserved(mem);
 615
 616 #if CONFIG_HAVE_MAINBOARD_RESOURCES
 617         add_mainboard_resources(mem);
 618 #endif
 619
 620         lb_dump_memory_ranges(mem);
 621
 622         /* Note:
 623          * I assume that there is always memory at immediately after
 624          * the low_table_end.  This means that after I setup the coreboot table.
 625          * I can trivially fixup the reserved memory ranges to hold the correct
 626          * size of the coreboot table.
 627          */
 628
 629         /* Record our motherboard */
 630         lb_mainboard(head);
 631         /* Record the serial port, if present */
 632         lb_serial(head);
 633         /* Record our console setup */
 634         lb_console(head);
 635         /* Record our various random string information */
 636         lb_strings(head);
 637         /* Record our framebuffer */
 638         lb_framebuffer(head);
 639
 640 #if CONFIG_COLLECT_TIMESTAMPS
 641         lb_tsamp(head);
 642 #endif
 643         /* Remember where my valid memory ranges are */
 644         return lb_table_fini(head, 1);
 645
 646 }