Initial commit of OpenSPARC T2 architecture model.

[OpenSPARC-T2-SAM] / obp / tools / makedi.c

/*
* ========== Copyright Header Begin ==========================================
*
* Hypervisor Software File: makedi.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: @(#)makedi.c 1.12 06/02/16
 * purpose:
 * copyright: Copyright 2006 Sun Microsystems, Inc.  All Rights Reserved.
 * copyright: Use is subject to license terms.
 */

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#include <sys/dropins.h>

#define	MAX_DI		(4*1048*1024)

static int compress = 0;
static int verbose = 0;
static int list = 0;
static int group_mode = 0;

static uchar_t *prom;

int comp(unsigned char *src, int size, unsigned char *dest);

static void
usage(char *name)
{
	char *msg =
	    "%s: [-c] [-v] input1 name1 .. inputn namen\n"
	    "   -g   : group mode using src,dropin-name pairs\n"
	    "   -a   : create level2 using existing dropins\n"
	    "   -c   : compress dropins\n"
	    "   -v   : verbose mode\n"
	    "   -t   : list targets\n"
	    "   -s   : list sources\n"
	    "   -d   : list dependancies\n"
	    "   -o   : create a dropin from data\n"
	    "   -O   : overwrite any existing header\n"
	    "\n"
	    "for compress mode, each input will produce a file input.di\n"
	    "group mode changes the format of the args a little\n"
	    "-g <output> name input0 name0 .. intputn namen\n"
	    "-a <output> name input0 input1 .. inputn\n"
	    "-o <output> <srcfile> <diname>\n";

	fprintf(stderr, msg, name);
	exit(1);
}

static int
make_dropin(char *name, unsigned char *prom, unsigned char *buffer, int size)
{
	int crc, i, clen, dlen, compressed;
	unsigned char *pptr;
	obmd_t *di = (obmd_t *)prom;
	unsigned char *dataptr = prom+OBMD_HDR;

	memset((void *) prom, 0, OBMD_HDR);
	compressed = compress;
	if (compress) {
		compresshdr *chdr = (compresshdr *) dataptr;
		/* The magic number is always COMP */
		chdr->magic		= COMP_MAGIC;
		/*
		 * This is the compression type
		 * currently COMP for compress
		 */
		chdr->type		= COMP_MAGIC;
		chdr->decomp_size	= size;

		clen = comp(buffer, size, dataptr+sizeof (compresshdr));

		/* Now adjust the data size */
		clen += sizeof (compresshdr);
		chdr->comp_size = clen;

		if (clen >= size) {
			/*
			 * Compression didn't help this and in fact
			 * has added some bytes, so we undo the compression.
			 */
			compressed = 0;
			clen = size;
			memcpy((void *) dataptr, (void *) buffer, size);
		}
	} else {
		clen = size;
		memcpy((void *) dataptr, (void *) buffer, size);
	}

	strncpy(di->magic, "OBMD", 4);
	di->size  = clen;
	di->res0  = 0;
	di->res1  = 0;
	di->chksum = 0;
	if (strlen(name) > 15) {
		fprintf(stderr, "Error: dropin name > 15 characters\n");
		fprintf(stderr, "Error: -> %s\n", name);
		exit(1);
	}
	memset(di->name, 0, 16);
	strncpy(di->name, name, 15);
	crc = checksum((ushort_t *)di, clen+OBMD_HDR);
	di->chksum = crc;

	if (verbose) {
		printf(" Name: %s size = %lx", di->name, di->size);
		if (compressed)
			printf(" (-%d%%)", ((size-clen)*100)/size);
		printf(" checksum = %x ", di->chksum);
	}
	dlen = OBMD_HDR+clen;
	pptr = prom+dlen;
	if (dlen&3) {
		if (verbose) printf("(+%d)", (dlen&3));

		for (i = (3-(dlen&3)); i >= 0; i--, dlen++) *(pptr+i) = 1;
	}
	if (verbose) printf("\n");
	return (dlen);
}

char *
make_dropin_name(char *name)
{
	static char outname[40];
	char *dot;

	dot = strrchr(name, '/');
	if (dot)
		strcpy(outname, dot+1);
	else
		strcpy(outname, name);
	dot = strrchr(outname, '.');
	if (dot) *dot = 0;
	strcat(outname, ".di");
	return (outname);
}


void
write_dropin(char *argv[], char *name, unsigned char *prom, int dlen)
{
	int ofd;

	ofd = open(name, O_CREAT|O_TRUNC|O_RDWR, 0666);
	if (ofd < 0) {
		fprintf(stderr, "%s: Can't open output file %s\n",
		    argv[0], name);
		exit(1);
	} else {
		if (dlen > MAX_DI) {
			fprintf(stderr, "%s: Output %s exceeds %d bytes\n",
				argv[0], name, MAX_DI);
			exit(1);
		}
		if (write(ofd, prom, dlen) != dlen) {
			fprintf(stderr, "%s: Short write on %s\n",
				argv[0], name);
			exit(1);
		}
		close(ofd);
	}
}

/*
 * makedi [-c] <source> <dropin-name> [<source> <dropin-name>]
 */

void
main(int argc, char **argv)
{
	int ifd, ofd;
	int i;
	int pad = 512;
	struct stat statbuf;
	int c;
	char *group_name;
	char *group_file, *outfile = NULL;
	uchar_t *holding, *insert_pt;
	extern char *optarg;
	extern int optind;
	obmd_t *di;
	int arg_step = 2;
	int append_mode = 0;
	int overwrite = 0;
	int diupdate = 1;

	while ((c = getopt(argc, argv, "acCOvstdgGo:")) != EOF)
		switch (c) {
		case 'a':
			append_mode = 1;
			arg_step = 1;
			break;

		case 's':
			list = 's';
			break;

		case 't':
			list = 't';
			break;

		case 'd':
			list = 'd';
			break;

		case 'v':
			verbose++;
			break;

		case 'c':
			group_mode = 0;
			compress = 1;
			break;

		case 'C':
			group_mode = 0;
			compress = 0;
			break;

		case 'O':
			overwrite = 1;
			break;

		case 'g':
			compress = 0;
			group_mode = 1;
			break;

		case 'o':
			outfile = optarg;
			diupdate = 0;
			break;

		default:
			usage(argv[0]);
		}

	if (list) compress = 0, verbose = 0;
	if (append_mode) {
		if (list) list = 'd';
	}

	insert_pt = prom = (uchar_t *)malloc(MAX_DI);
	if (prom == NULL) {
		fprintf(stderr, "Malloc failed for dropin image\n");
		exit(1);
	}

	holding = (uchar_t *)malloc(MAX_DI);
	if (holding == NULL) {
		fprintf(stderr, "Malloc failed for holding buffer\n");
		exit(1);
	}

	/* Fill with FF */
	memset((void *) prom, 0xff, MAX_DI);
	if (group_mode || append_mode) {
		if (argv[optind] == NULL) {
			fprintf(stderr, "%s: Missing group name\n", argv[0]);
			exit(1);
		}
		group_file = strdup(make_dropin_name(argv[optind]));
		group_name = argv[optind+1];
		if (argv[optind+1] == NULL) {
			fprintf(stderr, "%s: Missing dropin name for %s\n",
			    argv[0], argv[optind]);
			exit(1);
		}
		optind += 2;
		/*
		 * reserve space for the dropin header and marker
		 */
		insert_pt += sizeof (obme_t);
	}

	di = (obmd_t *)holding;
	for (i = optind; i < argc; i += arg_step) {
		int dlen, len, tmp;
		char *outname;

		if ((!append_mode) && (argv[i+1] == NULL)) {
			fprintf(stderr, "%s: Missing dropin name for %s\n",
			    argv[0], argv[i]);
			exit(1);
		}

		if (outfile == NULL) {
		    outname = make_dropin_name(argv[i]);
		} else {
		    outname = outfile;
		}

		if (list) {
			switch (list) {
			case 't':
				if (group_mode) {
					static int once = 0;
					if (!once++)
						printf("%s ", group_file);
				} else {
					printf("%s ", outname);
				}
				break;

			case 's':
				printf("%s ", argv[i]);
				break;

			case 'd':
				if (group_mode || append_mode)
					printf("%s: %s\n",
					    group_file, argv[i]);
				else
					printf("%s: %s\n", outname, argv[i]);
				break;
			}
			continue;
		}

		if (verbose > 1) printf("Loading: %s\n", argv[i]);
		ifd = open(argv[i], O_RDONLY);
		if (ifd < 0) {
			fprintf(stderr,
			    "%s: Can't open input file %s\n",
			    argv[0], argv[i]);
			exit(1);
		}
		fstat(ifd, &statbuf);
		len = statbuf.st_size;
		if (len > MAX_DI) {
			fprintf(stderr, "%s: Input %s exceeds %d bytes\n",
				argv[0], argv[i], MAX_DI);
			exit(1);
		}
		memset((void *) holding, 0xff, MAX_DI);
		tmp = read(ifd, holding, len);
		if (tmp != len) {
			fprintf(stderr, "%s: Short read on %s\n",
				argv[0], argv[i]);
			exit(1);
		}
		close(ifd);
		if (verbose) {
			if (group_mode || append_mode)
				printf("Including: %s,", argv[i]);
			else
				printf("Writing: %s,", outname);
		}

		if (diupdate && (strncmp(di->magic, "OBMD", 4) == 0)) {
			unsigned int *dataptr;

			dataptr = (uint_t *)((uchar_t *)di + sizeof (obmd_t));

			if ((dataptr[0] == COMP_MAGIC) &&
			    (dataptr[1] == di->size)) {
				/*
				 * We can do nothing with dropins that are
				 * already compressed
				 */
				dlen = len;
				if (verbose) {
					printf(" Name: %s size = %lx (COMP)",
					    di->name, di->size);
					printf(" checksum = %x\n", di->chksum);
				}
				if ((group_mode) || (append_mode)) {
					memcpy((void *) insert_pt,
						(void *) holding, len);
				}
			} else {
				char *diname;

				/*
				 * Strip the dropin header off to leave the
				 * raw data and then compress it
				 */
				len -= OBMD_HDR;
				if (append_mode)
					diname = strdup(di->name);
				else
					diname = argv[i+1];
				memcpy((void *) holding,
				    (void *) (holding+OBMD_HDR),
				    len);
				dlen = make_dropin(diname,
				    insert_pt, holding, len);
			}
		} else {
			if (append_mode) {
				fprintf(stderr,
				    "%s: append_mode requires you to provide"
				    " a dropin list (%s)\n",
				    argv[0], argv[optind]);
				exit(1);
			} else {
				if (overwrite) {
					dlen = make_dropin(argv[i+1],
					    insert_pt, (holding + OBMD_HDR),
					    (len - OBMD_HDR));
				} else {
					dlen = make_dropin(argv[i+1],
					    insert_pt, holding, len);
				}
			}
		}

		if (group_mode || append_mode) {
			insert_pt += (dlen + 3) & ~3;
		} else {
			write_dropin(argv, outname, prom, dlen);
		}
	}
	if (group_mode || append_mode) {
		int flen;
		char *outname;
		int bytes;

		bytes = insert_pt - prom;
		if (bytes&3) {
			for (i = (4-(bytes&3)); i > 0; i--, bytes++)
				*insert_pt++ = 1;
		}
		for (i = 4; i > 0; i--, bytes++) *insert_pt++ = 0xff;
		if (verbose) printf("Writing: %s,", group_file);
		strncpy((char *)prom, "OBME", 4);
		memcpy((void *)holding, (void *)prom, bytes);
		flen = make_dropin(group_name, prom, holding, bytes);
		write_dropin(argv, group_file, prom, flen);
	}
	free(holding);
	free(prom);
	exit(0);
}