kmx git

/*
* ========== Copyright Header Begin ==========================================
*
* Hypervisor Software File: mem-seeprom.c
* 
* Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
* 
*  - Do no alter or remove copyright notices
* 
*  - Redistribution and use of this software in source and binary forms, with 
*    or without modification, are permitted provided that the following 
*    conditions are met: 
* 
*  - Redistribution of source code must retain the above copyright notice, 
*    this list of conditions and the following disclaimer.
* 
*  - Redistribution 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. 
* 
*    Neither the name of Sun Microsystems, Inc. or the names of contributors 
* may be used to endorse or promote products derived from this software 
* without specific prior written permission. 
* 
*     This software is provided "AS IS," without a warranty of any kind. 
* ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, 
* INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A 
* PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN 
* MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR 
* ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR 
* DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN 
* OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR 
* FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE 
* DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY, 
* ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF 
* SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
* 
* You acknowledge that this software is not designed, licensed or
* intended for use in the design, construction, operation or maintenance of
* any nuclear facility. 
* 
* ========== Copyright Header End ============================================
*/
/*
 * id: @(#)mem-seeprom.c 1.4 05/11/15
 * purpose:
 * copyright: Copyright 2005 Sun Microsystems, Inc.  All Rights Reserved
 * copyright: Use is subject to license terms.
 */

#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <sys/param.h>
#include "gen-seeprom.h"
#include "mem-seeprom.h"
#include "prototypes.h"

struct fixed_seeprom mem_seeprom_data[] = {
	/*   name		size	type	value */
	{ NULL, 0, 0, 0, NULL},
};

static struct dimm_list_entry *dimm_list = NULL;
static struct dimm_list_entry *cur_dimm;

/* mem_layout is array of pointers to data for each memc */
static struct mem_data_entry *mem_layout = NULL;

static int max_bits = 0;
static int max_banks = 0;
static int num_dimms_per_bank = 0;
static int num_memc = 1;

static int cur_memc = 0;   /* bit_mask to indicate which memc data applies */
static int force_default_mc = 0;   /* support for older cfgs w/out memc_id */

static int max_encode_dimm_bits = 0;
static int max_dimms  = 0;
static int num_dimms_in_list = 0;
static int num_bits_in_list = 0;
static int *bit_to_dimm_map = NULL;
static int *bit_to_pin_map = NULL;

static int processing_dimm_list = 0;
static int processing_bit_map = 0;
static int table_width = 0;
static int memc_id_init = 0;

static int
parse_memc_id(char *line)
{
	unsigned int input_val;

	if (scan_line(line, &input_val) == ERROR)
		return (ERROR);

	/* For each memc_id, set the mask bit */
	if ((input_val >= 0) && (input_val < num_memc)) {
		cur_memc |= (1 << input_val);
		memc_id_init = 1;
	} else {
		print_error("Invalid memc_id\n");
		return (ERROR);
	}

	return (NO_ERROR);
}

static int
update_dimm_list(char *parameter, char *line)
{

	char temp[MAXNAMESIZE], input_str[DIMM_NAME_SIZE+1];

	if (strcmp("memc_id", parameter) == 0) {
		return (parse_memc_id(line));
	} else if (strcmp("DIMM", parameter) != 0) {
		fprintf(stderr, "%s is not a valid DIMM list parameter\n",
			parameter);
		return (ERROR);
	}
	if (sscanf(line, "%32s %s", temp, input_str) != 2) {
		fprintf(stderr, "DIMM list entries need 2 strings\n");
		return (ERROR);
	}
	if (strlen(input_str) > (DIMM_NAME_SIZE - 1)) {
		fprintf(stderr, "DIMM name cannot be greater than %d letters\n",
			DIMM_NAME_SIZE-1);
		return (ERROR);
	}

	if (dimm_list == NULL) {
		dimm_list = malloc(sizeof (struct dimm_list_entry));
		dimm_list->next = NULL;
		cur_dimm = dimm_list;
	} else {
		cur_dimm->next = malloc(sizeof (struct dimm_list_entry));
		cur_dimm = cur_dimm->next;
		cur_dimm->next = NULL;
	}
	num_dimms_in_list += 1;
	(void) strcpy(cur_dimm->name, input_str);
	return (NO_ERROR);
}

int prev_bit_num = 0;


static int
update_bit_map(char *parameter, char *line)
{
	int bit_num, dimm, pin_num;

	if (strcmp("memc_id", parameter) == 0) {
		return (parse_memc_id(line));
	}

	if (sscanf(line, "%d %d %d", &bit_num, &dimm, &pin_num) != 3) {
		fprintf(stderr, "bit map entries need 3 numeric values\n");
		return (ERROR);
	}

	if ((bit_num >= 0 && (bit_num < (max_bits))) &&
		(dimm >= 0 && (dimm < (num_dimms_per_bank))) &&
		(pin_num >= 0))  {
		bit_to_dimm_map[bit_num] = dimm;
		bit_to_pin_map[bit_num] = pin_num;
	} else {
		fprintf(stderr, "Invalid bit map entry for bit# %d\n", bit_num);
		fprintf(stderr, "bit#, dimm# and pin# must be >= 0, ");
		fprintf(stderr, " bit# must be < %d and dimm# < %d\n", max_bits,
			num_dimms_per_bank);
		return (ERROR);
	}

	num_bits_in_list++;

	return (NO_ERROR);

}

static int
mem_params(char *line, int *mem_data)
{
	char temp2[MAXNAMESIZE];
	int data = 0;

	if ((sscanf(line, "%32s %d", temp2, &data) != 2) || (data <= 0)) {
		return (ERROR);
	} else {
		*mem_data = data;
	}
	return (NO_ERROR);
}

static int
init_mem_params()
{
	int retval = NO_ERROR;

	if (table_width == 0) {
		print_error("table_width must be initialized!\n");
		retval = ERROR;
	}
	if (max_banks == 0) {
		print_error("max_banks must be initialized!\n");
		retval = ERROR;
	}
	if (max_bits == 0) {
		print_error("max_bits must be initialized!\n");
		retval = ERROR;
	}
	if (num_dimms_per_bank == 0) {
		print_error("num_dimms_per_bank must be initialized!\n");
		retval = ERROR;
	}
	if (mem_layout == NULL) {
		print_error("num_memc not initialized.  Assuming 1\n");
		mem_layout = malloc(sizeof (struct mem_data_entry));
		force_default_mc = 1;
	}
	return (retval);
}

int
mem_dynamic(char *parameter, char *line)
{

	int retval = NO_ERROR;
	unsigned long long temp;
	char temp2[MAXNAMESIZE];
	int count, i;

	if (strcmp(parameter, "table_width") == 0) {
		retval =  mem_params(line, &table_width);
	} else if (strcmp(parameter, "max_bits") == 0) {
		retval =  mem_params(line, &max_bits);
	} else if (strcmp(parameter, "max_banks") == 0) {
		retval =  mem_params(line, &max_banks);
	} else if (strcmp(parameter, "num_memc") == 0) {
		retval =  mem_params(line, &num_memc);
		if (mem_layout == NULL) {
			mem_layout =
			malloc(sizeof (struct mem_data_entry)*num_memc);
		} else {
			printf("ERROR: Already initialized num_memc\n");
			retval = ERROR;
		}
	} else if (strcmp(parameter, "num_dimms_per_bank") == 0) {
		retval = mem_params(line, &num_dimms_per_bank);
		if (retval != ERROR)  {
			max_dimms = num_dimms_per_bank * max_banks;
			max_encode_dimm_bits = 0;
			count = num_dimms_per_bank;
			while (count != 1) {
				count >>= 1;
				max_encode_dimm_bits++;
			}
		}
	} else if (processing_dimm_list) {
		if (strcmp(parameter, "dimm_list_end") == 0) {
			processing_dimm_list = 0;
			if (num_dimms_in_list !=
				(num_dimms_per_bank * max_banks)) {
				sprintf(err_string,
					"DIMM list must have %d names!\n",
					num_dimms_per_bank * max_banks);
				print_error(err_string);
				retval = ERROR;
			}
			if (force_default_mc) {
				cur_memc = 1;
			} else if (memc_id_init == 0) {
				print_error("Must init memc_id in dimm_list\n");
				retval = ERROR;
			}
			for (i = 0; i < num_memc; i++) {
				if (cur_memc & (1 << i)) {
					mem_layout[i].dimm_list = dimm_list;
				}
			}
			dimm_list = NULL;
		} else {
			retval = update_dimm_list(parameter, line);
		}
	} else if (processing_bit_map) {
		if (strcmp(parameter, "bit_map_end") == 0) {
			processing_bit_map = 0;
			if (num_bits_in_list != max_bits) {
				sprintf(err_string,
				    "Bit map has %d entries, should have %d!\n",
				    num_bits_in_list, max_bits);
				print_error(err_string);
				retval = ERROR;
			}
			if (force_default_mc) {
				cur_memc = 1;
			} else if (memc_id_init == 0) {
				print_error("Must init memc_id in bitmap\n");
				retval = ERROR;
			}
			for (i = 0; i < num_memc; i++) {
				if (cur_memc & (1 << i)) {
					mem_layout[i].bit_to_dimm_map =
						bit_to_dimm_map;
					mem_layout[i].bit_to_pin_map =
						bit_to_pin_map;
				}
			}
		} else {
			retval = update_bit_map(parameter, line);
		}
	} else if (strcmp(parameter, "dimm_list_start") == 0) {
		if (init_mem_params() == NO_ERROR) {
			num_dimms_in_list = 0;
			processing_dimm_list = 1;
			cur_memc = 0;
			memc_id_init = 0;
		} else
			retval = ERROR;
	} else if (strcmp(parameter, "dimm_list_end") == 0) {
		fprintf(stderr, "Missing dimm_list_start\n");
		retval = ERROR;
	} else if (strcmp(parameter, "bit_map_start") == 0) {
		if (init_mem_params() == NO_ERROR) {
			num_bits_in_list = 0;
			bit_to_dimm_map = malloc(max_bits * sizeof (int));
			bit_to_pin_map =  malloc(max_bits * sizeof (int));
			processing_bit_map = 1;
			cur_memc = 0;
			memc_id_init = 0;
		} else
			retval = ERROR;
	} else {
		retval = UNKNOWN;
	}
	return (retval);
}

static void
free_mem(void)
{
	struct dimm_list_entry *dimm_ptr, *tmp1;

	free(bit_to_dimm_map);
	free(bit_to_pin_map);

	dimm_ptr = dimm_list;
	while (dimm_ptr->next != NULL) {
		tmp1 = dimm_ptr->next;
		free(dimm_ptr);
		dimm_ptr = tmp1;
	}
	free(dimm_ptr);
}

void
write_mem(unsigned char **ptr)
{
	struct dimm_list_entry *dimm_ptr;
	unsigned char *p;
	int bits;
	int i, j, new_val, size;

	size = (max_dimms * DIMM_NAME_SIZE) + max_bits +
		(max_bits*max_encode_dimm_bits)/8 + TABLE_WIDTH_LEN + 1;
	store_bytes(4, (unsigned long long) size, ptr);

	for (j = 0; j < num_memc; j++) {
		dimm_ptr = mem_layout[j].dimm_list;
		while (dimm_ptr != NULL) {
			p = (unsigned char *) dimm_ptr->name;
			store_chars(DIMM_NAME_SIZE, p, ptr);
			dimm_ptr = dimm_ptr->next;
		}
		store_bytes(1, (unsigned long long) table_width, ptr);

		bits = max_bits - 1;
		while (bits >= 0) {
			new_val = 0;
			for (i = 8-max_encode_dimm_bits; i >= 0;
					i -= max_encode_dimm_bits) {
				new_val |=
				mem_layout[j].bit_to_dimm_map[bits--] << i;
			}
			store_bytes(1, (unsigned long long) new_val, ptr);
		}
		for (i = 0; i < max_bits; i++) {
			store_bytes(1,
			(unsigned long long) mem_layout[j].bit_to_pin_map[i],
			    ptr);
		}
		/* last byte ends in 0 */
		store_bytes(1, 0, ptr);
	}
}

void
dump_mem(void)
{
}

int
check_mem(void)
{
	return (0);
}

int
reg_mem(char *s1, data_reg **reg)
{
	return (0);
}
openbios/openboot/tools/gen-seeprom/mem-seeprom.c

Commit

tools/gen-seeprom/mem-seeprom.c
