coreboot-kgpe-d16/util/lxbios/layout.c

514 lines
17 KiB
C
Raw Normal View History

/*****************************************************************************\
* layout.c
* $Id: layout.c,v 1.2 2006/01/24 00:25:40 dsp_llnl Exp $
*****************************************************************************
* Copyright (C) 2002-2005 The Regents of the University of California.
* Produced at the Lawrence Livermore National Laboratory.
* Written by Dave Peterson <dsp@llnl.gov> <dave_peterson@pobox.com>.
* UCRL-CODE-2003-012
* All rights reserved.
*
* This file is part of lxbios, a utility for reading/writing LinuxBIOS
* parameters and displaying information from the LinuxBIOS table.
* For details, see <http://www.llnl.gov/linux/lxbios/>.
*
* Please also read the file DISCLAIMER which is included in this software
* distribution.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License (as published by the
* Free Software Foundation) version 2, dated June 1991.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the IMPLIED WARRANTY OF
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the terms and
* conditions of the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
\*****************************************************************************/
#include "common.h"
#include "layout.h"
#include "cmos_lowlevel.h"
typedef struct cmos_entry_item_t cmos_entry_item_t;
struct cmos_entry_item_t
{ cmos_entry_t item;
cmos_entry_item_t *next;
};
typedef struct cmos_enum_item_t cmos_enum_item_t;
struct cmos_enum_item_t
{ cmos_enum_t item;
cmos_enum_item_t *next;
};
static void default_cmos_layout_get_fn (void);
static int areas_overlap (unsigned area_0_start, unsigned area_0_length,
unsigned area_1_start, unsigned area_1_length);
static int entries_overlap (const cmos_entry_t *p, const cmos_entry_t *q);
static const cmos_enum_item_t * find_first_cmos_enum_id (unsigned config_id);
const char checksum_param_name[] = "check_sum";
/* Newer versions of LinuxBIOS store the 3 pieces of information below in the
* LinuxBIOS table so we don't have to rely on hardcoded values.
*/
/* This is the offset from the start of CMOS of the first byte that the
* checksum is calculated over.
*/
#define CMOS_CHECKSUM_START 49
/* This is the offset from the start of CMOS of the last byte that the
* checksum is calculated over.
*/
#define CMOS_CHECKSUM_END 125
/* This is the offset from the start of CMOS where the LinuxBIOS checksum is
* stored.
*/
#define CMOS_CHECKSUM_INDEX 126
/* index of first byte of checksummed area */
unsigned cmos_checksum_start = CMOS_CHECKSUM_START;
/* index of last byte of checksummed area */
unsigned cmos_checksum_end = CMOS_CHECKSUM_END;
/* index of first byte of CMOS checksum (a big-endian 16-bit value) */
unsigned cmos_checksum_index = CMOS_CHECKSUM_INDEX;
/* List is sorted in ascending order according to 'bit' field in
* cmos_entry_t.
*/
static cmos_entry_item_t *cmos_entry_list = NULL;
/* List is sorted in ascending order: first by 'config_id' and then by
* 'value'.
*/
static cmos_enum_item_t *cmos_enum_list = NULL;
static cmos_layout_get_fn_t cmos_layout_get_fn = default_cmos_layout_get_fn;
/****************************************************************************
* entries_overlap
*
* Return 1 if cmos entries 'p' and 'q' overlap. Else return 0.
****************************************************************************/
static inline int entries_overlap (const cmos_entry_t *p,
const cmos_entry_t *q)
{ return areas_overlap(p->bit, p->length, q->bit, q->length); }
/****************************************************************************
* cmos_entry_to_const_item
*
* Return a pointer to the cmos_entry_item_t that 'p' is embedded within.
****************************************************************************/
static inline const cmos_entry_item_t * cmos_entry_to_const_item
(const cmos_entry_t *p)
{ static const cmos_entry_t *pos = &((cmos_entry_item_t *) 0)->item;
unsigned long offset, address;
offset = (unsigned long) pos;
address = ((unsigned long) p) - offset;
return (const cmos_entry_item_t *) address;
}
/****************************************************************************
* cmos_enum_to_const_item
*
* Return a pointer to the cmos_enum_item_t that 'p' is embedded within.
****************************************************************************/
static inline const cmos_enum_item_t * cmos_enum_to_const_item
(const cmos_enum_t *p)
{ static const cmos_enum_t *pos = &((cmos_enum_item_t *) 0)->item;
unsigned long offset, address;
offset = (unsigned long) pos;
address = ((unsigned long) p) - offset;
return (const cmos_enum_item_t *) address;
}
/****************************************************************************
* register_cmos_layout_get_fn
*
* Set 'fn' as the function that will be called to retrieve CMOS layout
* information.
****************************************************************************/
void register_cmos_layout_get_fn (cmos_layout_get_fn_t fn)
{ cmos_layout_get_fn = fn; }
/****************************************************************************
* get_cmos_layout
*
* Retrieve CMOS layout information and store it in our internal repository.
****************************************************************************/
void get_cmos_layout (void)
{ cmos_layout_get_fn(); }
/****************************************************************************
* add_cmos_entry
*
* Attempt to add CMOS entry 'e' to our internal repository of layout
* information. Return OK on success or an error code on failure. If
* operation fails because 'e' overlaps an existing CMOS entry, '*conflict'
* will be set to point to the overlapping entry.
****************************************************************************/
int add_cmos_entry (const cmos_entry_t *e, const cmos_entry_t **conflict)
{ cmos_entry_item_t *item, *prev, *new_entry;
*conflict = NULL;
if (e->length < 1)
return LAYOUT_ENTRY_BAD_LENGTH;
if ((new_entry = (cmos_entry_item_t *) malloc(sizeof(*new_entry))) == NULL)
out_of_memory();
new_entry->item = *e;
if (cmos_entry_list == NULL)
{ new_entry->next = NULL;
cmos_entry_list = new_entry;
return OK;
}
/* Find place in list to insert new entry. List is sorted in ascending
* order.
*/
for (item = cmos_entry_list, prev = NULL;
(item != NULL) && (item->item.bit < e->bit);
prev = item, item = item->next);
if (prev == NULL)
{ if (entries_overlap(e, &cmos_entry_list->item))
{ *conflict = &cmos_entry_list->item;
goto fail;
}
new_entry->next = cmos_entry_list;
cmos_entry_list = new_entry;
return OK;
}
if (entries_overlap(&prev->item, e))
{ *conflict = &prev->item;
goto fail;
}
if ((item != NULL) && entries_overlap(e, &item->item))
{ *conflict = &item->item;
goto fail;
}
new_entry->next = item;
prev->next = new_entry;
return OK;
fail:
free(new_entry);
return LAYOUT_ENTRY_OVERLAP;
}
/****************************************************************************
* find_cmos_entry
*
* Search for a CMOS entry whose name is 'name'. Return pointer to matching
* entry or NULL if entry not found.
****************************************************************************/
const cmos_entry_t * find_cmos_entry (const char name[])
{ cmos_entry_item_t *item;
for (item = cmos_entry_list; item != NULL; item = item->next)
{ if (!strcmp(item->item.name, name))
return &item->item;
}
return NULL;
}
/****************************************************************************
* first_cmos_entry
*
* Return a pointer to the first CMOS entry in our list or NULL if list is
* empty.
****************************************************************************/
const cmos_entry_t * first_cmos_entry (void)
{ return (cmos_entry_list == NULL) ? NULL : &cmos_entry_list->item; }
/****************************************************************************
* next_cmos_entry
*
* Return a pointer to next entry in list after 'last' or NULL if no more
* entries.
****************************************************************************/
const cmos_entry_t * next_cmos_entry (const cmos_entry_t *last)
{ const cmos_entry_item_t *last_item, *next_item;
last_item = cmos_entry_to_const_item(last);
next_item = last_item->next;
return (next_item == NULL) ? NULL : &next_item->item;
}
/****************************************************************************
* add_cmos_enum
*
* Attempt to add CMOS enum 'e' to our internal repository of layout
* information. Return OK on success or an error code on failure.
****************************************************************************/
int add_cmos_enum (const cmos_enum_t *e)
{ cmos_enum_item_t *item, *prev, *new_enum;
if ((new_enum = (cmos_enum_item_t *) malloc(sizeof(*new_enum))) == NULL)
out_of_memory();
new_enum->item = *e;
if (cmos_enum_list == NULL)
{ new_enum->next = NULL;
cmos_enum_list = new_enum;
return OK;
}
/* The list of enums is sorted in ascending order, first by 'config_id' and
* then by 'value'. Look for the first enum whose 'config_id' field
* matches 'e'.
*/
for (item = cmos_enum_list, prev = NULL;
(item != NULL) && (item->item.config_id < e->config_id);
prev = item, item = item->next);
if (item == NULL)
{ new_enum->next = NULL;
prev->next = new_enum;
return OK;
}
if (item->item.config_id > e->config_id)
{ new_enum->next = item;
if (prev == NULL)
cmos_enum_list = new_enum;
else
prev->next = new_enum;
return OK;
}
/* List already contains at least one enum whose 'config_id' matches 'e'.
* Now find proper place to insert 'e' based on 'value'.
*/
while (item->item.value < e->value)
{ prev = item;
item = item->next;
if ((item == NULL) || (item->item.config_id != e->config_id))
{ new_enum->next = item;
prev->next = new_enum;
return OK;
}
}
if (item->item.value == e->value)
{ free(new_enum);
return LAYOUT_DUPLICATE_ENUM;
}
new_enum->next = item;
if (prev == NULL)
cmos_enum_list = new_enum;
else
prev->next = new_enum;
return OK;
}
/****************************************************************************
* find_cmos_enum
*
* Search for an enum that matches 'config_id' and 'value'. If found, return
* a pointer to the mathcing enum. Else return NULL.
****************************************************************************/
const cmos_enum_t * find_cmos_enum (unsigned config_id,
unsigned long long value)
{ const cmos_enum_item_t *item;
if ((item = find_first_cmos_enum_id(config_id)) == NULL)
return NULL;
while (item->item.value < value)
{ item = item->next;
if ((item == NULL) || (item->item.config_id != config_id))
return NULL;
}
return (item->item.value == value) ? &item->item : NULL;
}
/****************************************************************************
* first_cmos_enum
*
* Return a pointer to the first CMOS enum in our list or NULL if list is
* empty.
****************************************************************************/
const cmos_enum_t * first_cmos_enum (void)
{ return (cmos_enum_list == NULL) ? NULL : &cmos_enum_list->item; }
/****************************************************************************
* next_cmos_enum
*
* Return a pointer to next enum in list after 'last' or NULL if no more
* enums.
****************************************************************************/
const cmos_enum_t * next_cmos_enum (const cmos_enum_t *last)
{ const cmos_enum_item_t *last_item, *next_item;
last_item = cmos_enum_to_const_item(last);
next_item = last_item->next;
return (next_item == NULL) ? NULL : &next_item->item;
}
/****************************************************************************
* first_cmos_enum_id
*
* Return a pointer to the first CMOS enum in our list that matches
* 'config_id' or NULL if there are no matching enums.
****************************************************************************/
const cmos_enum_t * first_cmos_enum_id (unsigned config_id)
{ const cmos_enum_item_t *item;
item = find_first_cmos_enum_id(config_id);
return (item == NULL) ? NULL : &item->item;
}
/****************************************************************************
* next_cmos_enum_id
*
* Return a pointer to next enum in list after 'last' that matches the
* 'config_id' field of 'last' or NULL if there are no more matching enums.
****************************************************************************/
const cmos_enum_t * next_cmos_enum_id (const cmos_enum_t *last)
{ const cmos_enum_item_t *item;
item = cmos_enum_to_const_item(last)->next;
return ((item == NULL) || (item->item.config_id != last->config_id)) ?
NULL : &item->item;
}
/****************************************************************************
* is_checksum_name
*
* Return 1 if 'name' matches the name of the parameter representing the CMOS
* checksum. Else return 0.
****************************************************************************/
int is_checksum_name (const char name[])
{ return !strcmp(name, checksum_param_name); }
/****************************************************************************
* checksum_layout_to_bytes
*
* On entry, '*layout' contains checksum-related layout information expressed
* in bits. Perform sanity checking on the information and convert it from
* bit positions to byte positions. Return OK on success or an error code if
* a sanity check fails.
****************************************************************************/
int checksum_layout_to_bytes (cmos_checksum_layout_t *layout)
{ unsigned start, end, index;
start = layout->summed_area_start;
end = layout->summed_area_end;
index = layout->checksum_at;
if (start % 8)
return LAYOUT_SUMMED_AREA_START_NOT_ALIGNED;
if ((end % 8) != 7)
return LAYOUT_SUMMED_AREA_END_NOT_ALIGNED;
if (index % 8)
return LAYOUT_CHECKSUM_LOCATION_NOT_ALIGNED;
if (end <= start)
return LAYOUT_INVALID_SUMMED_AREA;
/* Convert bit positions to byte positions. */
start /= 8;
end /= 8; /* equivalent to "end = ((end - 7) / 8)" */
index /= 8;
if (verify_cmos_byte_index(start) || verify_cmos_byte_index(end))
return LAYOUT_SUMMED_AREA_OUT_OF_RANGE;
if (verify_cmos_byte_index(index))
return LAYOUT_CHECKSUM_LOCATION_OUT_OF_RANGE;
/* checksum occupies 16 bits */
if (areas_overlap(start, end - start + 1, index, index + 1))
return LAYOUT_CHECKSUM_OVERLAPS_SUMMED_AREA;
layout->summed_area_start = start;
layout->summed_area_end = end;
layout->checksum_at = index;
return OK;
}
/****************************************************************************
* checksum_layout_to_bits
*
* On entry, '*layout' contains checksum-related layout information expressed
* in bytes. Convert this information to bit positions.
****************************************************************************/
void checksum_layout_to_bits (cmos_checksum_layout_t *layout)
{ layout->summed_area_start *= 8;
layout->summed_area_end = (layout->summed_area_end * 8) + 7;
layout->checksum_at *= 8;
}
/****************************************************************************
* default_cmos_layout_get_fn
*
* If this function is ever called, it means that an appropriate callback for
* obtaining CMOS layout information was not set before attempting to
* retrieve layout information.
****************************************************************************/
static void default_cmos_layout_get_fn (void)
{ BUG(); }
/****************************************************************************
* areas_overlap
*
* Return 1 if the two given areas overlap. Else return 0.
****************************************************************************/
static int areas_overlap (unsigned area_0_start, unsigned area_0_length,
unsigned area_1_start, unsigned area_1_length)
{ unsigned area_0_end, area_1_end;
area_0_end = area_0_start + area_0_length - 1;
area_1_end = area_1_start + area_1_length - 1;
return ((area_1_start <= area_0_end) && (area_0_start <= area_1_end));
}
/****************************************************************************
* find_first_cmos_enum_id
*
* Return a pointer to the first item in our list of enums that matches
* 'config_id'. Return NULL if there is no matching enum.
****************************************************************************/
static const cmos_enum_item_t * find_first_cmos_enum_id (unsigned config_id)
{ cmos_enum_item_t *item;
for (item = cmos_enum_list;
(item != NULL) && (item->item.config_id < config_id);
item = item->next);
return ((item == NULL) || (item->item.config_id > config_id)) ?
NULL : item;
}