david/ipxe
david
/
ipxe
Archived
1
0
Fork 0
Code

These can come back when someone wants to support them

This commit is contained in:
Michael Brown 2006-03-17 14:16:05 +00:00
parent 7be870acd3
commit 013ee958a1
2 changed files with 0 additions and 569 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

386
src/firmware/linuxbios/linuxbios.c
View File

@ -1,386 +0,0 @@
#ifdef LINUXBIOS
#include "etherboot.h"
#include "dev.h"
#include "linuxbios_tables.h"
struct meminfo meminfo;
static int lb_failsafe = 1;
static unsigned lb_boot[MAX_BOOT_ENTRIES];
static unsigned lb_boot_index;
static struct cmos_entries lb_countdown;
static struct cmos_checksum lb_checksum;
#undef DEBUG_LINUXBIOS
static void set_base_mem_k(struct meminfo *info, unsigned mem_k)
{
if ((mem_k <= 640) && (info->basememsize <= mem_k)) {
info->basememsize = mem_k;
}
}
static void set_high_mem_k(struct meminfo *info, unsigned mem_k)
{
/* Shave off a megabyte before playing */
if (mem_k < 1024) {
return;
}
mem_k -= 1024;
if (info->memsize <= mem_k) {
info->memsize = mem_k;
}
}
#define for_each_lbrec(head, rec) \
for(rec = (struct lb_record *)(((char *)head) + sizeof(*head)); \
(((char *)rec) < (((char *)head) + sizeof(*head) + head->table_bytes)) && \
(rec->size >= 1) && \
((((char *)rec) + rec->size) <= (((char *)head) + sizeof(*head) + head->table_bytes)); \
rec = (struct lb_record *)(((char *)rec) + rec->size))
#define for_each_crec(tbl, rec) \
for(rec = (struct lb_record *)(((char *)tbl) + tbl->header_length); \
(((char *)rec) < (((char *)tbl) + tbl->size)) && \
(rec->size >= 1) && \
((((char *)rec) + rec->size) <= (((char *)tbl) + tbl->size)); \
rec = (struct lb_record *)(((char *)rec) + rec->size))
static void read_lb_memory(
struct meminfo *info, struct lb_memory *mem)
{
int i;
int entries;
entries = (mem->size - sizeof(*mem))/sizeof(mem->map[0]);
for(i = 0; (i < entries); i++) {
if (info->map_count < E820MAX) {
info->map[info->map_count].addr = mem->map[i].start;
info->map[info->map_count].size = mem->map[i].size;
info->map[info->map_count].type = mem->map[i].type;
info->map_count++;
}
switch(mem->map[i].type) {
case LB_MEM_RAM:
{
unsigned long long end;
unsigned long mem_k;
end = mem->map[i].start + mem->map[i].size;
#if defined(DEBUG_LINUXBIOS)
printf("lb: %X%X - %X%X (ram)\n",
(unsigned long)(mem->map[i].start >>32),
(unsigned long)(mem->map[i].start & 0xFFFFFFFF),
(unsigned long)(end >> 32),
(unsigned long)(end & 0xFFFFFFFF));
#endif /* DEBUG_LINUXBIOS */
end >>= 10;
mem_k = end;
if (end & 0xFFFFFFFF00000000ULL) {
mem_k = 0xFFFFFFFF;
}
set_base_mem_k(info, mem_k);
set_high_mem_k(info, mem_k);
break;
}
case LB_MEM_RESERVED:
default:
#if defined(DEBUG_LINUXBIOS)
{
unsigned long long end;
end = mem->map[i].start + mem->map[i].size;
printf("lb: %X%X - %X%X (reserved)\n",
(unsigned long)(mem->map[i].start >>32),
(unsigned long)(mem->map[i].start & 0xFFFFFFFF),
(unsigned long)(end >> 32),
(unsigned long)(end & 0xFFFFFFFF));
}
#endif /* DEBUG_LINUXBIOS */
break;
}
}
}
static unsigned cmos_read(unsigned offset, unsigned int size)
{
unsigned addr, old_addr;
unsigned value;
addr = offset/8;
old_addr = inb(0x70);
outb(addr | (old_addr &0x80), 0x70);
value = inb(0x71);
outb(old_addr, 0x70);
value >>= offset & 0x7;
value &= ((1 << size) - 1);
return value;
}
static unsigned cmos_read_checksum(void)
{
unsigned sum =
(cmos_read(lb_checksum.location, 8) << 8) |
cmos_read(lb_checksum.location +8, 8);
return sum & 0xffff;
}
static int cmos_valid(void)
{
unsigned i;
unsigned sum, old_sum;
sum = 0;
if ((lb_checksum.tag != LB_TAG_OPTION_CHECKSUM) ||
(lb_checksum.type != CHECKSUM_PCBIOS) ||
(lb_checksum.size != sizeof(lb_checksum))) {
return 0;
}
for(i = lb_checksum.range_start; i <= lb_checksum.range_end; i+= 8) {
sum += cmos_read(i, 8);
}
sum = (~sum)&0x0ffff;
old_sum = cmos_read_checksum();
return sum == old_sum;
}
static void cmos_write(unsigned offset, unsigned int size, unsigned setting)
{
unsigned addr, old_addr;
unsigned value, mask, shift;
unsigned sum;
addr = offset/8;
shift = offset & 0x7;
mask = ((1 << size) - 1) << shift;
setting = (setting << shift) & mask;
old_addr = inb(0x70);
sum = cmos_read_checksum();
sum = (~sum) & 0xffff;
outb(addr | (old_addr &0x80), 0x70);
value = inb(0x71);
sum -= value;
value &= ~mask;
value |= setting;
sum += value;
outb(value, 0x71);
sum = (~sum) & 0x0ffff;
outb((lb_checksum.location/8) | (old_addr & 0x80), 0x70);
outb((sum >> 8) & 0xff, 0x71);
outb(((lb_checksum.location +8)/8) | (old_addr & 0x80), 0x70);
outb(sum & 0xff, 0x71);
outb(old_addr, 0x70);
return;
}
static void read_linuxbios_values(struct meminfo *info,
struct lb_header *head)
{
/* Read linuxbios tables... */
struct lb_record *rec;
memset(lb_boot, 0, sizeof(lb_boot));
for_each_lbrec(head, rec) {
switch(rec->tag) {
case LB_TAG_MEMORY:
{
struct lb_memory *mem;
mem = (struct lb_memory *) rec;
read_lb_memory(info, mem);
break;
}
case LB_TAG_CMOS_OPTION_TABLE:
{
struct cmos_option_table *tbl;
struct lb_record *crec;
struct cmos_entries *entry;
tbl = (struct cmos_option_table *)rec;
for_each_crec(tbl, crec) {
/* Pick off the checksum entry and keep it */
if (crec->tag == LB_TAG_OPTION_CHECKSUM) {
memcpy(&lb_checksum, crec, sizeof(lb_checksum));
continue;
}
if (crec->tag != LB_TAG_OPTION)
continue;
entry = (struct cmos_entries *)crec;
if ((entry->bit < 112) || (entry->bit > 1020))
continue;
/* See if LinuxBIOS came up in fallback or normal mode */
if (memcmp(entry->name, "last_boot", 10) == 0) {
lb_failsafe = cmos_read(entry->bit, entry->length) == 0;
continue;
}
/* Find where the boot countdown is */
if (memcmp(entry->name, "boot_countdown", 15) == 0) {
lb_countdown = *entry;
continue;
}
/* Find the default boot index */
if (memcmp(entry->name, "boot_index", 11) == 0) {
lb_boot_index = cmos_read(entry->bit, entry->length);
continue;
}
/* Now filter for the boot order options */
if (entry->length != 4)
continue;
if (entry->config != 'e')
continue;
if (memcmp(entry->name, "boot_first", 11) == 0) {
lb_boot[0] = cmos_read(entry->bit, entry->length);
}
else if (memcmp(entry->name, "boot_second", 12) == 0) {
lb_boot[1] = cmos_read(entry->bit, entry->length);
}
else if (memcmp(entry->name, "boot_third", 11) == 0) {
lb_boot[2] = cmos_read(entry->bit, entry->length);
}
}
break;
}
default:
break;
};
}
}
static unsigned long count_lb_records(void *start, unsigned long length)
{
struct lb_record *rec;
void *end;
unsigned long count;
count = 0;
end = ((char *)start) + length;
for(rec = start; ((void *)rec < end) &&
((signed long)rec->size <= (end - (void *)rec));
rec = (void *)(((char *)rec) + rec->size)) {
count++;
}
return count;
}
static int find_lb_table(void *start, void *end, struct lb_header **result)
{
unsigned char *ptr;
/* For now be stupid.... */
for(ptr = start; virt_to_phys(ptr) < virt_to_phys(end); ptr += 16) {
struct lb_header *head = (struct lb_header *)ptr;
if ( (head->signature[0] != 'L') ||
(head->signature[1] != 'B') ||
(head->signature[2] != 'I') ||
(head->signature[3] != 'O')) {
continue;
}
if (head->header_bytes != sizeof(*head))
continue;
#if defined(DEBUG_LINUXBIOS)
printf("Found canidate at: %X\n", virt_to_phys(head));
#endif
if (ipchksum((uint16_t *)head, sizeof(*head)) != 0)
continue;
#if defined(DEBUG_LINUXBIOS)
printf("header checksum o.k.\n");
#endif
if (ipchksum((uint16_t *)(ptr + sizeof(*head)), head->table_bytes) !=
head->table_checksum) {
continue;
}
#if defined(DEBUG_LINUXBIOS)
printf("table checksum o.k.\n");
#endif
if (count_lb_records(ptr + sizeof(*head), head->table_bytes) !=
head->table_entries) {
continue;
}
#if defined(DEBUG_LINUXBIOS)
printf("record count o.k.\n");
#endif
*result = head;
return 1;
};
return 0;
}
void get_memsizes(void)
{
struct lb_header *lb_table;
int found;
#if defined(DEBUG_LINUXBIOS)
printf("\nSearching for linuxbios tables...\n");
#endif /* DEBUG_LINUXBIOS */
found = 0;
meminfo.basememsize = 0;
meminfo.memsize = 0;
meminfo.map_count = 0;
/* This code is specific to linuxBIOS but could
* concievably be extended to work under a normal bios.
* but size is important...
*/
if (!found) {
found = find_lb_table(phys_to_virt(0x00000), phys_to_virt(0x01000), &lb_table);
}
if (!found) {
found = find_lb_table(phys_to_virt(0xf0000), phys_to_virt(0x100000), &lb_table);
}
if (found) {
#if defined (DEBUG_LINUXBIOS)
printf("Found LinuxBIOS table at: %X\n", virt_to_phys(lb_table));
#endif
read_linuxbios_values(&meminfo, lb_table);
}
#if defined(DEBUG_LINUXBIOS)
printf("base_mem_k = %d high_mem_k = %d\n",
meminfo.basememsize, meminfo.memsize);
#endif /* DEBUG_LINUXBIOS */
}
unsigned long get_boot_order(unsigned long order, unsigned *index)
{
static int again;
static int checksum_valid;
static unsigned boot_count;
int i;
if (!lb_failsafe && !again) {
/* Decrement the boot countdown the first time through */
checksum_valid = cmos_valid();
boot_count = cmos_read(lb_countdown.bit, lb_countdown.length);
if (boot_count > 0) {
cmos_write(lb_countdown.bit, lb_countdown.length, boot_count -1);
}
again = 1;
}
if (lb_failsafe || !checksum_valid) {
/* When LinuxBIOS is in failsafe mode, or there is an
* invalid cmos checksum ignore all cmos options
*/
return order;
}
for(i = 0; i < MAX_BOOT_ENTRIES; i++) {
unsigned long boot;
boot = order >> (i*BOOT_BITS) & BOOT_MASK;
boot = lb_boot[i] & BOOT_TYPE_MASK;
if (boot >= BOOT_NOTHING) {
boot = BOOT_NOTHING;
}
if (boot_count == 0) {
boot |= BOOT_FAILSAFE;
}
order &= ~(BOOT_MASK << (i * BOOT_BITS));
order |= (boot << (i*BOOT_BITS));
}
*index = lb_boot_index;
return order;
}
#endif /* LINUXBIOS */

183
src/firmware/linuxbios/linuxbios_tables.h
View File

@ -1,183 +0,0 @@
#ifndef LINUXBIOS_TABLES_H
#define LINUXBIOS_TABLES_H
#include "stdint.h"
/* The linuxbios table information is for conveying information
* from the firmware to the loaded OS image. Primarily this
* is expected to be information that cannot be discovered by
* other means, such as quering the hardware directly.
*
* All of the information should be Position Independent Data.
* That is it should be safe to relocated any of the information
* without it's meaning/correctnes changing. For table that
* can reasonably be used on multiple architectures the data
* size should be fixed. This should ease the transition between
* 32 bit and 64 bit architectures etc.
*
* The completeness test for the information in this table is:
* - Can all of the hardware be detected?
* - Are the per motherboard constants available?
* - Is there enough to allow a kernel to run that was written before
* a particular motherboard is constructed? (Assuming the kernel
* has drivers for all of the hardware but it does not have
* assumptions on how the hardware is connected together).
*
* With this test it should be straight forward to determine if a
* table entry is required or not. This should remove much of the
* long term compatibility burden as table entries which are
* irrelevant or have been replaced by better alternatives may be
* dropped. Of course it is polite and expidite to include extra
* table entries and be backwards compatible, but it is not required.
*/
struct lb_header
{
uint8_t signature[4]; /* LBIO */
uint32_t header_bytes;
uint32_t header_checksum;
uint32_t table_bytes;
uint32_t table_checksum;
uint32_t table_entries;
};
/* Every entry in the boot enviroment list will correspond to a boot
* info record. Encoding both type and size. The type is obviously
* so you can tell what it is. The size allows you to skip that
* boot enviroment record if you don't know what it easy. This allows
* forward compatibility with records not yet defined.
*/
struct lb_record {
uint32_t tag; /* tag ID */
uint32_t size; /* size of record (in bytes) */
};
#define LB_TAG_UNUSED 0x0000
#define LB_TAG_MEMORY 0x0001
struct lb_memory_range {
uint64_t start;
uint64_t size;
uint32_t type;
#define LB_MEM_RAM 1 /* Memory anyone can use */
#define LB_MEM_RESERVED 2 /* Don't use this memory region */
#define LB_MEM_TABLE 16 /* Ram configuration tables are kept in */
};
struct lb_memory {
uint32_t tag;
uint32_t size;
struct lb_memory_range map[0];
};
#define LB_TAG_HWRPB 0x0002
struct lb_hwrpb {
uint32_t tag;
uint32_t size;
uint64_t hwrpb;
};
#define LB_TAG_MAINBOARD 0x0003
struct lb_mainboard {
uint32_t tag;
uint32_t size;
uint8_t vendor_idx;
uint8_t part_number_idx;
uint8_t strings[0];
};
#define LB_TAG_VERSION 0x0004
#define LB_TAG_EXTRA_VERSION 0x0005
#define LB_TAG_BUILD 0x0006
#define LB_TAG_COMPILE_TIME 0x0007
#define LB_TAG_COMPILE_BY 0x0008
#define LB_TAG_COMPILE_HOST 0x0009
#define LB_TAG_COMPILE_DOMAIN 0x000a
#define LB_TAG_COMPILER 0x000b
#define LB_TAG_LINKER 0x000c
#define LB_TAG_ASSEMBLER 0x000d
struct lb_string {
uint32_t tag;
uint32_t size;
uint8_t string[0];
};
/* The following structures are for the cmos definitions table */
#define LB_TAG_CMOS_OPTION_TABLE 200
/* cmos header record */
struct cmos_option_table {
uint32_t tag; /* CMOS definitions table type */
uint32_t size; /* size of the entire table */
uint32_t header_length; /* length of header */
};
/* cmos entry record
This record is variable length. The name field may be
shorter than CMOS_MAX_NAME_LENGTH. The entry may start
anywhere in the byte, but can not span bytes unless it
starts at the beginning of the byte and the length is
fills complete bytes.
*/
#define LB_TAG_OPTION 201
struct cmos_entries {
uint32_t tag; /* entry type */
uint32_t size; /* length of this record */
uint32_t bit; /* starting bit from start of image */
uint32_t length; /* length of field in bits */
uint32_t config; /* e=enumeration, h=hex, r=reserved */
uint32_t config_id; /* a number linking to an enumeration record */
#define CMOS_MAX_NAME_LENGTH 32
uint8_t name[CMOS_MAX_NAME_LENGTH]; /* name of entry in ascii,
variable length int aligned */
};
/* cmos enumerations record
This record is variable length. The text field may be
shorter than CMOS_MAX_TEXT_LENGTH.
*/
#define LB_TAG_OPTION_ENUM 202
struct cmos_enums {
uint32_t tag; /* enumeration type */
uint32_t size; /* length of this record */
uint32_t config_id; /* a number identifying the config id */
uint32_t value; /* the value associated with the text */
#define CMOS_MAX_TEXT_LENGTH 32
uint8_t text[CMOS_MAX_TEXT_LENGTH]; /* enum description in ascii,
variable length int aligned */
};
/* cmos defaults record
This record contains default settings for the cmos ram.
*/
#define LB_TAG_OPTION_DEFAULTS 203
struct cmos_defaults {
uint32_t tag; /* default type */
uint32_t size; /* length of this record */
uint32_t name_length; /* length of the following name field */
uint8_t name[CMOS_MAX_NAME_LENGTH]; /* name identifying the default */
#define CMOS_IMAGE_BUFFER_SIZE 128
uint8_t default_set[CMOS_IMAGE_BUFFER_SIZE]; /* default settings */
};
#define LB_TAG_OPTION_CHECKSUM 204
struct cmos_checksum {
uint32_t tag;
uint32_t size;
/* In practice everything is byte aligned, but things are measured
* in bits to be consistent.
*/
uint32_t range_start; /* First bit that is checksummed (byte aligned) */
uint32_t range_end; /* Last bit that is checksummed (byte aligned) */
uint32_t location; /* First bit of the checksum (byte aligned) */
uint32_t type; /* Checksum algorithm that is used */
#define CHECKSUM_NONE 0
#define CHECKSUM_PCBIOS 1
};
#endif /* LINUXBIOS_TABLES_H */