From 013ee958a142a8a12636faa136ea26249074fd59 Mon Sep 17 00:00:00 2001 From: Michael Brown Date: Fri, 17 Mar 2006 14:16:05 +0000 Subject: [PATCH] These can come back when someone wants to support them --- src/firmware/linuxbios/linuxbios.c | 386 ---------------------- src/firmware/linuxbios/linuxbios_tables.h | 183 ---------- 2 files changed, 569 deletions(-) delete mode 100644 src/firmware/linuxbios/linuxbios.c delete mode 100644 src/firmware/linuxbios/linuxbios_tables.h diff --git a/src/firmware/linuxbios/linuxbios.c b/src/firmware/linuxbios/linuxbios.c deleted file mode 100644 index 0ad66dd5..00000000 --- a/src/firmware/linuxbios/linuxbios.c +++ /dev/null @@ -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 */ diff --git a/src/firmware/linuxbios/linuxbios_tables.h b/src/firmware/linuxbios/linuxbios_tables.h deleted file mode 100644 index ee215201..00000000 --- a/src/firmware/linuxbios/linuxbios_tables.h +++ /dev/null @@ -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 */