blob: 7d4ca835f2c90352b058bc542f577387ba2cb32b [file] [log] [blame]
Kevin O'Connor59a23bb2008-06-08 23:09:42 -04001// Coreboot interface support.
2//
3// Copyright (C) 2008 Kevin O'Connor <kevin@koconnor.net>
4//
Kevin O'Connorb1b7c2a2009-01-15 20:52:58 -05005// This file may be distributed under the terms of the GNU LGPLv3 license.
Kevin O'Connor59a23bb2008-06-08 23:09:42 -04006
7#include "memmap.h" // add_e820
8#include "util.h" // dprintf
Kevin O'Connor93479e42008-06-12 22:22:43 -04009#include "pci.h" // struct pir_header
10#include "acpi.h" // struct rsdp_descriptor
Kevin O'Connor35746442009-02-27 20:54:51 -050011#include "mptable.h" // MPTABLE_SIGNATURE
Kevin O'Connor9521e262008-07-04 13:04:29 -040012#include "biosvar.h" // GET_EBDA
Kevin O'Connor592323f2009-04-26 23:17:49 -040013#include "lzmadecode.h" // LzmaDecode
Kevin O'Connor59a23bb2008-06-08 23:09:42 -040014
15
16/****************************************************************
Kevin O'Connor93479e42008-06-12 22:22:43 -040017 * BIOS table copying
18 ****************************************************************/
19
20static void
21copy_pir(void *pos)
22{
23 struct pir_header *p = pos;
24 if (p->signature != PIR_SIGNATURE)
25 return;
Kevin O'Connor51358db2008-12-28 21:50:29 -050026 if (PirOffset)
Kevin O'Connor93479e42008-06-12 22:22:43 -040027 return;
28 if (p->size < sizeof(*p))
29 return;
30 if (checksum(pos, p->size) != 0)
31 return;
32 bios_table_cur_addr = ALIGN(bios_table_cur_addr, 16);
33 if (bios_table_cur_addr + p->size > bios_table_end_addr) {
34 dprintf(1, "No room to copy PIR table!\n");
35 return;
36 }
37 dprintf(1, "Copying PIR from %p to %x\n", pos, bios_table_cur_addr);
38 memcpy((void*)bios_table_cur_addr, pos, p->size);
Kevin O'Connor51358db2008-12-28 21:50:29 -050039 PirOffset = bios_table_cur_addr - BUILD_BIOS_ADDR;
Kevin O'Connor93479e42008-06-12 22:22:43 -040040 bios_table_cur_addr += p->size;
41}
42
Kevin O'Connore10e6f82008-06-21 19:46:43 -040043static void
44copy_mptable(void *pos)
45{
46 struct mptable_floating_s *p = pos;
Kevin O'Connor35746442009-02-27 20:54:51 -050047 if (p->signature != MPTABLE_SIGNATURE)
Kevin O'Connore10e6f82008-06-21 19:46:43 -040048 return;
49 if (!p->physaddr)
50 return;
51 if (checksum(pos, sizeof(*p)) != 0)
52 return;
53 u32 length = p->length * 16;
54 bios_table_cur_addr = ALIGN(bios_table_cur_addr, 16);
Kevin O'Connor47e20932009-02-27 21:04:09 -050055 u16 mpclength = ((struct mptable_config_s *)p->physaddr)->length;
56 if (bios_table_cur_addr + length + mpclength > bios_table_end_addr) {
Kevin O'Connore10e6f82008-06-21 19:46:43 -040057 dprintf(1, "No room to copy MPTABLE!\n");
58 return;
59 }
Kevin O'Connor47e20932009-02-27 21:04:09 -050060 dprintf(1, "Copying MPTABLE from %p/%x to %x\n"
61 , pos, p->physaddr, bios_table_cur_addr);
Kevin O'Connore10e6f82008-06-21 19:46:43 -040062 memcpy((void*)bios_table_cur_addr, pos, length);
Kevin O'Connor47e20932009-02-27 21:04:09 -050063 struct mptable_floating_s *newp = (void*)bios_table_cur_addr;
64 newp->physaddr = bios_table_cur_addr + length;
65 newp->checksum = 0;
66 newp->checksum = -checksum(newp, sizeof(*newp));
67 memcpy((void*)bios_table_cur_addr + length, (void*)p->physaddr, mpclength);
68 bios_table_cur_addr += length + mpclength;
Kevin O'Connore10e6f82008-06-21 19:46:43 -040069}
Kevin O'Connor93479e42008-06-12 22:22:43 -040070
71static void
72copy_acpi_rsdp(void *pos)
73{
Kevin O'Connor9967ab72008-12-18 21:57:33 -050074 if (RsdpAddr)
Kevin O'Connor93479e42008-06-12 22:22:43 -040075 return;
76 struct rsdp_descriptor *p = pos;
Kevin O'Connor9967ab72008-12-18 21:57:33 -050077 if (p->signature != RSDP_SIGNATURE)
78 return;
Kevin O'Connor93479e42008-06-12 22:22:43 -040079 u32 length = 20;
80 if (checksum(pos, length) != 0)
81 return;
82 if (p->revision > 1) {
83 length = p->length;
84 if (checksum(pos, length) != 0)
85 return;
86 }
87 bios_table_cur_addr = ALIGN(bios_table_cur_addr, 16);
88 if (bios_table_cur_addr + length > bios_table_end_addr) {
89 dprintf(1, "No room to copy ACPI RSDP table!\n");
90 return;
91 }
92 dprintf(1, "Copying ACPI RSDP from %p to %x\n", pos, bios_table_cur_addr);
Kevin O'Connor9967ab72008-12-18 21:57:33 -050093 RsdpAddr = (void*)bios_table_cur_addr;
94 memcpy(RsdpAddr, pos, length);
Kevin O'Connor93479e42008-06-12 22:22:43 -040095 bios_table_cur_addr += length;
96}
97
98// Attempt to find (and relocate) any standard bios tables found in a
99// given address range.
Kevin O'Connor9521e262008-07-04 13:04:29 -0400100static void
Kevin O'Connor93479e42008-06-12 22:22:43 -0400101scan_tables(u32 start, u32 size)
102{
103 void *p = (void*)ALIGN(start, 16);
104 void *end = (void*)start + size;
105 for (; p<end; p += 16) {
106 copy_pir(p);
Kevin O'Connore10e6f82008-06-21 19:46:43 -0400107 copy_mptable(p);
Kevin O'Connor93479e42008-06-12 22:22:43 -0400108 copy_acpi_rsdp(p);
109 }
110}
111
112
113/****************************************************************
114 * Memory map
Kevin O'Connor59a23bb2008-06-08 23:09:42 -0400115 ****************************************************************/
116
117struct cb_header {
118 u32 signature;
119 u32 header_bytes;
120 u32 header_checksum;
121 u32 table_bytes;
122 u32 table_checksum;
123 u32 table_entries;
124};
125
126#define CB_SIGNATURE 0x4f49424C // "LBIO"
127
128struct cb_memory_range {
129 u64 start;
130 u64 size;
131 u32 type;
132};
133
134#define CB_MEM_TABLE 16
135
136struct cb_memory {
137 u32 tag;
138 u32 size;
139 struct cb_memory_range map[0];
140};
141
142#define CB_TAG_MEMORY 0x01
143
144#define MEM_RANGE_COUNT(_rec) \
145 (((_rec)->size - sizeof(*(_rec))) / sizeof((_rec)->map[0]))
146
Kevin O'Connor071f1542009-03-21 13:17:21 -0400147struct cb_forward {
148 u32 tag;
149 u32 size;
150 u64 forward;
151};
152
153#define CB_TAG_FORWARD 0x11
154
Kevin O'Connor59a23bb2008-06-08 23:09:42 -0400155static u16
156ipchksum(char *buf, int count)
157{
158 u16 *p = (u16*)buf;
159 u32 sum = 0;
160 while (count > 1) {
161 sum += *p++;
162 count -= 2;
163 }
164 if (count)
165 sum += *(u8*)p;
166 sum = (sum >> 16) + (sum & 0xffff);
167 sum += (sum >> 16);
168 return ~sum;
169}
170
171// Try to locate the coreboot header in a given address range.
172static struct cb_header *
173find_cb_header(char *addr, int len)
174{
175 char *end = addr + len;
176 for (; addr < end; addr += 16) {
177 struct cb_header *cbh = (struct cb_header *)addr;
178 if (cbh->signature != CB_SIGNATURE)
179 continue;
Kevin O'Connor59a23bb2008-06-08 23:09:42 -0400180 if (! cbh->table_bytes)
181 continue;
182 if (ipchksum(addr, sizeof(*cbh)) != 0)
183 continue;
184 if (ipchksum(addr + sizeof(*cbh), cbh->table_bytes)
185 != cbh->table_checksum)
186 continue;
187 return cbh;
188 }
189 return NULL;
190}
191
192// Try to find the coreboot memory table in the given coreboot table.
Kevin O'Connor93479e42008-06-12 22:22:43 -0400193static void *
194find_cb_subtable(struct cb_header *cbh, u32 tag)
Kevin O'Connor59a23bb2008-06-08 23:09:42 -0400195{
196 char *tbl = (char *)cbh + sizeof(*cbh);
197 int i;
198 for (i=0; i<cbh->table_entries; i++) {
199 struct cb_memory *cbm = (struct cb_memory *)tbl;
200 tbl += cbm->size;
Kevin O'Connor93479e42008-06-12 22:22:43 -0400201 if (cbm->tag == tag)
Kevin O'Connor59a23bb2008-06-08 23:09:42 -0400202 return cbm;
203 }
204 return NULL;
205}
206
207// Populate max ram and e820 map info by scanning for a coreboot table.
Kevin O'Connor4c0c85a2009-04-11 23:31:29 -0400208static void
Kevin O'Connor59a23bb2008-06-08 23:09:42 -0400209coreboot_fill_map()
210{
211 dprintf(3, "Attempting to find coreboot table\n");
Kevin O'Connoref3d8822009-02-05 19:51:12 -0500212
213 // Init variables set in coreboot table memory scan.
214 PirOffset = 0;
215 RsdpAddr = 0;
216
217 // Find coreboot table.
Kevin O'Connor59a23bb2008-06-08 23:09:42 -0400218 struct cb_header *cbh = find_cb_header(0, 0x1000);
219 if (!cbh)
220 goto fail;
Kevin O'Connor071f1542009-03-21 13:17:21 -0400221 struct cb_forward *cbf = find_cb_subtable(cbh, CB_TAG_FORWARD);
222 if (cbf) {
223 dprintf(3, "Found coreboot table forwarder.\n");
224 cbh = find_cb_header((char *)((u32)cbf->forward), 0x100);
225 if (!cbh)
226 goto fail;
227 }
228 dprintf(3, "Now attempting to find coreboot memory map\n");
Kevin O'Connor93479e42008-06-12 22:22:43 -0400229 struct cb_memory *cbm = find_cb_subtable(cbh, CB_TAG_MEMORY);
Kevin O'Connor59a23bb2008-06-08 23:09:42 -0400230 if (!cbm)
231 goto fail;
232
Kevin O'Connor59c35f22008-10-25 23:05:42 -0400233 u64 maxram = 0, maxram_over4G = 0;
Kevin O'Connor59a23bb2008-06-08 23:09:42 -0400234 int i, count = MEM_RANGE_COUNT(cbm);
235 for (i=0; i<count; i++) {
236 struct cb_memory_range *m = &cbm->map[i];
237 u32 type = m->type;
Kevin O'Connor93479e42008-06-12 22:22:43 -0400238 if (type == CB_MEM_TABLE) {
Kevin O'Connor59a23bb2008-06-08 23:09:42 -0400239 type = E820_RESERVED;
Kevin O'Connor93479e42008-06-12 22:22:43 -0400240 scan_tables(m->start, m->size);
Kevin O'Connor59c35f22008-10-25 23:05:42 -0400241 } else if (type == E820_ACPI || type == E820_RAM) {
242 u64 end = m->start + m->size;
243 if (end > 0x100000000ull) {
244 end -= 0x100000000ull;
245 if (end > maxram_over4G)
246 maxram_over4G = end;
247 } else if (end > maxram)
248 maxram = end;
Kevin O'Connor93479e42008-06-12 22:22:43 -0400249 }
Kevin O'Connor59a23bb2008-06-08 23:09:42 -0400250 add_e820(m->start, m->size, type);
251 }
252
Kevin O'Connore7916362008-12-28 22:03:17 -0500253 RamSize = maxram;
254 RamSizeOver4G = maxram_over4G;
Kevin O'Connor59c35f22008-10-25 23:05:42 -0400255
Kevin O'Connor59a23bb2008-06-08 23:09:42 -0400256 // Ughh - coreboot likes to set a map at 0x0000-0x1000, but this
257 // confuses grub. So, override it.
258 add_e820(0, 16*1024, E820_RAM);
259
Kevin O'Connor1d247db2008-08-29 21:19:53 -0400260 // XXX - just create dummy smbios table for now - should detect if
261 // smbios/dmi table is found from coreboot and use that instead.
262 smbios_init();
263
Kevin O'Connor59a23bb2008-06-08 23:09:42 -0400264 return;
265
266fail:
267 // No table found.. Use 16Megs as a dummy value.
268 dprintf(1, "Unable to find coreboot table!\n");
Kevin O'Connore7916362008-12-28 22:03:17 -0500269 RamSize = 16*1024*1024;
270 RamSizeOver4G = 0;
Kevin O'Connor59a23bb2008-06-08 23:09:42 -0400271 add_e820(0, 16*1024*1024, E820_RAM);
272 return;
273}
Kevin O'Connor4c0c85a2009-04-11 23:31:29 -0400274
275
276/****************************************************************
Kevin O'Connor592323f2009-04-26 23:17:49 -0400277 * ulzma
278 ****************************************************************/
279
280static int
Kevin O'Connorcbd6ca02009-04-27 21:51:13 -0400281ulzma(u8 *dst, u32 maxlen, const u8 *src, u32 srclen)
Kevin O'Connor592323f2009-04-26 23:17:49 -0400282{
Kevin O'Connor1edc89d2009-04-30 21:50:35 -0400283 dprintf(3, "Uncompressing data %d@%p to %d@%p\n", srclen, src, maxlen, dst);
Kevin O'Connor592323f2009-04-26 23:17:49 -0400284 CLzmaDecoderState state;
285 int ret = LzmaDecodeProperties(&state.Properties, src, LZMA_PROPERTIES_SIZE);
286 if (ret != LZMA_RESULT_OK) {
287 dprintf(1, "LzmaDecodeProperties error - %d\n", ret);
288 return -1;
289 }
290 u8 scratch[15980];
291 int need = (LzmaGetNumProbs(&state.Properties) * sizeof(CProb));
292 if (need > sizeof(scratch)) {
293 dprintf(1, "LzmaDecode need %d have %d\n", need, sizeof(scratch));
294 return -1;
295 }
296 state.Probs = (CProb *)scratch;
297
298 u32 dstlen = *(u32*)(src + LZMA_PROPERTIES_SIZE);
Kevin O'Connorcbd6ca02009-04-27 21:51:13 -0400299 if (dstlen > maxlen) {
300 dprintf(1, "LzmaDecode too large (max %d need %d)\n", maxlen, dstlen);
301 return -1;
302 }
Kevin O'Connor592323f2009-04-26 23:17:49 -0400303 u32 inProcessed, outProcessed;
Kevin O'Connorcbd6ca02009-04-27 21:51:13 -0400304 ret = LzmaDecode(&state, src + LZMA_PROPERTIES_SIZE + 8, srclen
Kevin O'Connor592323f2009-04-26 23:17:49 -0400305 , &inProcessed, dst, dstlen, &outProcessed);
306 if (ret) {
307 dprintf(1, "LzmaDecode returned %d\n", ret);
308 return -1;
309 }
310 return dstlen;
311}
312
313
314/****************************************************************
Kevin O'Connor4c0c85a2009-04-11 23:31:29 -0400315 * Coreboot flash format
316 ****************************************************************/
317
318// XXX - optimize
319#define ntohl(x) ((((x)&0xff)<<24) | (((x)&0xff00)<<8) | \
320 (((x)&0xff0000) >> 8) | (((x)&0xff000000) >> 24))
321#define htonl(x) ntohl(x)
322
323#define CBFS_HEADER_MAGIC 0x4F524243
324#define CBFS_HEADPTR_ADDR 0xFFFFFFFc
325#define CBFS_VERSION1 0x31313131
326
327struct cbfs_header {
328 u32 magic;
329 u32 version;
330 u32 romsize;
331 u32 bootblocksize;
332 u32 align;
333 u32 offset;
334 u32 pad[2];
335} PACKED;
336
337static struct cbfs_header *CBHDR;
338
339static void
340cbfs_setup()
341{
342 if (! CONFIG_COREBOOT_FLASH)
343 return;
344
345 CBHDR = *(void **)CBFS_HEADPTR_ADDR;
346 if (CBHDR->magic != htonl(CBFS_HEADER_MAGIC)) {
347 dprintf(1, "Unable to find CBFS (got %x not %x)\n"
348 , CBHDR->magic, htonl(CBFS_HEADER_MAGIC));
349 CBHDR = NULL;
350 return;
351 }
352
353 dprintf(1, "Found CBFS header at %p\n", CBHDR);
354}
355
356#define CBFS_FILE_MAGIC 0x455649484352414cLL // LARCHIVE
357
358struct cbfs_file {
359 u64 magic;
360 u32 len;
361 u32 type;
362 u32 checksum;
363 u32 offset;
Kevin O'Connor67823442009-04-13 14:14:51 -0400364 char filename[0];
Kevin O'Connor4c0c85a2009-04-11 23:31:29 -0400365} PACKED;
366
367static struct cbfs_file *
Kevin O'Connor67823442009-04-13 14:14:51 -0400368cbfs_search(struct cbfs_file *file)
Kevin O'Connor4c0c85a2009-04-11 23:31:29 -0400369{
Kevin O'Connor4c0c85a2009-04-11 23:31:29 -0400370 for (;;) {
371 if (file < (struct cbfs_file *)(0xFFFFFFFF - ntohl(CBHDR->romsize)))
372 return NULL;
Kevin O'Connor214f6c22009-04-26 21:27:15 -0400373 u64 magic = file->magic;
Kevin O'Connorcbd6ca02009-04-27 21:51:13 -0400374 if (magic == CBFS_FILE_MAGIC) {
375 dprintf(5, "Found CBFS file %s\n", file->filename);
Kevin O'Connor4c0c85a2009-04-11 23:31:29 -0400376 return file;
Kevin O'Connorcbd6ca02009-04-27 21:51:13 -0400377 }
Kevin O'Connor214f6c22009-04-26 21:27:15 -0400378 if (magic == 0)
379 return NULL;
Kevin O'Connor67823442009-04-13 14:14:51 -0400380 file = (void*)file + ntohl(CBHDR->align);
Kevin O'Connor4c0c85a2009-04-11 23:31:29 -0400381 }
382}
383
Kevin O'Connor67823442009-04-13 14:14:51 -0400384static struct cbfs_file *
385cbfs_getfirst()
386{
387 if (! CBHDR)
388 return NULL;
389 return cbfs_search((void *)(0 - ntohl(CBHDR->romsize) + ntohl(CBHDR->offset)));
390}
391
392static struct cbfs_file *
393cbfs_getnext(struct cbfs_file *file)
394{
395 file = (void*)file + ALIGN(ntohl(file->len) + ntohl(file->offset), ntohl(CBHDR->align));
396 return cbfs_search(file);
397}
398
399static struct cbfs_file *
400cbfs_findfile(const char *fname)
401{
Kevin O'Connor67823442009-04-13 14:14:51 -0400402 dprintf(3, "Searching CBFS for %s\n", fname);
403 struct cbfs_file *file;
404 for (file = cbfs_getfirst(); file; file = cbfs_getnext(file)) {
Kevin O'Connor38d1a342009-04-18 16:59:47 -0400405 if (strcmp(fname, file->filename) == 0)
Kevin O'Connor67823442009-04-13 14:14:51 -0400406 return file;
407 }
408 return NULL;
409}
410
Kevin O'Connor1edc89d2009-04-30 21:50:35 -0400411static int
412data_copy(u8 *dst, u32 maxlen, const u8 *src, u32 srclen)
413{
414 dprintf(3, "Copying data %d@%p to %d@%p\n", srclen, src, maxlen, dst);
415 if (srclen > maxlen) {
416 dprintf(1, "File too big to copy\n");
417 return -1;
418 }
419 memcpy(dst, src, srclen);
420 return srclen;
421}
422
Kevin O'Connorcbd6ca02009-04-27 21:51:13 -0400423// Copy a file to memory (uncompressing if necessary)
424static int
425cbfs_copyfile(void *dst, u32 maxlen, const char *fname)
426{
427 dprintf(3, "Searching CBFS for data file %s\n", fname);
428 int fnlen = strlen(fname);
429 struct cbfs_file *file;
430 for (file = cbfs_getfirst(); file; file = cbfs_getnext(file)) {
431 if (memcmp(fname, file->filename, fnlen) != 0)
432 continue;
433 u32 size = ntohl(file->len);
434 void *src = (void*)file + ntohl(file->offset);
Kevin O'Connor1edc89d2009-04-30 21:50:35 -0400435 if (file->filename[fnlen] == '\0')
436 return data_copy(dst, maxlen, src, size);
437 if (strcmp(&file->filename[fnlen], ".lzma") == 0)
Kevin O'Connorcbd6ca02009-04-27 21:51:13 -0400438 return ulzma(dst, maxlen, src, size);
Kevin O'Connorcbd6ca02009-04-27 21:51:13 -0400439 }
440 return -1;
441}
442
Kevin O'Connor67823442009-04-13 14:14:51 -0400443const char *
444cbfs_findNprefix(const char *prefix, int n)
445{
446 if (! CONFIG_COREBOOT_FLASH)
447 return NULL;
448
449 dprintf(3, "Searching CBFS for prefix %s\n", prefix);
450 int len = strlen(prefix);
451 struct cbfs_file *file;
452 for (file = cbfs_getfirst(); file; file = cbfs_getnext(file)) {
Kevin O'Connor38d1a342009-04-18 16:59:47 -0400453 if (memcmp(prefix, file->filename, len) == 0) {
Kevin O'Connor67823442009-04-13 14:14:51 -0400454 if (n <= 0)
455 return file->filename;
456 n--;
457 }
458 }
459 return NULL;
460}
461
Kevin O'Connor4c0c85a2009-04-11 23:31:29 -0400462static char
463getHex(u8 x)
464{
465 if (x <= 9)
466 return '0' + x;
467 return 'a' + x - 10;
468}
469
470static u32
471hexify4(u16 x)
472{
473 return ((getHex(x&0xf) << 24)
474 | (getHex((x>>4)&0xf) << 16)
475 | (getHex((x>>8)&0xf) << 8)
476 | (getHex(x>>12)));
477}
478
Kevin O'Connorcbd6ca02009-04-27 21:51:13 -0400479int
Kevin O'Connor1edc89d2009-04-30 21:50:35 -0400480cbfs_copy_optionrom(void *dst, u32 maxlen, u32 vendev)
Kevin O'Connor4c0c85a2009-04-11 23:31:29 -0400481{
482 if (! CONFIG_COREBOOT_FLASH)
Kevin O'Connorcbd6ca02009-04-27 21:51:13 -0400483 return -1;
Kevin O'Connor4c0c85a2009-04-11 23:31:29 -0400484
485 char fname[17];
486 // Ughh - poor man's sprintf of "pci%04x,%04x.rom"
Kevin O'Connor67823442009-04-13 14:14:51 -0400487 *(u32*)fname = 0x20696370; // "pci "
Kevin O'Connor4c0c85a2009-04-11 23:31:29 -0400488 *(u32*)&fname[3] = hexify4(vendev);
489 fname[7] = ',';
490 *(u32*)&fname[8] = hexify4(vendev >> 16);
491 *(u32*)&fname[12] = 0x6d6f722e; // ".rom"
492 fname[16] = '\0';
493
Kevin O'Connorcbd6ca02009-04-27 21:51:13 -0400494 return cbfs_copyfile(dst, maxlen, fname);
Kevin O'Connor4c0c85a2009-04-11 23:31:29 -0400495}
496
Kevin O'Connor09880da2009-06-17 20:35:41 -0400497// Copy the next file with the given prefix - starting at pos 'last'.
Kevin O'Connor1edc89d2009-04-30 21:50:35 -0400498struct cbfs_file *
Kevin O'Connor09880da2009-06-17 20:35:41 -0400499cbfs_copyfile_prefix(void *dst, u32 maxlen, char *prefix
500 , struct cbfs_file *last)
Kevin O'Connor1edc89d2009-04-30 21:50:35 -0400501{
502 if (! CONFIG_COREBOOT_FLASH)
503 return NULL;
Kevin O'Connor09880da2009-06-17 20:35:41 -0400504 dprintf(3, "Searching CBFS for data file prefix %s\n", prefix);
505 struct cbfs_file *file;
506 if (! last)
Kevin O'Connor1edc89d2009-04-30 21:50:35 -0400507 file = cbfs_getfirst();
508 else
Kevin O'Connor09880da2009-06-17 20:35:41 -0400509 file = cbfs_getnext(last);
510 int prefixlen = strlen(prefix);
Kevin O'Connor1edc89d2009-04-30 21:50:35 -0400511 for (; file; file = cbfs_getnext(file)) {
Kevin O'Connor09880da2009-06-17 20:35:41 -0400512 if (memcmp(prefix, file->filename, prefixlen) != 0)
Kevin O'Connor1edc89d2009-04-30 21:50:35 -0400513 continue;
514 u32 size = ntohl(file->len);
515 void *src = (void*)file + ntohl(file->offset);
516 int fnamelen = strlen(file->filename);
517 int rv;
518 if (fnamelen > 5 && strcmp(&file->filename[fnamelen-5], ".lzma") == 0)
519 rv = ulzma(dst, maxlen, src, size);
520 else
521 rv = data_copy(dst, maxlen, src, size);
522 if (rv >= 0)
523 return file;
524 }
525 return NULL;
526}
527
Kevin O'Connor67823442009-04-13 14:14:51 -0400528struct cbfs_payload_segment {
529 u32 type;
530 u32 compression;
531 u32 offset;
532 u64 load_addr;
533 u32 len;
534 u32 mem_len;
535} PACKED;
536
537#define PAYLOAD_SEGMENT_BSS 0x20535342
538#define PAYLOAD_SEGMENT_ENTRY 0x52544E45
539
540#define CBFS_COMPRESS_NONE 0
Kevin O'Connor592323f2009-04-26 23:17:49 -0400541#define CBFS_COMPRESS_LZMA 1
Kevin O'Connor67823442009-04-13 14:14:51 -0400542
543struct cbfs_payload {
544 struct cbfs_payload_segment segments[1];
545};
546
547void
548cbfs_run_payload(const char *filename)
549{
Kevin O'Connorcbd6ca02009-04-27 21:51:13 -0400550 if (! CONFIG_COREBOOT_FLASH)
551 return;
Kevin O'Connor67823442009-04-13 14:14:51 -0400552 dprintf(1, "Run %s\n", filename);
553 struct cbfs_file *file = cbfs_findfile(filename);
554 if (!file)
555 return;
556 struct cbfs_payload *pay = (void*)file + ntohl(file->offset);
557 struct cbfs_payload_segment *seg = pay->segments;
558 for (;;) {
Kevin O'Connor67823442009-04-13 14:14:51 -0400559 void *src = (void*)pay + ntohl(seg->offset);
560 void *dest = (void*)ntohl((u32)seg->load_addr);
561 u32 src_len = ntohl(seg->len);
562 u32 dest_len = ntohl(seg->mem_len);
563 switch (seg->type) {
564 case PAYLOAD_SEGMENT_BSS:
565 dprintf(3, "BSS segment %d@%p\n", dest_len, dest);
566 memset(dest, 0, dest_len);
567 break;
568 case PAYLOAD_SEGMENT_ENTRY: {
569 dprintf(1, "Calling addr %p\n", dest);
570 void (*func)() = dest;
571 func();
572 return;
573 }
574 default:
575 dprintf(3, "Segment %x %d@%p -> %d@%p\n"
576 , seg->type, src_len, src, dest_len, dest);
Kevin O'Connor592323f2009-04-26 23:17:49 -0400577 if (seg->compression == htonl(CBFS_COMPRESS_NONE)) {
Kevin O'Connorcbd6ca02009-04-27 21:51:13 -0400578 if (src_len > dest_len)
579 src_len = dest_len;
Kevin O'Connor592323f2009-04-26 23:17:49 -0400580 memcpy(dest, src, src_len);
581 } else if (CONFIG_LZMA
582 && seg->compression == htonl(CBFS_COMPRESS_LZMA)) {
Kevin O'Connorcbd6ca02009-04-27 21:51:13 -0400583 int ret = ulzma(dest, dest_len, src, src_len);
Kevin O'Connor592323f2009-04-26 23:17:49 -0400584 if (ret < 0)
585 return;
586 src_len = ret;
587 } else {
588 dprintf(1, "No support for compression type %x\n"
589 , seg->compression);
590 return;
591 }
Kevin O'Connor67823442009-04-13 14:14:51 -0400592 if (dest_len > src_len)
593 memset(dest + src_len, 0, dest_len - src_len);
594 break;
595 }
596 seg++;
597 }
598}
599
Kevin O'Connor4c0c85a2009-04-11 23:31:29 -0400600void
601coreboot_setup(void)
602{
603 coreboot_fill_map();
604 cbfs_setup();
605}