4af50edb9212e44d2002294c8374dcbc0ea5f429
[akaros.git] / user / vmm / 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 <console/uart.h>
25 #include <ip_checksum.h>
26 #include <boot/coreboot_tables.h>
27 #include <string.h>
28 #include <version.h>
29 #include <boardid.h>
30 #include <device/device.h>
31 #include <stdlib.h>
32 #include <cbfs.h>
33 #include <cbmem.h>
34 #include <bootmem.h>
35 #include <spi_flash.h>
36 #if CONFIG_CHROMEOS
37 #if CONFIG_HAVE_ACPI_TABLES
38 #include <arch/acpi.h>
39 #endif
40 #include <vendorcode/google/chromeos/chromeos.h>
41 #include <vendorcode/google/chromeos/gnvs.h>
42 #endif
43 #if CONFIG_ARCH_X86
44 #include <cpu/x86/mtrr.h>
45 #endif
46
47 static struct lb_header *lb_table_init(unsigned long addr)
48 {
49         struct lb_header *header;
50
51         /* 16 byte align the address */
52         addr += 15;
53         addr &= ~15;
54
55         header = (void *)addr;
56         header->signature[0] = 'L';
57         header->signature[1] = 'B';
58         header->signature[2] = 'I';
59         header->signature[3] = 'O';
60         header->header_bytes = sizeof(*header);
61         header->header_checksum = 0;
62         header->table_bytes = 0;
63         header->table_checksum = 0;
64         header->table_entries = 0;
65         return header;
66 }
67
68 static struct lb_record *lb_first_record(struct lb_header *header)
69 {
70         struct lb_record *rec;
71         rec = (void *)(((char *)header) + sizeof(*header));
72         return rec;
73 }
74
75 static struct lb_record *lb_last_record(struct lb_header *header)
76 {
77         struct lb_record *rec;
78         rec = (void *)(((char *)header) + sizeof(*header) + header->table_bytes);
79         return rec;
80 }
81
82 struct lb_record *lb_new_record(struct lb_header *header)
83 {
84         struct lb_record *rec;
85         rec = lb_last_record(header);
86         if (header->table_entries) {
87                 header->table_bytes += rec->size;
88         }
89         rec = lb_last_record(header);
90         header->table_entries++;
91         rec->tag = LB_TAG_UNUSED;
92         rec->size = sizeof(*rec);
93         return rec;
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 void lb_add_serial(struct lb_serial *new_serial, void *data)
108 {
109         struct lb_header *header = (struct lb_header *)data;
110         struct lb_serial *serial;
111
112         serial = (struct lb_serial *)lb_new_record(header);
113         serial->tag = LB_TAG_SERIAL;
114         serial->size = sizeof(*serial);
115         serial->type = new_serial->type;
116         serial->baseaddr = new_serial->baseaddr;
117         serial->baud = new_serial->baud;
118         serial->regwidth = new_serial->regwidth;
119 }
120
121 void lb_add_console(uint16_t consoletype, void *data)
122 {
123         struct lb_header *header = (struct lb_header *)data;
124         struct lb_console *console;
125
126         console = (struct lb_console *)lb_new_record(header);
127         console->tag = LB_TAG_CONSOLE;
128         console->size = sizeof(*console);
129         console->type = consoletype;
130 }
131
132 static void lb_framebuffer(struct lb_header *header)
133 {
134 #if CONFIG_FRAMEBUFFER_KEEP_VESA_MODE || CONFIG_MAINBOARD_DO_NATIVE_VGA_INIT
135         void fill_lb_framebuffer(struct lb_framebuffer *framebuffer);
136         int vbe_mode_info_valid(void);
137
138         // If there isn't any mode info to put in the table, don't ask for it
139         // to be filled with junk.
140         if (!vbe_mode_info_valid())
141                 return;
142         struct lb_framebuffer *framebuffer;
143         framebuffer = (struct lb_framebuffer *)lb_new_record(header);
144         fill_lb_framebuffer(framebuffer);
145         framebuffer->tag = LB_TAG_FRAMEBUFFER;
146         framebuffer->size = sizeof(*framebuffer);
147 #endif
148 }
149
150 void fill_lb_gpio(struct lb_gpio *gpio, int num,
151                          int polarity, const char *name, int value)
152 {
153         memset(gpio, 0, sizeof(*gpio));
154         gpio->port = num;
155         gpio->polarity = polarity;
156         if (value >= 0)
157                 gpio->value = value;
158         strncpy((char *)gpio->name, name, GPIO_MAX_NAME_LENGTH);
159 }
160
161 #if CONFIG_CHROMEOS
162 static void lb_gpios(struct lb_header *header)
163 {
164         struct lb_gpios *gpios;
165
166         gpios = (struct lb_gpios *)lb_new_record(header);
167         gpios->tag = LB_TAG_GPIO;
168         gpios->size = sizeof(*gpios);
169         gpios->count = 0;
170         fill_lb_gpios(gpios);
171 }
172
173 static void lb_vdat(struct lb_header *header)
174 {
175 #if CONFIG_HAVE_ACPI_TABLES
176         struct lb_range *vdat;
177
178         vdat = (struct lb_range *)lb_new_record(header);
179         vdat->tag = LB_TAG_VDAT;
180         vdat->size = sizeof(*vdat);
181         acpi_get_vdat_info(&vdat->range_start, &vdat->range_size);
182 #endif
183 }
184
185 static void lb_vbnv(struct lb_header *header)
186 {
187 #if CONFIG_PC80_SYSTEM
188         struct lb_range *vbnv;
189
190         vbnv = (struct lb_range *)lb_new_record(header);
191         vbnv->tag = LB_TAG_VBNV;
192         vbnv->size = sizeof(*vbnv);
193         vbnv->range_start = CONFIG_VBNV_OFFSET + 14;
194         vbnv->range_size = CONFIG_VBNV_SIZE;
195 #endif
196 }
197
198 #if CONFIG_VBOOT_VERIFY_FIRMWARE
199 static void lb_vboot_handoff(struct lb_header *header)
200 {
201         void *addr;
202         uint32_t size;
203         struct lb_range *vbho;
204
205         if (vboot_get_handoff_info(&addr, &size))
206                 return;
207
208         vbho = (struct lb_range *)lb_new_record(header);
209         vbho->tag = LB_TAB_VBOOT_HANDOFF;
210         vbho->size = sizeof(*vbho);
211         vbho->range_start = (intptr_t)addr;
212         vbho->range_size = size;
213 }
214 #else
215 static inline void lb_vboot_handoff(struct lb_header *header) {}
216 #endif /* CONFIG_VBOOT_VERIFY_FIRMWARE */
217 #endif /* CONFIG_CHROMEOS */
218
219 static void lb_board_id(struct lb_header *header)
220 {
221 #if CONFIG_BOARD_ID_AUTO || CONFIG_BOARD_ID_MANUAL
222         struct lb_board_id  *bid;
223
224         bid = (struct lb_board_id *)lb_new_record(header);
225
226         bid->tag = LB_TAG_BOARD_ID;
227         bid->size = sizeof(*bid);
228         bid->board_id = board_id();
229 #endif
230 }
231
232 static void lb_ram_code(struct lb_header *header)
233 {
234 #if IS_ENABLED(CONFIG_RAM_CODE_SUPPORT)
235         struct lb_ram_code *code;
236
237         code = (struct lb_ram_code *)lb_new_record(header);
238
239         code->tag = LB_TAG_RAM_CODE;
240         code->size = sizeof(*code);
241         code->ram_code = ram_code();
242 #endif
243 }
244
245 static void add_cbmem_pointers(struct lb_header *header)
246 {
247         /*
248          * These CBMEM sections' addresses are included in the coreboot table
249          * with the appropriate tags.
250          */
251         const struct section_id {
252                 int cbmem_id;
253                 int table_tag;
254         } section_ids[] = {
255                 {CBMEM_ID_TIMESTAMP, LB_TAG_TIMESTAMPS},
256                 {CBMEM_ID_CONSOLE, LB_TAG_CBMEM_CONSOLE},
257                 {CBMEM_ID_ACPI_GNVS, LB_TAG_ACPI_GNVS},
258                 {CBMEM_ID_WIFI_CALIBRATION, LB_TAG_WIFI_CALIBRATION}
259         };
260         int i;
261
262         for (i = 0; i < ARRAY_SIZE(section_ids); i++) {
263                 const struct section_id *sid = section_ids + i;
264                 struct lb_cbmem_ref *cbmem_ref;
265                 void *cbmem_addr = cbmem_find(sid->cbmem_id);
266
267                 if (!cbmem_addr)
268                         continue;  /* This section is not present */
269
270                 cbmem_ref = (struct lb_cbmem_ref *)lb_new_record(header);
271                 if (!cbmem_ref) {
272                         printk(BIOS_ERR, "No more room in coreboot table!\n");
273                         break;
274                 }
275                 cbmem_ref->tag = sid->table_tag;
276                 cbmem_ref->size = sizeof(*cbmem_ref);
277                 cbmem_ref->cbmem_addr = (unsigned long)cbmem_addr;
278         }
279 }
280
281 static struct lb_mainboard *lb_mainboard(struct lb_header *header)
282 {
283         struct lb_record *rec;
284         struct lb_mainboard *mainboard;
285         rec = lb_new_record(header);
286         mainboard = (struct lb_mainboard *)rec;
287         mainboard->tag = LB_TAG_MAINBOARD;
288
289         mainboard->size = (sizeof(*mainboard) +
290                 strlen(mainboard_vendor) + 1 +
291                 strlen(mainboard_part_number) + 1 +
292                 3) & ~3;
293
294         mainboard->vendor_idx = 0;
295         mainboard->part_number_idx = strlen(mainboard_vendor) + 1;
296
297         memcpy(mainboard->strings + mainboard->vendor_idx,
298                 mainboard_vendor,      strlen(mainboard_vendor) + 1);
299         memcpy(mainboard->strings + mainboard->part_number_idx,
300                 mainboard_part_number, strlen(mainboard_part_number) + 1);
301
302         return mainboard;
303 }
304
305 static void lb_strings(struct lb_header *header)
306 {
307         static const struct {
308                 uint32_t tag;
309                 const char *string;
310         } strings[] = {
311                 { LB_TAG_VERSION,        coreboot_version,        },
312                 { LB_TAG_EXTRA_VERSION,  coreboot_extra_version,  },
313                 { LB_TAG_BUILD,          coreboot_build,          },
314                 { LB_TAG_COMPILE_TIME,   coreboot_compile_time,   },
315         };
316         unsigned int i;
317         for(i = 0; i < ARRAY_SIZE(strings); i++) {
318                 struct lb_string *rec;
319                 size_t len;
320                 rec = (struct lb_string *)lb_new_record(header);
321                 len = strlen(strings[i].string);
322                 rec->tag = strings[i].tag;
323                 rec->size = (sizeof(*rec) + len + 1 + 3) & ~3;
324                 memcpy(rec->string, strings[i].string, len+1);
325         }
326
327 }
328
329 static void lb_record_version_timestamp(struct lb_header *header)
330 {
331         struct lb_timestamp *rec;
332         rec = (struct lb_timestamp *)lb_new_record(header);
333         rec->tag = LB_TAG_VERSION_TIMESTAMP;
334         rec->size = sizeof(*rec);
335         rec->timestamp = coreboot_version_timestamp;
336 }
337
338 void __attribute__((weak)) lb_board(struct lb_header *header) { /* NOOP */ }
339
340 static struct lb_forward *lb_forward(struct lb_header *header, struct lb_header *next_header)
341 {
342         struct lb_record *rec;
343         struct lb_forward *forward;
344         rec = lb_new_record(header);
345         forward = (struct lb_forward *)rec;
346         forward->tag = LB_TAG_FORWARD;
347         forward->size = sizeof(*forward);
348         forward->forward = (uint64_t)(unsigned long)next_header;
349         return forward;
350 }
351
352 static unsigned long lb_table_fini(struct lb_header *head)
353 {
354         struct lb_record *rec, *first_rec;
355         rec = lb_last_record(head);
356         if (head->table_entries) {
357                 head->table_bytes += rec->size;
358         }
359
360         first_rec = lb_first_record(head);
361         head->table_checksum = compute_ip_checksum(first_rec, head->table_bytes);
362         head->header_checksum = 0;
363         head->header_checksum = compute_ip_checksum(head, sizeof(*head));
364         printk(BIOS_DEBUG,
365                "Wrote coreboot table at: %p, 0x%x bytes, checksum %x\n",
366                head, head->table_bytes, head->table_checksum);
367         return (unsigned long)rec + rec->size;
368 }
369
370 unsigned long write_coreboot_table(
371         unsigned long low_table_start, unsigned long low_table_end,
372         unsigned long rom_table_start, unsigned long rom_table_end)
373 {
374         struct lb_header *head;
375
376         if (low_table_start || low_table_end) {
377                 printk(BIOS_DEBUG, "Writing table forward entry at 0x%08lx\n",
378                                 low_table_end);
379                 head = lb_table_init(low_table_end);
380                 lb_forward(head, (struct lb_header*)rom_table_end);
381
382                 low_table_end = (unsigned long) lb_table_fini(head);
383                 printk(BIOS_DEBUG, "Table forward entry ends at 0x%08lx.\n",
384                         low_table_end);
385                 low_table_end = ALIGN(low_table_end, 4096);
386                 printk(BIOS_DEBUG, "... aligned to 0x%08lx\n", low_table_end);
387         }
388
389         printk(BIOS_DEBUG, "Writing coreboot table at 0x%08lx\n",
390                 rom_table_end);
391
392         head = lb_table_init(rom_table_end);
393         rom_table_end = (unsigned long)head;
394         printk(BIOS_DEBUG, "rom_table_end = 0x%08lx\n", rom_table_end);
395         rom_table_end = ALIGN(rom_table_end, (64 * 1024));
396         printk(BIOS_DEBUG, "... aligned to 0x%08lx\n", rom_table_end);
397
398 #if CONFIG_USE_OPTION_TABLE
399         {
400                 struct cmos_option_table *option_table = cbfs_get_file_content(
401                                 CBFS_DEFAULT_MEDIA, "cmos_layout.bin",
402                                 CBFS_COMPONENT_CMOS_LAYOUT, NULL);
403                 if (option_table) {
404                         struct lb_record *rec_dest = lb_new_record(head);
405                         /* Copy the option config table, it's already a lb_record... */
406                         memcpy(rec_dest,  option_table, option_table->size);
407                 } else {
408                         printk(BIOS_ERR, "cmos_layout.bin could not be found!\n");
409                 }
410         }
411 #endif
412
413         /* Initialize the memory map at boot time. */
414         bootmem_init();
415
416         if (low_table_start || low_table_end) {
417                 uint64_t size = low_table_end - low_table_start;
418                 /* Record the mptable and the the lb_table.
419                  * (This will be adjusted later)  */
420                 bootmem_add_range(low_table_start, size, LB_MEM_TABLE);
421         }
422
423         /* Record the pirq table, acpi tables, and maybe the mptable. However,
424          * these only need to be added when the rom_table is sitting below
425          * 1MiB. If it isn't that means high tables are being written.
426          * The code below handles high tables correctly. */
427         if (rom_table_end <= (1 << 20)) {
428                 uint64_t size = rom_table_end - rom_table_start;
429                 bootmem_add_range(rom_table_start, size, LB_MEM_TABLE);
430         }
431
432         /* No other memory areas can be added after the memory table has been
433          * committed as the entries won't show up in the serialize mem table. */
434         bootmem_write_memory_table(lb_memory(head));
435
436         /* Record our motherboard */
437         lb_mainboard(head);
438
439         /* Record the serial ports and consoles */
440 #if CONFIG_CONSOLE_SERIAL
441         uart_fill_lb(head);
442 #endif
443 #if CONFIG_CONSOLE_USB
444         lb_add_console(LB_TAG_CONSOLE_EHCI, head);
445 #endif
446
447         /* Record our various random string information */
448         lb_strings(head);
449         lb_record_version_timestamp(head);
450         /* Record our framebuffer */
451         lb_framebuffer(head);
452
453 #if CONFIG_CHROMEOS
454         /* Record our GPIO settings (ChromeOS specific) */
455         lb_gpios(head);
456
457         /* pass along the VDAT buffer address */
458         lb_vdat(head);
459
460         /* pass along VBNV offsets in CMOS */
461         lb_vbnv(head);
462
463         /* pass along the vboot_handoff address. */
464         lb_vboot_handoff(head);
465 #endif
466
467         /* Add board ID if available */
468         lb_board_id(head);
469
470         /* Add RAM config if available */
471         lb_ram_code(head);
472
473 #if IS_ENABLED(CONFIG_SPI_FLASH)
474         /* Add SPI flash description if available */
475         lb_spi_flash(head);
476 #endif
477
478         add_cbmem_pointers(head);
479
480         /* Add board-specific table entries, if any. */
481         lb_board(head);
482
483 #if IS_ENABLED(CONFIG_CHROMEOS_RAMOOPS)
484         lb_ramoops(head);
485 #endif
486
487         /* Remember where my valid memory ranges are */
488         return lb_table_fini(head);
489 }