coreboot-kgpe-d16/payloads/libpayload/drivers/options.c

379 lines
10 KiB
C

/*
* This file is part of the libpayload project.
*
* Copyright (C) 2008 coresystems GmbH
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#include <libpayload.h>
#include <coreboot_tables.h>
u8 *mem_accessor_base;
static u8 mem_read(u8 reg)
{
return mem_accessor_base[reg];
}
static void mem_write(u8 val, u8 reg)
{
mem_accessor_base[reg] = val;
}
struct nvram_accessor *use_nvram = &(struct nvram_accessor) {
nvram_read,
nvram_write
};
struct nvram_accessor *use_mem = &(struct nvram_accessor) {
mem_read,
mem_write
};
struct cb_cmos_option_table *get_system_option_table(void)
{
return lib_sysinfo.option_table;
}
int options_checksum_valid(const struct nvram_accessor *nvram)
{
int i;
int range_start = lib_sysinfo.cmos_range_start / 8;
int range_end = lib_sysinfo.cmos_range_end / 8;
int checksum_location = lib_sysinfo.cmos_checksum_location / 8;
u16 checksum = 0, checksum_old;
for(i = range_start; i <= range_end; i++) {
checksum += nvram->read(i);
}
checksum_old = ((nvram->read(checksum_location)<<8) | nvram->read(checksum_location+1));
return (checksum_old == checksum);
}
void fix_options_checksum_with(const struct nvram_accessor *nvram)
{
int i;
int range_start = lib_sysinfo.cmos_range_start / 8;
int range_end = lib_sysinfo.cmos_range_end / 8;
int checksum_location = lib_sysinfo.cmos_checksum_location / 8;
u16 checksum = 0;
for(i = range_start; i <= range_end; i++) {
checksum += nvram->read(i);
}
nvram->write((checksum >> 8), checksum_location);
nvram->write((checksum & 0xff), checksum_location + 1);
}
void fix_options_checksum(void)
{
fix_options_checksum_with(use_nvram);
}
static int get_cmos_value(const struct nvram_accessor *nvram, u32 bitnum, u32 len, void *valptr)
{
u8 *value = valptr;
int offs = 0;
u32 addr, bit;
u8 reg8;
/* Convert to byte borders */
addr=(bitnum / 8);
bit=(bitnum % 8);
/* Handle single byte or less */
if(len <= 8) {
reg8 = nvram->read(addr);
reg8 >>= bit;
value[0] = reg8 & ((1 << len) -1);
return 0;
}
/* When handling more than a byte, copy whole bytes */
while (len > 0) {
len -= 8;
value[offs++]=nvram->read(addr++);
}
return 0;
}
static int set_cmos_value(const struct nvram_accessor *nvram, u32 bitnum, u32 len, const void *valptr)
{
const u8 *value = valptr;
int offs = 0;
u32 addr, bit;
u8 reg8;
/* Convert to byte borders */
addr=(bitnum / 8);
bit=(bitnum % 8);
/* Handle single byte or less */
if (len <= 8) {
reg8 = nvram->read(addr);
reg8 &= ~(((1 << len) - 1) << bit);
reg8 |= (value[0] & ((1 << len) - 1)) << bit;
nvram->write(reg8, addr);
return 0;
}
/* When handling more than a byte, copy whole bytes */
while (len > 0) {
len -= 8;
nvram->write(value[offs++], addr++);
}
return 0;
}
static struct cb_cmos_entries *lookup_cmos_entry(struct cb_cmos_option_table *option_table, const char *name)
{
struct cb_cmos_entries *cmos_entry;
int len = name ? strnlen(name, CB_CMOS_MAX_NAME_LENGTH) : 0;
/* cmos entries are located right after the option table */
cmos_entry = first_cmos_entry(option_table);
while (cmos_entry) {
if (memcmp((const char*)cmos_entry->name, name, len) == 0)
return cmos_entry;
cmos_entry = next_cmos_entry(cmos_entry);
}
printf("ERROR: No such CMOS option (%s)\n", name);
return NULL;
}
struct cb_cmos_entries *first_cmos_entry(struct cb_cmos_option_table *option_table)
{
return (struct cb_cmos_entries*)((unsigned char *)option_table + option_table->header_length);
}
struct cb_cmos_entries *next_cmos_entry(struct cb_cmos_entries *cmos_entry)
{
struct cb_cmos_entries *next = (struct cb_cmos_entries*)((unsigned char *)cmos_entry + cmos_entry->size);
if (next->tag == CB_TAG_OPTION)
return next;
else
return NULL;
}
struct cb_cmos_enums *first_cmos_enum(struct cb_cmos_option_table *option_table)
{
struct cb_cmos_entries *cmos_entry;
/* cmos entries are located right after the option table. Skip them */
cmos_entry = (struct cb_cmos_entries *)((unsigned char *)option_table + option_table->header_length);
while (cmos_entry->tag == CB_TAG_OPTION)
cmos_entry = (struct cb_cmos_entries*)((unsigned char *)cmos_entry + cmos_entry->size);
/* cmos enums are located after cmos entries. */
return (struct cb_cmos_enums *)cmos_entry;
}
struct cb_cmos_enums *next_cmos_enum(struct cb_cmos_enums *cmos_enum)
{
if (!cmos_enum) {
return NULL;
}
cmos_enum = (struct cb_cmos_enums*)((unsigned char *)cmos_enum + cmos_enum->size);
if (cmos_enum->tag == CB_TAG_OPTION_ENUM) {
return cmos_enum;
} else {
return NULL;
}
}
struct cb_cmos_enums *next_cmos_enum_of_id(struct cb_cmos_enums *cmos_enum, int id)
{
while ((cmos_enum = next_cmos_enum(cmos_enum))) {
if (cmos_enum->config_id == id) {
return cmos_enum;
}
}
return NULL;
}
struct cb_cmos_enums *first_cmos_enum_of_id(struct cb_cmos_option_table *option_table, int id)
{
struct cb_cmos_enums *cmos_enum = first_cmos_enum(option_table);
if (!cmos_enum) {
return NULL;
}
if (cmos_enum->config_id == id) {
return cmos_enum;
}
return next_cmos_enum_of_id(cmos_enum, id);
}
/* Either value or text must be NULL. Returns the field that matches "the other" for a given config_id */
static struct cb_cmos_enums *lookup_cmos_enum_core(struct cb_cmos_option_table *option_table, int config_id, const u8 *value, const char *text)
{
int len = strnlen(text, CB_CMOS_MAX_TEXT_LENGTH);
/* cmos enums are located after cmos entries. */
struct cb_cmos_enums *cmos_enum;
for ( cmos_enum = first_cmos_enum_of_id(option_table, config_id);
cmos_enum;
cmos_enum = next_cmos_enum_of_id(cmos_enum, config_id)) {
if (((value == NULL) || (cmos_enum->value == *value)) &&
((text == NULL) || (memcmp((const char*)cmos_enum->text, text, len) == 0))) {
return cmos_enum;
}
}
return NULL;
}
static struct cb_cmos_enums *lookup_cmos_enum_by_value(struct cb_cmos_option_table *option_table, int config_id, const u8 *value)
{
return lookup_cmos_enum_core(option_table, config_id, value, NULL);
}
static struct cb_cmos_enums *lookup_cmos_enum_by_label(struct cb_cmos_option_table *option_table, int config_id, const char *label)
{
return lookup_cmos_enum_core(option_table, config_id, NULL, label);
}
int get_option_with(const struct nvram_accessor *nvram, struct cb_cmos_option_table *option_table, void *dest, const char *name)
{
struct cb_cmos_entries *cmos_entry = lookup_cmos_entry(option_table, name);
if (cmos_entry) {
if(get_cmos_value(nvram, cmos_entry->bit, cmos_entry->length, dest))
return 1;
if(!options_checksum_valid(nvram))
return 1;
return 0;
}
return 1;
}
int get_option_from(struct cb_cmos_option_table *option_table, void *dest, const char *name)
{
return get_option_with(use_nvram, option_table, dest, name);
}
int get_option(void *dest, const char *name)
{
return get_option_from(get_system_option_table(), dest, name);
}
int set_option_with(const struct nvram_accessor *nvram, struct cb_cmos_option_table *option_table, const void *value, const char *name)
{
struct cb_cmos_entries *cmos_entry = lookup_cmos_entry(option_table, name);
if (cmos_entry) {
set_cmos_value(nvram, cmos_entry->bit, cmos_entry->length, value);
fix_options_checksum_with(nvram);
return 0;
}
return 1;
}
int set_option(const void *value, const char *name)
{
return set_option_with(use_nvram, get_system_option_table(), value, name);
}
int get_option_as_string(const struct nvram_accessor *nvram, struct cb_cmos_option_table *option_table, char **dest, const char *name)
{
void *raw;
struct cb_cmos_entries *cmos_entry = lookup_cmos_entry(option_table, name);
if (!cmos_entry)
return 1;
int cmos_length = (cmos_entry->length+7)/8;
/* ensure we have enough space for u64 */
if (cmos_length < 8)
cmos_length = 8;
/* extra byte to ensure 0-terminated strings */
raw = malloc(cmos_length+1);
memset(raw, 0, cmos_length+1);
int ret = get_option_with(nvram, option_table, raw, name);
struct cb_cmos_enums *cmos_enum;
switch (cmos_entry->config) {
case 'h':
/* only works on little endian.
26 bytes is enough for a 64bit value in decimal */
*dest = malloc(26);
sprintf(*dest, "%llu", *(u64*)raw);
break;
case 's':
*dest = strdup(raw);
break;
case 'e':
cmos_enum = lookup_cmos_enum_by_value(option_table, cmos_entry->config_id, (u8*)raw);
*dest = strdup((const char*)cmos_enum->text);
break;
default: /* fail */
ret = 1;
}
free(raw);
return ret;
}
int set_option_from_string(const struct nvram_accessor *nvram, struct cb_cmos_option_table *option_table, const char *value, const char *name)
{
void *raw;
struct cb_cmos_entries *cmos_entry = lookup_cmos_entry(option_table, name);
if (!cmos_entry)
return 1;
struct cb_cmos_enums *cmos_enum;
switch (cmos_entry->config) {
case 'h':
/* only works on little endian */
raw = malloc(sizeof(u64));
*(u64*)raw = strtoull(value, NULL, 0);
break;
case 's':
raw = malloc(cmos_entry->length);
if (!raw)
return 1;
memset(raw, 0x00, cmos_entry->length);
strncpy(raw, value, cmos_entry->length);
break;
case 'e':
cmos_enum = lookup_cmos_enum_by_label(option_table, cmos_entry->config_id, value);
raw = malloc(sizeof(u32));
*(u32*)raw = cmos_enum->value;
break;
default: /* fail */
return 1;
}
int ret = set_option_with(nvram, option_table, raw, name);
free(raw);
return ret;
}