blob: c2ae0949ed158920d218a1c5ac0665459055f41b [file] [log] [blame]
Stefan Reinauerb883d4c2009-08-27 11:23:06 +00001/*
2 * This file is part of the coreboot project.
Stefan Reinauer14e22772010-04-27 06:56:47 +00003 *
Stefan Reinauerb883d4c2009-08-27 11:23:06 +00004 * Copyright (C) 2003-2004 Eric Biederman
Stefan Reinauerb5828d72010-03-29 17:14:28 +00005 * Copyright (C) 2005-2010 coresystems GmbH
Stefan Reinauerb883d4c2009-08-27 11:23:06 +00006 *
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.
Stefan Reinauerb883d4c2009-08-27 11:23:06 +000016 */
17
Aaron Durbina6e90512016-04-21 14:06:17 -050018#include <arch/cbconfig.h>
Eric Biederman8ca8d762003-04-22 19:02:15 +000019#include <console/console.h>
Kyösti Mälkki1d7541f2014-02-17 21:34:42 +020020#include <console/uart.h>
Eric Biederman8ca8d762003-04-22 19:02:15 +000021#include <ip_checksum.h>
Stefan Reinauerca374d42008-01-18 16:16:45 +000022#include <boot/coreboot_tables.h>
Aaron Durbin5481c962016-04-19 20:37:51 -050023#include <boot/tables.h>
Patrick Georgifb5d5b12015-07-14 17:15:51 +010024#include <boot_device.h>
Eric Biederman8ca8d762003-04-22 19:02:15 +000025#include <string.h>
26#include <version.h>
Vadim Bendeburyb0c302f2014-07-28 16:03:07 -070027#include <boardid.h>
Eric Biedermanb78c1972004-10-14 20:54:17 +000028#include <device/device.h>
Patrick Georgifb5d5b12015-07-14 17:15:51 +010029#include <fmap.h>
Eric Biedermanb78c1972004-10-14 20:54:17 +000030#include <stdlib.h>
Duncan Laurie66ecdc52011-08-15 16:35:10 -070031#include <cbfs.h>
Vadim Bendebury2e438672011-09-23 09:56:11 -070032#include <cbmem.h>
Aaron Durbin49048022014-02-18 21:55:02 -060033#include <bootmem.h>
Dan Ehrenberga5aac762015-01-08 10:29:19 -080034#include <spi_flash.h>
Philipp Deppenwiesefea24292017-10-17 17:02:29 +020035#include <security/vboot/vbnv_layout.h>
Martin Roth1bf55b42017-06-24 14:16:38 -060036#if IS_ENABLED(CONFIG_USE_OPTION_TABLE)
Nico Huber08599912015-09-21 20:11:47 +020037#include <option_table.h>
38#endif
Martin Roth1bf55b42017-06-24 14:16:38 -060039#if IS_ENABLED(CONFIG_CHROMEOS)
40#if IS_ENABLED(CONFIG_HAVE_ACPI_TABLES)
Stefan Reinauer0e672b52012-04-27 00:34:54 +020041#include <arch/acpi.h>
Stefan Reinauer3e4e3032013-03-20 14:08:04 -070042#endif
Aaron Durbindd32a312013-03-07 23:15:06 -060043#include <vendorcode/google/chromeos/chromeos.h>
Stefan Reinauer0e672b52012-04-27 00:34:54 +020044#include <vendorcode/google/chromeos/gnvs.h>
45#endif
Eric Biederman8ca8d762003-04-22 19:02:15 +000046
Stefan Reinauerb883d4c2009-08-27 11:23:06 +000047static struct lb_header *lb_table_init(unsigned long addr)
Eric Biederman8ca8d762003-04-22 19:02:15 +000048{
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
Stefan Reinauerb883d4c2009-08-27 11:23:06 +000068static struct lb_record *lb_first_record(struct lb_header *header)
Eric Biederman8ca8d762003-04-22 19:02:15 +000069{
70 struct lb_record *rec;
71 rec = (void *)(((char *)header) + sizeof(*header));
72 return rec;
73}
74
Stefan Reinauerb883d4c2009-08-27 11:23:06 +000075static struct lb_record *lb_last_record(struct lb_header *header)
Eric Biederman8ca8d762003-04-22 19:02:15 +000076{
77 struct lb_record *rec;
Lee Leahy73402172017-03-10 15:23:24 -080078 rec = (void *)(((char *)header) + sizeof(*header)
79 + header->table_bytes);
Eric Biederman8ca8d762003-04-22 19:02:15 +000080 return rec;
81}
82
Julius Wernerb8fad3d2013-08-27 15:48:32 -070083struct lb_record *lb_new_record(struct lb_header *header)
Eric Biederman8ca8d762003-04-22 19:02:15 +000084{
85 struct lb_record *rec;
86 rec = lb_last_record(header);
Lee Leahy2f919ec2017-03-08 17:37:06 -080087 if (header->table_entries)
Eric Biederman8ca8d762003-04-22 19:02:15 +000088 header->table_bytes += rec->size;
Eric Biederman8ca8d762003-04-22 19:02:15 +000089 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
Stefan Reinauerb883d4c2009-08-27 11:23:06 +000096static struct lb_memory *lb_memory(struct lb_header *header)
Eric Biederman8ca8d762003-04-22 19:02:15 +000097{
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
Kyösti Mälkkibbf6f3d2014-03-15 01:32:55 +0200107void lb_add_serial(struct lb_serial *new_serial, void *data)
Patrick Georgi8c2a0c12008-01-25 18:28:18 +0000108{
Kyösti Mälkkibbf6f3d2014-03-15 01:32:55 +0200109 struct lb_header *header = (struct lb_header *)data;
Patrick Georgi8c2a0c12008-01-25 18:28:18 +0000110 struct lb_serial *serial;
Kyösti Mälkkibbf6f3d2014-03-15 01:32:55 +0200111
112 serial = (struct lb_serial *)lb_new_record(header);
Patrick Georgi8c2a0c12008-01-25 18:28:18 +0000113 serial->tag = LB_TAG_SERIAL;
114 serial->size = sizeof(*serial);
Kyösti Mälkkibbf6f3d2014-03-15 01:32:55 +0200115 serial->type = new_serial->type;
116 serial->baseaddr = new_serial->baseaddr;
117 serial->baud = new_serial->baud;
Vadim Bendebury9dccf1c2015-01-09 16:54:19 -0800118 serial->regwidth = new_serial->regwidth;
Lee Leahyf92a98c2016-05-04 11:59:19 -0700119 serial->input_hertz = new_serial->input_hertz;
120 serial->uart_pci_addr = new_serial->uart_pci_addr;
Patrick Georgi8c2a0c12008-01-25 18:28:18 +0000121}
122
Kyösti Mälkkibbf6f3d2014-03-15 01:32:55 +0200123void lb_add_console(uint16_t consoletype, void *data)
Patrick Georgi3bbf2ff2008-01-27 14:12:54 +0000124{
Kyösti Mälkkibbf6f3d2014-03-15 01:32:55 +0200125 struct lb_header *header = (struct lb_header *)data;
Patrick Georgi3bbf2ff2008-01-27 14:12:54 +0000126 struct lb_console *console;
Patrick Georgi16cdbb22009-04-21 20:14:31 +0000127
Patrick Georgi3bbf2ff2008-01-27 14:12:54 +0000128 console = (struct lb_console *)lb_new_record(header);
129 console->tag = LB_TAG_CONSOLE;
130 console->size = sizeof(*console);
131 console->type = consoletype;
132}
Patrick Georgi3bbf2ff2008-01-27 14:12:54 +0000133
Aaron Durbinbdb5c8f2017-05-16 21:39:50 -0500134static void lb_framebuffer(struct lb_header *header)
135{
Stefan Reinauerd650e992010-02-22 04:33:13 +0000136 struct lb_framebuffer *framebuffer;
Duncan Laurie13bc5e52017-06-26 01:50:14 -0700137 struct lb_framebuffer fb = {0};
Aaron Durbinbdb5c8f2017-05-16 21:39:50 -0500138
Nico Huberce768f32017-05-20 20:47:18 +0200139 if (!IS_ENABLED(CONFIG_LINEAR_FRAMEBUFFER) || fill_lb_framebuffer(&fb))
Aaron Durbinbdb5c8f2017-05-16 21:39:50 -0500140 return;
141
Stefan Reinauerd650e992010-02-22 04:33:13 +0000142 framebuffer = (struct lb_framebuffer *)lb_new_record(header);
Aaron Durbinbdb5c8f2017-05-16 21:39:50 -0500143 memcpy(framebuffer, &fb, sizeof(*framebuffer));
Stefan Reinauerd650e992010-02-22 04:33:13 +0000144 framebuffer->tag = LB_TAG_FRAMEBUFFER;
145 framebuffer->size = sizeof(*framebuffer);
Stefan Reinauerd650e992010-02-22 04:33:13 +0000146}
147
Julius Wernerc445b4f2016-03-31 17:27:05 -0700148void lb_add_gpios(struct lb_gpios *gpios, const struct lb_gpio *gpio_table,
149 size_t count)
Kyösti Mälkki65784752013-12-22 03:12:38 +0200150{
Julius Wernerc445b4f2016-03-31 17:27:05 -0700151 size_t table_size = count * sizeof(struct lb_gpio);
152
153 memcpy(&gpios->gpios[gpios->count], gpio_table, table_size);
154 gpios->count += count;
155 gpios->size += table_size;
Kyösti Mälkki65784752013-12-22 03:12:38 +0200156}
157
Martin Roth1bf55b42017-06-24 14:16:38 -0600158#if IS_ENABLED(CONFIG_CHROMEOS)
Stefan Reinauer31324c62012-04-05 21:22:02 +0200159static void lb_gpios(struct lb_header *header)
160{
161 struct lb_gpios *gpios;
Julius Wernerc445b4f2016-03-31 17:27:05 -0700162 struct lb_gpio *g;
Vadim Bendebury274ef412014-09-22 18:48:41 -0700163
Stefan Reinauer31324c62012-04-05 21:22:02 +0200164 gpios = (struct lb_gpios *)lb_new_record(header);
165 gpios->tag = LB_TAG_GPIO;
166 gpios->size = sizeof(*gpios);
167 gpios->count = 0;
168 fill_lb_gpios(gpios);
Julius Wernerc445b4f2016-03-31 17:27:05 -0700169
170 printk(BIOS_INFO, "Passing %u GPIOs to payload:\n"
171 " NAME | PORT | POLARITY | VALUE\n",
172 gpios->count);
173 for (g = &gpios->gpios[0]; g < &gpios->gpios[gpios->count]; g++) {
174 printk(BIOS_INFO, "%16s | ", g->name);
175 if (g->port == -1)
176 printk(BIOS_INFO, " undefined | ");
177 else
178 printk(BIOS_INFO, "%#.8x | ", g->port);
179 if (g->polarity == ACTIVE_HIGH)
180 printk(BIOS_INFO, " high | ");
181 else
182 printk(BIOS_INFO, " low | ");
183 switch (g->value) {
184 case 0:
Julius Wernerdc5d24c2018-03-07 13:06:53 -0800185 printk(BIOS_INFO, " low\n");
Julius Wernerc445b4f2016-03-31 17:27:05 -0700186 break;
187 case 1:
Julius Wernerdc5d24c2018-03-07 13:06:53 -0800188 printk(BIOS_INFO, " high\n");
Julius Wernerc445b4f2016-03-31 17:27:05 -0700189 break;
190 default:
191 printk(BIOS_INFO, "undefined\n");
192 break;
193 }
194 }
Stefan Reinauer31324c62012-04-05 21:22:02 +0200195}
196
Stefan Reinauer31324c62012-04-05 21:22:02 +0200197static void lb_vbnv(struct lb_header *header)
198{
Martin Roth1bf55b42017-06-24 14:16:38 -0600199#if IS_ENABLED(CONFIG_PC80_SYSTEM)
Julius Werner1f5487a2013-08-27 15:38:54 -0700200 struct lb_range *vbnv;
Stefan Reinauer31324c62012-04-05 21:22:02 +0200201
Julius Werner1f5487a2013-08-27 15:38:54 -0700202 vbnv = (struct lb_range *)lb_new_record(header);
Stefan Reinauer31324c62012-04-05 21:22:02 +0200203 vbnv->tag = LB_TAG_VBNV;
204 vbnv->size = sizeof(*vbnv);
Furquan Shaikh2a12e2e2016-07-25 11:48:03 -0700205 vbnv->range_start = CONFIG_VBOOT_VBNV_OFFSET + 14;
206 vbnv->range_size = VBOOT_VBNV_BLOCK_SIZE;
Stefan Reinauer3e4e3032013-03-20 14:08:04 -0700207#endif
Stefan Reinauer31324c62012-04-05 21:22:02 +0200208}
Aaron Durbindd32a312013-03-07 23:15:06 -0600209
Martin Roth1bf55b42017-06-24 14:16:38 -0600210#if IS_ENABLED(CONFIG_VBOOT)
Aaron Durbindd32a312013-03-07 23:15:06 -0600211static void lb_vboot_handoff(struct lb_header *header)
212{
213 void *addr;
214 uint32_t size;
Julius Werner1f5487a2013-08-27 15:38:54 -0700215 struct lb_range *vbho;
Aaron Durbindd32a312013-03-07 23:15:06 -0600216
217 if (vboot_get_handoff_info(&addr, &size))
218 return;
219
Julius Werner1f5487a2013-08-27 15:38:54 -0700220 vbho = (struct lb_range *)lb_new_record(header);
Aaron Durbindd32a312013-03-07 23:15:06 -0600221 vbho->tag = LB_TAB_VBOOT_HANDOFF;
222 vbho->size = sizeof(*vbho);
Julius Werner1f5487a2013-08-27 15:38:54 -0700223 vbho->range_start = (intptr_t)addr;
224 vbho->range_size = size;
Aaron Durbindd32a312013-03-07 23:15:06 -0600225}
226#else
227static inline void lb_vboot_handoff(struct lb_header *header) {}
Furquan Shaikh2a12e2e2016-07-25 11:48:03 -0700228#endif /* CONFIG_VBOOT */
Aaron Durbindd32a312013-03-07 23:15:06 -0600229#endif /* CONFIG_CHROMEOS */
Stefan Reinauer31324c62012-04-05 21:22:02 +0200230
Aaron Durbin64031672018-04-21 14:45:32 -0600231__weak uint32_t board_id(void) { return UNDEFINED_STRAPPING_ID; }
232__weak uint32_t ram_code(void) { return UNDEFINED_STRAPPING_ID; }
233__weak uint32_t sku_id(void) { return UNDEFINED_STRAPPING_ID; }
Julius Werner4ec3d9d2017-12-01 19:01:55 -0800234
Vadim Bendeburyb0c302f2014-07-28 16:03:07 -0700235static void lb_board_id(struct lb_header *header)
236{
Julius Wernere2f17f72017-12-05 13:39:10 -0800237 struct lb_strapping_id *rec;
238 uint32_t bid = board_id();
Vadim Bendeburyb0c302f2014-07-28 16:03:07 -0700239
Julius Werner4ec3d9d2017-12-01 19:01:55 -0800240 if (bid == UNDEFINED_STRAPPING_ID)
241 return;
242
Julius Wernere2f17f72017-12-05 13:39:10 -0800243 rec = (struct lb_strapping_id *)lb_new_record(header);
Vadim Bendeburyb0c302f2014-07-28 16:03:07 -0700244
Julius Wernere2f17f72017-12-05 13:39:10 -0800245 rec->tag = LB_TAG_BOARD_ID;
246 rec->size = sizeof(*rec);
247 rec->id_code = bid;
248
249 printk(BIOS_INFO, "Board ID: %d\n", bid);
Vadim Bendeburyb0c302f2014-07-28 16:03:07 -0700250}
251
Patrick Georgifb5d5b12015-07-14 17:15:51 +0100252static void lb_boot_media_params(struct lb_header *header)
253{
254 struct lb_boot_media_params *bmp;
255 struct cbfs_props props;
256 const struct region_device *boot_dev;
257 struct region_device fmrd;
258
259 boot_device_init();
260
261 if (cbfs_boot_region_properties(&props))
262 return;
263
264 boot_dev = boot_device_ro();
265 if (boot_dev == NULL)
266 return;
267
268 bmp = (struct lb_boot_media_params *)lb_new_record(header);
269 bmp->tag = LB_TAG_BOOT_MEDIA_PARAMS;
270 bmp->size = sizeof(*bmp);
271
272 bmp->cbfs_offset = props.offset;
273 bmp->cbfs_size = props.size;
274 bmp->boot_media_size = region_device_sz(boot_dev);
275
276 bmp->fmap_offset = ~(uint64_t)0;
Lee Leahy2f919ec2017-03-08 17:37:06 -0800277 if (find_fmap_directory(&fmrd) == 0)
Patrick Georgifb5d5b12015-07-14 17:15:51 +0100278 bmp->fmap_offset = region_device_offset(&fmrd);
Patrick Georgifb5d5b12015-07-14 17:15:51 +0100279}
280
David Hendricks627b3bd2014-11-03 17:42:09 -0800281static void lb_ram_code(struct lb_header *header)
282{
Julius Wernere2f17f72017-12-05 13:39:10 -0800283 struct lb_strapping_id *rec;
284 uint32_t code = ram_code();
David Hendricks627b3bd2014-11-03 17:42:09 -0800285
Julius Werner4ec3d9d2017-12-01 19:01:55 -0800286 if (code == UNDEFINED_STRAPPING_ID)
287 return;
288
Julius Wernere2f17f72017-12-05 13:39:10 -0800289 rec = (struct lb_strapping_id *)lb_new_record(header);
David Hendricks627b3bd2014-11-03 17:42:09 -0800290
Julius Wernere2f17f72017-12-05 13:39:10 -0800291 rec->tag = LB_TAG_RAM_CODE;
292 rec->size = sizeof(*rec);
293 rec->id_code = code;
294
295 printk(BIOS_INFO, "RAM code: %d\n", code);
David Hendricks627b3bd2014-11-03 17:42:09 -0800296}
297
Julius Werner96ed92d2017-12-01 19:12:14 -0800298static void lb_sku_id(struct lb_header *header)
299{
300 struct lb_strapping_id *rec;
301 uint32_t sid = sku_id();
302
303 if (sid == UNDEFINED_STRAPPING_ID)
304 return;
305
306 rec = (struct lb_strapping_id *)lb_new_record(header);
307
308 rec->tag = LB_TAG_SKU_ID;
309 rec->size = sizeof(*rec);
310 rec->id_code = sid;
311
312 printk(BIOS_INFO, "SKU ID: %d\n", sid);
313}
314
Vadim Bendebury22c04682011-10-03 14:58:57 -0700315static void add_cbmem_pointers(struct lb_header *header)
Vadim Bendebury2e438672011-09-23 09:56:11 -0700316{
Vadim Bendebury22c04682011-10-03 14:58:57 -0700317 /*
318 * These CBMEM sections' addresses are included in the coreboot table
319 * with the appropriate tags.
320 */
321 const struct section_id {
322 int cbmem_id;
323 int table_tag;
324 } section_ids[] = {
325 {CBMEM_ID_TIMESTAMP, LB_TAG_TIMESTAMPS},
Duncan Laurie16e899b2013-12-12 10:43:21 -0800326 {CBMEM_ID_CONSOLE, LB_TAG_CBMEM_CONSOLE},
327 {CBMEM_ID_ACPI_GNVS, LB_TAG_ACPI_GNVS},
Hung-Te Linb15a0d02015-07-13 15:49:57 +0800328 {CBMEM_ID_VPD, LB_TAG_VPD},
Philipp Deppenwiesefa1f6ff2018-05-13 12:42:42 +0200329 {CBMEM_ID_WIFI_CALIBRATION, LB_TAG_WIFI_CALIBRATION},
330 {CBMEM_ID_TCPA_LOG, LB_TAG_TCPA_LOG}
Vadim Bendebury22c04682011-10-03 14:58:57 -0700331 };
332 int i;
Vadim Bendebury2e438672011-09-23 09:56:11 -0700333
Vadim Bendebury22c04682011-10-03 14:58:57 -0700334 for (i = 0; i < ARRAY_SIZE(section_ids); i++) {
335 const struct section_id *sid = section_ids + i;
336 struct lb_cbmem_ref *cbmem_ref;
337 void *cbmem_addr = cbmem_find(sid->cbmem_id);
Vadim Bendebury2e438672011-09-23 09:56:11 -0700338
Vadim Bendebury22c04682011-10-03 14:58:57 -0700339 if (!cbmem_addr)
340 continue; /* This section is not present */
Vadim Bendebury2e438672011-09-23 09:56:11 -0700341
Vadim Bendebury22c04682011-10-03 14:58:57 -0700342 cbmem_ref = (struct lb_cbmem_ref *)lb_new_record(header);
343 if (!cbmem_ref) {
344 printk(BIOS_ERR, "No more room in coreboot table!\n");
345 break;
346 }
347 cbmem_ref->tag = sid->table_tag;
348 cbmem_ref->size = sizeof(*cbmem_ref);
Stefan Reinauerb8ad2242013-01-11 10:41:42 -0800349 cbmem_ref->cbmem_addr = (unsigned long)cbmem_addr;
Vadim Bendebury22c04682011-10-03 14:58:57 -0700350 }
Vadim Bendebury2e438672011-09-23 09:56:11 -0700351}
Vadim Bendebury2e438672011-09-23 09:56:11 -0700352
Stefan Reinauere3778572010-01-30 09:47:18 +0000353static struct lb_mainboard *lb_mainboard(struct lb_header *header)
Eric Biederman8ca8d762003-04-22 19:02:15 +0000354{
355 struct lb_record *rec;
356 struct lb_mainboard *mainboard;
357 rec = lb_new_record(header);
358 mainboard = (struct lb_mainboard *)rec;
359 mainboard->tag = LB_TAG_MAINBOARD;
360
Ronald G. Minnich23bb0362017-01-17 23:20:48 -0800361 mainboard->size = ALIGN_UP(sizeof(*mainboard) +
Stefan Reinauer14e22772010-04-27 06:56:47 +0000362 strlen(mainboard_vendor) + 1 +
Ronald G. Minnich23bb0362017-01-17 23:20:48 -0800363 strlen(mainboard_part_number) + 1, 8);
Eric Biederman8ca8d762003-04-22 19:02:15 +0000364
365 mainboard->vendor_idx = 0;
366 mainboard->part_number_idx = strlen(mainboard_vendor) + 1;
367
368 memcpy(mainboard->strings + mainboard->vendor_idx,
369 mainboard_vendor, strlen(mainboard_vendor) + 1);
370 memcpy(mainboard->strings + mainboard->part_number_idx,
371 mainboard_part_number, strlen(mainboard_part_number) + 1);
372
373 return mainboard;
374}
375
Martin Roth1bf55b42017-06-24 14:16:38 -0600376#if IS_ENABLED(CONFIG_USE_OPTION_TABLE)
Nico Huber08599912015-09-21 20:11:47 +0200377static struct cmos_checksum *lb_cmos_checksum(struct lb_header *header)
378{
379 struct lb_record *rec;
380 struct cmos_checksum *cmos_checksum;
381 rec = lb_new_record(header);
382 cmos_checksum = (struct cmos_checksum *)rec;
383 cmos_checksum->tag = LB_TAG_OPTION_CHECKSUM;
384
385 cmos_checksum->size = (sizeof(*cmos_checksum));
386
387 cmos_checksum->range_start = LB_CKS_RANGE_START * 8;
Lee Leahyd638ef42017-03-07 09:47:22 -0800388 cmos_checksum->range_end = (LB_CKS_RANGE_END * 8) + 7;
Nico Huber08599912015-09-21 20:11:47 +0200389 cmos_checksum->location = LB_CKS_LOC * 8;
390 cmos_checksum->type = CHECKSUM_PCBIOS;
391
392 return cmos_checksum;
393}
394#endif
395
Stefan Reinauerb883d4c2009-08-27 11:23:06 +0000396static void lb_strings(struct lb_header *header)
Eric Biederman8ca8d762003-04-22 19:02:15 +0000397{
398 static const struct {
399 uint32_t tag;
Stefan Reinauer0dff6e32007-10-23 22:17:45 +0000400 const char *string;
Eric Biederman8ca8d762003-04-22 19:02:15 +0000401 } strings[] = {
Stefan Reinauerf8ee1802008-01-18 15:08:58 +0000402 { LB_TAG_VERSION, coreboot_version, },
403 { LB_TAG_EXTRA_VERSION, coreboot_extra_version, },
404 { LB_TAG_BUILD, coreboot_build, },
405 { LB_TAG_COMPILE_TIME, coreboot_compile_time, },
Eric Biederman8ca8d762003-04-22 19:02:15 +0000406 };
Eric Biederman52685572003-05-19 19:16:21 +0000407 unsigned int i;
Lee Leahy45fde702017-03-08 18:02:24 -0800408 for (i = 0; i < ARRAY_SIZE(strings); i++) {
Eric Biederman8ca8d762003-04-22 19:02:15 +0000409 struct lb_string *rec;
410 size_t len;
411 rec = (struct lb_string *)lb_new_record(header);
412 len = strlen(strings[i].string);
413 rec->tag = strings[i].tag;
Ronald G. Minnich23bb0362017-01-17 23:20:48 -0800414 rec->size = ALIGN_UP(sizeof(*rec) + len + 1, 8);
Eric Biederman8ca8d762003-04-22 19:02:15 +0000415 memcpy(rec->string, strings[i].string, len+1);
416 }
417
418}
419
Vladimir Serbinenko6ead2532014-08-23 01:08:09 +0200420static void lb_record_version_timestamp(struct lb_header *header)
421{
422 struct lb_timestamp *rec;
423 rec = (struct lb_timestamp *)lb_new_record(header);
424 rec->tag = LB_TAG_VERSION_TIMESTAMP;
425 rec->size = sizeof(*rec);
426 rec->timestamp = coreboot_version_timestamp;
427}
428
Aaron Durbin64031672018-04-21 14:45:32 -0600429void __weak lb_board(struct lb_header *header) { /* NOOP */ }
Julius Wernerb8fad3d2013-08-27 15:48:32 -0700430
Aaron Durbinc0a823c2016-08-11 14:51:38 -0500431/*
432 * It's possible that the system is using a SPI flash as the boot device,
433 * however it is not probing for devices to fill in specifics. In that
434 * case don't provide any information as the correct information is
435 * not known.
436 */
Aaron Durbin64031672018-04-21 14:45:32 -0600437void __weak lb_spi_flash(struct lb_header *header) { /* NOOP */ }
Aaron Durbinc0a823c2016-08-11 14:51:38 -0500438
Lee Leahy73402172017-03-10 15:23:24 -0800439static struct lb_forward *lb_forward(struct lb_header *header,
440 struct lb_header *next_header)
Stefan Reinauerefab4ba2009-03-17 14:38:48 +0000441{
442 struct lb_record *rec;
443 struct lb_forward *forward;
444 rec = lb_new_record(header);
445 forward = (struct lb_forward *)rec;
446 forward->tag = LB_TAG_FORWARD;
447 forward->size = sizeof(*forward);
Stefan Reinauerdf77f342009-04-06 14:00:53 +0000448 forward->forward = (uint64_t)(unsigned long)next_header;
Stefan Reinauerefab4ba2009-03-17 14:38:48 +0000449 return forward;
450}
451
Aaron Durbin28adb6e2013-03-23 00:06:36 -0500452static unsigned long lb_table_fini(struct lb_header *head)
Eric Biederman8ca8d762003-04-22 19:02:15 +0000453{
454 struct lb_record *rec, *first_rec;
455 rec = lb_last_record(head);
Lee Leahy2f919ec2017-03-08 17:37:06 -0800456 if (head->table_entries)
Eric Biederman8ca8d762003-04-22 19:02:15 +0000457 head->table_bytes += rec->size;
Stefan Reinauerefab4ba2009-03-17 14:38:48 +0000458
Eric Biederman8ca8d762003-04-22 19:02:15 +0000459 first_rec = lb_first_record(head);
Lee Leahy73402172017-03-10 15:23:24 -0800460 head->table_checksum = compute_ip_checksum(first_rec,
461 head->table_bytes);
Eric Biederman8ca8d762003-04-22 19:02:15 +0000462 head->header_checksum = 0;
463 head->header_checksum = compute_ip_checksum(head, sizeof(*head));
Vadim Bendebury05239892011-08-16 11:44:35 -0700464 printk(BIOS_DEBUG,
465 "Wrote coreboot table at: %p, 0x%x bytes, checksum %x\n",
466 head, head->table_bytes, head->table_checksum);
467 return (unsigned long)rec + rec->size;
Eric Biederman8ca8d762003-04-22 19:02:15 +0000468}
469
Aaron Durbin8984af82016-04-19 17:06:09 -0500470size_t write_coreboot_forwarding_table(uintptr_t entry, uintptr_t target)
471{
472 struct lb_header *head;
473
474 printk(BIOS_DEBUG, "Writing table forward entry at 0x%p\n",
475 (void *)entry);
476
477 head = lb_table_init(entry);
Lee Leahyb2d834a2017-03-08 16:52:22 -0800478 lb_forward(head, (struct lb_header *)target);
Aaron Durbin8984af82016-04-19 17:06:09 -0500479
480 return (uintptr_t)lb_table_fini(head) - entry;
481}
482
Aaron Durbina4db0502016-04-19 21:38:18 -0500483static uintptr_t write_coreboot_table(uintptr_t rom_table_end)
Eric Biederman8ca8d762003-04-22 19:02:15 +0000484{
Eric Biederman8ca8d762003-04-22 19:02:15 +0000485 struct lb_header *head;
Eric Biederman8ca8d762003-04-22 19:02:15 +0000486
Stefan Reinauer3e4e3032013-03-20 14:08:04 -0700487 printk(BIOS_DEBUG, "Writing coreboot table at 0x%08lx\n",
Aaron Durbina4db0502016-04-19 21:38:18 -0500488 (long)rom_table_end);
Stefan Reinauer14e22772010-04-27 06:56:47 +0000489
Stefan Reinauerefab4ba2009-03-17 14:38:48 +0000490 head = lb_table_init(rom_table_end);
Stefan Reinauer4f1cb232006-07-19 15:32:49 +0000491
Martin Roth1bf55b42017-06-24 14:16:38 -0600492#if IS_ENABLED(CONFIG_USE_OPTION_TABLE)
Stefan Reinauerba430642007-04-06 12:14:51 +0000493 {
Aaron Durbin899d13d2015-05-15 23:39:23 -0500494 struct cmos_option_table *option_table =
495 cbfs_boot_map_with_leak("cmos_layout.bin",
Vladimir Serbinenko0af61b62014-01-12 13:45:52 +0100496 CBFS_COMPONENT_CMOS_LAYOUT, NULL);
Patrick Georgi24479372011-01-18 13:56:36 +0000497 if (option_table) {
498 struct lb_record *rec_dest = lb_new_record(head);
Lee Leahy73402172017-03-10 15:23:24 -0800499 /* Copy the option config table, it's already a
500 * lb_record...
501 */
Josef Kellermann679d38b2011-01-24 21:07:57 +0000502 memcpy(rec_dest, option_table, option_table->size);
Nico Huber08599912015-09-21 20:11:47 +0200503 /* Create cmos checksum entry in coreboot table */
504 lb_cmos_checksum(head);
Patrick Georgicef3b892011-01-18 14:28:45 +0000505 } else {
Lee Leahy73402172017-03-10 15:23:24 -0800506 printk(BIOS_ERR,
507 "cmos_layout.bin could not be found!\n");
Patrick Georgi24479372011-01-18 13:56:36 +0000508 }
Eric Biederman8ca8d762003-04-22 19:02:15 +0000509 }
Stefan Reinauerba430642007-04-06 12:14:51 +0000510#endif
Stefan Reinauer3e4e3032013-03-20 14:08:04 -0700511
Aaron Durbin4677f6b2018-04-03 00:08:12 -0600512 /* Serialize resource map into mem table types (LB_MEM_*) */
Aaron Durbin2d5cec62014-02-25 00:24:22 -0600513 bootmem_write_memory_table(lb_memory(head));
Eric Biederman8ca8d762003-04-22 19:02:15 +0000514
Patrick Georgi8c2a0c12008-01-25 18:28:18 +0000515 /* Record our motherboard */
Eric Biederman8ca8d762003-04-22 19:02:15 +0000516 lb_mainboard(head);
Kyösti Mälkkibbf6f3d2014-03-15 01:32:55 +0200517
518 /* Record the serial ports and consoles */
Martin Roth1bf55b42017-06-24 14:16:38 -0600519#if IS_ENABLED(CONFIG_CONSOLE_SERIAL)
Kyösti Mälkkibbf6f3d2014-03-15 01:32:55 +0200520 uart_fill_lb(head);
521#endif
Martin Roth1bf55b42017-06-24 14:16:38 -0600522#if IS_ENABLED(CONFIG_CONSOLE_USB)
Kyösti Mälkkibbf6f3d2014-03-15 01:32:55 +0200523 lb_add_console(LB_TAG_CONSOLE_EHCI, head);
524#endif
525
Eric Biederman8ca8d762003-04-22 19:02:15 +0000526 /* Record our various random string information */
527 lb_strings(head);
Vladimir Serbinenko6ead2532014-08-23 01:08:09 +0200528 lb_record_version_timestamp(head);
Stefan Reinauerd650e992010-02-22 04:33:13 +0000529 /* Record our framebuffer */
530 lb_framebuffer(head);
Eric Biederman8ca8d762003-04-22 19:02:15 +0000531
Martin Roth1bf55b42017-06-24 14:16:38 -0600532#if IS_ENABLED(CONFIG_CHROMEOS)
Stefan Reinauer31324c62012-04-05 21:22:02 +0200533 /* Record our GPIO settings (ChromeOS specific) */
534 lb_gpios(head);
535
Stefan Reinauer31324c62012-04-05 21:22:02 +0200536 /* pass along VBNV offsets in CMOS */
537 lb_vbnv(head);
Aaron Durbindd32a312013-03-07 23:15:06 -0600538
539 /* pass along the vboot_handoff address. */
540 lb_vboot_handoff(head);
Stefan Reinauer31324c62012-04-05 21:22:02 +0200541#endif
Vadim Bendeburyb0c302f2014-07-28 16:03:07 -0700542
Julius Werner96ed92d2017-12-01 19:12:14 -0800543 /* Add strapping IDs if available */
Vadim Bendeburyb0c302f2014-07-28 16:03:07 -0700544 lb_board_id(head);
David Hendricks627b3bd2014-11-03 17:42:09 -0800545 lb_ram_code(head);
Julius Werner96ed92d2017-12-01 19:12:14 -0800546 lb_sku_id(head);
David Hendricks627b3bd2014-11-03 17:42:09 -0800547
Dan Ehrenberga5aac762015-01-08 10:29:19 -0800548 /* Add SPI flash description if available */
Aaron Durbinc0a823c2016-08-11 14:51:38 -0500549 if (IS_ENABLED(CONFIG_BOOT_DEVICE_SPI_FLASH))
550 lb_spi_flash(head);
Dan Ehrenberga5aac762015-01-08 10:29:19 -0800551
Vadim Bendebury22c04682011-10-03 14:58:57 -0700552 add_cbmem_pointers(head);
553
Julius Wernerb8fad3d2013-08-27 15:48:32 -0700554 /* Add board-specific table entries, if any. */
555 lb_board(head);
556
Furquan Shaikhefb546d2014-11-08 17:34:27 -0800557#if IS_ENABLED(CONFIG_CHROMEOS_RAMOOPS)
558 lb_ramoops(head);
559#endif
560
Patrick Georgifb5d5b12015-07-14 17:15:51 +0100561 lb_boot_media_params(head);
562
Aaron Durbinf6ada1c2016-02-10 10:52:47 -0600563 /* Add architecture records. */
564 lb_arch_add_records(head);
565
Aaron Durbin1ca2d862015-09-30 12:26:54 -0500566 /* Add all cbmem entries into the coreboot tables. */
567 cbmem_add_records_to_cbtable(head);
568
Eric Biederman8ca8d762003-04-22 19:02:15 +0000569 /* Remember where my valid memory ranges are */
Aaron Durbin28adb6e2013-03-23 00:06:36 -0500570 return lb_table_fini(head);
Eric Biederman8ca8d762003-04-22 19:02:15 +0000571}
Aaron Durbina4db0502016-04-19 21:38:18 -0500572
Ronald G. Minnicha8fa2512018-07-18 14:35:01 -0700573void *write_tables(void)
Aaron Durbina4db0502016-04-19 21:38:18 -0500574{
575 uintptr_t cbtable_start;
576 uintptr_t cbtable_end;
577 size_t cbtable_size;
Aaron Durbina6e90512016-04-21 14:06:17 -0500578 const size_t max_table_size = COREBOOT_TABLE_SIZE;
Aaron Durbina4db0502016-04-19 21:38:18 -0500579
580 cbtable_start = (uintptr_t)cbmem_add(CBMEM_ID_CBTABLE, max_table_size);
581
582 if (!cbtable_start) {
583 printk(BIOS_ERR, "Could not add CBMEM for coreboot table.\n");
Ronald G. Minnicha8fa2512018-07-18 14:35:01 -0700584 return NULL;
Aaron Durbina4db0502016-04-19 21:38:18 -0500585 }
586
587 /* Add architecture specific tables. */
588 arch_write_tables(cbtable_start);
589
590 /* Write the coreboot table. */
591 cbtable_end = write_coreboot_table(cbtable_start);
592 cbtable_size = cbtable_end - cbtable_start;
593
594 if (cbtable_size > max_table_size) {
595 printk(BIOS_ERR, "%s: coreboot table didn't fit (%zx/%zx)\n",
596 __func__, cbtable_size, max_table_size);
597 }
598
599 printk(BIOS_DEBUG, "coreboot table: %zd bytes.\n", cbtable_size);
600
601 /* Print CBMEM sections */
602 cbmem_list();
Ronald G. Minnicha8fa2512018-07-18 14:35:01 -0700603 return (void *)cbtable_start;
Aaron Durbina4db0502016-04-19 21:38:18 -0500604}