mb: Set coreboot as DSDT's manufacturer model ID

[coreboot.git] / util / nvramtool / layout.c

/*****************************************************************************\
 * layout.c
 *****************************************************************************
 *  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 nvramtool, a utility for reading/writing coreboot
 *  parameters and displaying information from the coreboot table.
 *  For details, see https://coreboot.org/nvramtool.
 *
 *  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.
\*****************************************************************************/

#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 coreboot store the 3 pieces of information below in the
 * coreboot 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 coreboot 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 (e->bit % 8 && e->bit / 8 != (e->bit + e->length - 1) / 8)
                return LAYOUT_MULTIBYTE_ENTRY_NOT_ALIGNED;

        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;
}