[deliverable/binutils-gdb.git] / sim / mips / sky-vu1.c

/*  Copyright (C) 1998, Cygnus Solutions

    */

#include "sim-main.h"

#include "sky-device.h"
#include "sky-vu1.h"
#include "sky-libvpe.h"
#include "sky-vu.h"

VectorUnitState vu1_state;

static char vu1_umem_buffer[VU1_MEM0_SIZE];
static char vu1_mem_buffer[VU1_MEM1_SIZE];

void init_vu1();
void init_vu(VectorUnitState *state, char* umem_buffer, char* mem_buffer);

void 
vu1_issue() 
{
      if (vu1_state.runState == VU_RUN)
          vpecallms_cycle(&vu1_state);
}

int
vu1_io_read_register_window(device *me,
                   void *dest,
                   int space,
                   address_word addr,
                   unsigned nr_bytes,
                   sim_cpu *processor,
                   sim_cia cia)
{
	/* Slow and crappy hack ... */

	int i;

	char source_buffer[VU1_REGISTER_WINDOW_SIZE];
	char* src;

	memcpy(source_buffer, &vu1_state.regs.VF[0][0], 0x200);	/* copy VF registers */	
	for (i = 0; i<16; i++ ) {
	    *(short*)&source_buffer[0x200 + i*16] = vu1_state.regs.VI[i];
	}
	*(u_long*)&source_buffer[VU1_MST - VU1_REGISTER_WINDOW_START] = vu1_state.regs.MST;
	*(u_long*)&source_buffer[VU1_MMC - VU1_REGISTER_WINDOW_START] = vu1_state.regs.MMC;
	*(u_long*)&source_buffer[VU1_MCP - VU1_REGISTER_WINDOW_START] = vu1_state.regs.MCP;
	*(u_long*)&source_buffer[VU1_MR  - VU1_REGISTER_WINDOW_START] = vu1_state.regs.MR;
	*(u_long*)&source_buffer[VU1_MI  - VU1_REGISTER_WINDOW_START] = vu1_state.regs.MI;
	*(u_long*)&source_buffer[VU1_MQ  - VU1_REGISTER_WINDOW_START] = vu1_state.regs.MQ;
	*(u_long*)&source_buffer[VU1_MP  - VU1_REGISTER_WINDOW_START] = vu1_state.regs.MP;
	*(u_long*)&source_buffer[VU1_MTPC - VU1_REGISTER_WINDOW_START] = vu1_state.regs.MTPC;
	*(VpeStat*)&source_buffer[VPE1_STAT - VU1_REGISTER_WINDOW_START] = vu1_state.regs.VPE_STAT;

	printf("%s: Read: %x, %d, dest: %x, space: %d, %x!\n", me->name, addr, nr_bytes, dest, space, vu1_state.regs.VPE_STAT);
	printf("	vu1_state.regs.VPE_STAT = %x\n", vu1_state.regs.VPE_STAT);

	if (addr + nr_bytes > VU1_REGISTER_WINDOW_END) {
	    fprintf(stderr, "Error: Read past end of vu1 register window!!!\n");
	    exit(1);
	}

	src = &source_buffer[0] + (addr - VU1_REGISTER_WINDOW_START);
	memcpy(dest, src, nr_bytes);
	return nr_bytes;
}

int
vu1_io_write_register_window(device *me,
                    const void *source,
                    int space,
                    address_word addr,
                    unsigned nr_bytes,
                    sim_cpu *processor,
                    sim_cia cia)
{
	char *dest;

	if (addr == VPE1_STAT && nr_bytes == 4) {
	    /* Magic to switch VU to run state, until other methods are available. */
	    vu1_state.runState = VU_RUN;
	    vu1_state.regs.VPE_STAT.vbs = 1;
printf("Magic start run...\n");
printf("%x,%x,%x,%x\n", &vu1_state.regs.VF[0][0], &vu1_state.regs.VPE_STAT,
			((char*)&vu1_state.regs.VPE_STAT) - ((char*)&vu1_state.regs.VF[0][0]),
			((char*)&vu1_state.regs.VPE_STAT) - ((char*)&vu1_state.regs.VF[0][0]) + VU1_REGISTER_WINDOW_START
     );

printf("%x,%x,%x,%x\n", &vu1_state.regs.VF[0][0], &vu1_state.regs.VI[0],
			((char*)&vu1_state.regs.VI[0]) - ((char*)&vu1_state.regs.VF[0][0]),
			((char*)&vu1_state.regs.VI[0]) - ((char*)&vu1_state.regs.VF[0][0]) + VU1_REGISTER_WINDOW_START
     );
printf("%x,%x,%x,%x\n", &vu1_state.regs.VF[0][0], &vu1_state.regs.MST,
			((char*)&vu1_state.regs.MST) - ((char*)&vu1_state.regs.VF[0][0]),
			((char*)&vu1_state.regs.MST) - ((char*)&vu1_state.regs.VF[0][0]) + VU1_REGISTER_WINDOW_START
     );
	    return nr_bytes;
	}

	printf("%s: Write: %x, %d, source: %x, space: %d!\n", me->name, addr, nr_bytes, source, space);

	if (addr + nr_bytes > VU1_REGISTER_WINDOW_END) {
	    fprintf(stderr, "Error: Read past end of vu1 register window!!!\n");
	    exit(1);
	}

	dest = ((char*) (&vu1_state.regs)) + (addr - VU1_REGISTER_WINDOW_START);

	memcpy(dest, source, nr_bytes);

	return nr_bytes;
}

device vu1_device = 
  { 
    "vu1", 
    &vu1_io_read_register_window,
    &vu1_io_write_register_window 
  };

void 
vu1_init(SIM_DESC sd) 
{

  sim_core_attach (sd,
		   NULL,
                   0 /*level*/,
                   access_read_write,
                   0 /*space ???*/,
                   VU1_REGISTER_WINDOW_START,
                   VU1_REGISTER_WINDOW_SIZE /*nr_bytes*/,
                   0 /*modulo*/,
                   &vu1_device,
                   NULL /*buffer*/);

  sim_core_attach (sd,
		   NULL,
                   0 /*level*/,
                   access_read_write,
                   0 /*space ???*/,
                   VU1_MEM0_WINDOW_START,
                   VU1_MEM0_SIZE /*nr_bytes*/,
                   0 /*modulo*/,
                   0 /*device*/,
                   &vu1_umem_buffer /*buffer*/);

  sim_core_attach (sd,
		   NULL,
                   0 /*level*/,
                   access_read_write,
                   0 /*space ???*/,
                   VU1_MEM1_WINDOW_START,
                   VU1_MEM1_SIZE /*nr_bytes*/,
                   0 /*modulo*/,
                   0 /*device*/,
                   &vu1_mem_buffer /*buffer*/);

  init_vu1();
  /*initvpe();*/
  vpecallms_init(&vu1_state);
}

/****************************************************************************/
/*                                                                          */
/*             Sony Computer Entertainment CONFIDENTIAL                     */
/*      (C) 1997 Sony Computer Entertainment Inc. All Rights Reserved       */
/*                                                                          */
/*      VPE1 simulator                                                      */
/*                                                                          */
/****************************************************************************/

#include <stdio.h>
#include <sys/types.h>
#include <strings.h>
#include "sky-libvpe.h"

char	ifilename[64] = "vu.bin";
char	ofilename[64] = "";
char	pfilename[64] = "";

void abend2(char *fmt, char* p) {
    fprintf(stderr, fmt, p);
    exit(1);
}

void getoption();

void init_vu1() {
    init_vu(&vu1_state, &vu1_umem_buffer[0], &vu1_mem_buffer[0]);
}

void init_vu(VectorUnitState *state, char* umem_buffer, char* mem_buffer)
{
	FILE *fp;
	int i, j;
	u_long	data[4];

	/* set up memory buffers */
	state->uMEM = (uMEM_Entry_Type *) umem_buffer;
	state->MEM =  (MEM_Entry_Type*)   mem_buffer;

	/* set up run state */
	state->runState = VU_READY;

	/* read option */
	getoption();

	/* read instruction file (mandatory) */
	if (*ifilename) {
		if((fp = fopen(ifilename, "r")) != NULL) {
			for (i = 0; fread(&data[0], 4, 1, fp) != 0; i++) {
				fread(&data[1], 4, 1, fp);
				LoadMMem(state, i, data, 1);
			}
			fclose(fp);
		}
	}
	
	/* PKE dirven simvpe */
	if (*pfilename) {
		/* initpke(pfilename); */
		initvpe(&vu1_state);
		/* while (simpke() != -1) 
			simvpe(); */
	}
	
	/* conventional simvpe */
	else {
		initvpe(&vu1_state);
		/*simvpe();*/
	}
	
	/* write result memory image (optional) */
	if (*ofilename) {
		if((fp = fopen(ofilename, "w")) == NULL)
			abend2("%s: can not open\n", ofilename);

		for(i = 0; i < 2048; i++){
			StoreVUMem(i, data, 1);
			for(j = 0; j < 4; j++)
				fwrite(&data[j], 4, 1, fp);
		}
		fclose(fp);
	}
}

static void Usage(void)
{
	fprintf(stderr, "Usage: simvpe [options]\n");
	fprintf(stderr, "\t\t-i instruction-file\n");
	fprintf(stderr, "\t\t-o output-memory-file\n");
	fprintf(stderr, "\t\t-t PKE-file (text type)\n");
	fprintf(stderr, "\t\t-s start-address [default = 0]\n");
	fprintf(stderr, "\t\t-d [interactive mode enable: default desable]\n");
	fprintf(stderr, "\t\t-v [statistics mode enable: default desable]\n");
	fprintf(stderr, "\t\t-p [debug print mode enable: default desable]\n");
}

void getoption()
{
	int startline = 0;
	int count = 1;

	_is_dbg = 1;
	_vpepc = 0;
	_is_verb = 0;
	_is_dump = 0;
	_pgpuif	 = 2;
	_ITOP = 20;
	_TOP = 10;

#if 0
	while(argc - count){
		if(argv[count][0] == '-'){
			switch(argv[count][1]){
				case 'i':
					strcpy(ifilename, argv[count+1]);
					count += 2;
					break;
				case 'o':
					strcpy(ofilename, argv[count+1]);
					count += 2;
					break;
				case 't':
					strcpy(pfilename, argv[count+1]);
					count += 2;
					break;
				case 's':
					sscanf(argv[count+1], "%d", &startline);
					_vpepc = startline;
					count += 2;
					break;
				case 'd':
					_is_dbg = 1;
					count += 1;
					break;
				case 'v':
					_is_verb = 1;
					count += 1;
					break;
				case 'p':
					_is_dump = 1;
					count += 1;
					break;
				case 'h':
				case '?':
					Usage();
					exit(1);
					break;
				default:
					Usage();
					exit(1);
			}
		}else{
			Usage();
			exit(1);
		}
	}
#endif
}
Commit	Line	Data
aea481da DE	1	/* Copyright (C) 1998, Cygnus Solutions
	2
	3	*/
	4
	5	#include "sim-main.h"
	6
803f52b9 DE	7	#include "sky-device.h"
	8	#include "sky-vu1.h"
	9	#include "sky-libvpe.h"
	10	#include "sky-vu.h"
aea481da DE	11
	12	VectorUnitState vu1_state;
	13
	14	static char vu1_umem_buffer[VU1_MEM0_SIZE];
	15	static char vu1_mem_buffer[VU1_MEM1_SIZE];
	16
	17	void init_vu1();
	18	void init_vu(VectorUnitState state, char umem_buffer, char* mem_buffer);
	19
	20	void
	21	vu1_issue()
	22	{
	23	if (vu1_state.runState == VU_RUN)
	24	vpecallms_cycle(&vu1_state);
	25	}
	26
	27	int
	28	vu1_io_read_register_window(device *me,
	29	void *dest,
	30	int space,
	31	address_word addr,
	32	unsigned nr_bytes,
	33	sim_cpu *processor,
	34	sim_cia cia)
	35	{
	36	/* Slow and crappy hack ... */
	37
	38	int i;
	39
	40	char source_buffer[VU1_REGISTER_WINDOW_SIZE];
	41	char* src;
	42
	43	memcpy(source_buffer, &vu1_state.regs.VF[0][0], 0x200); /* copy VF registers */
	44	for (i = 0; i<16; i++ ) {
	45	(short)&source_buffer[0x200 + i*16] = vu1_state.regs.VI[i];
	46	}
	47	(u_long)&source_buffer[VU1_MST - VU1_REGISTER_WINDOW_START] = vu1_state.regs.MST;
	48	(u_long)&source_buffer[VU1_MMC - VU1_REGISTER_WINDOW_START] = vu1_state.regs.MMC;
	49	(u_long)&source_buffer[VU1_MCP - VU1_REGISTER_WINDOW_START] = vu1_state.regs.MCP;
	50	(u_long)&source_buffer[VU1_MR - VU1_REGISTER_WINDOW_START] = vu1_state.regs.MR;
	51	(u_long)&source_buffer[VU1_MI - VU1_REGISTER_WINDOW_START] = vu1_state.regs.MI;
	52	(u_long)&source_buffer[VU1_MQ - VU1_REGISTER_WINDOW_START] = vu1_state.regs.MQ;
	53	(u_long)&source_buffer[VU1_MP - VU1_REGISTER_WINDOW_START] = vu1_state.regs.MP;
	54	(u_long)&source_buffer[VU1_MTPC - VU1_REGISTER_WINDOW_START] = vu1_state.regs.MTPC;
	55	(VpeStat)&source_buffer[VPE1_STAT - VU1_REGISTER_WINDOW_START] = vu1_state.regs.VPE_STAT;
	56
	57	printf("%s: Read: %x, %d, dest: %x, space: %d, %x!\n", me->name, addr, nr_bytes, dest, space, vu1_state.regs.VPE_STAT);
	58	printf(" vu1_state.regs.VPE_STAT = %x\n", vu1_state.regs.VPE_STAT);
	59
	60	if (addr + nr_bytes > VU1_REGISTER_WINDOW_END) {
	61	fprintf(stderr, "Error: Read past end of vu1 register window!!!\n");
	62	exit(1);
	63	}
	64
	65	src = &source_buffer[0] + (addr - VU1_REGISTER_WINDOW_START);
	66	memcpy(dest, src, nr_bytes);
	67	return nr_bytes;
	68	}
	69
	70	int
	71	vu1_io_write_register_window(device *me,
	72	const void *source,
	73	int space,
	74	address_word addr,
75	unsigned nr_bytes,
76	sim_cpu *processor,
77	sim_cia cia)
78	{
79	char *dest;
80
81	if (addr == VPE1_STAT && nr_bytes == 4) {
82	/* Magic to switch VU to run state, until other methods are available. */
83	vu1_state.runState = VU_RUN;
84	vu1_state.regs.VPE_STAT.vbs = 1;
85	printf("Magic start run...\n");
86	printf("%x,%x,%x,%x\n", &vu1_state.regs.VF[0][0], &vu1_state.regs.VPE_STAT,
87	((char)&vu1_state.regs.VPE_STAT) - ((char)&vu1_state.regs.VF[0][0]),
88	((char)&vu1_state.regs.VPE_STAT) - ((char)&vu1_state.regs.VF[0][0]) + VU1_REGISTER_WINDOW_START
89	);
90
91	printf("%x,%x,%x,%x\n", &vu1_state.regs.VF[0][0], &vu1_state.regs.VI[0],
92	((char)&vu1_state.regs.VI[0]) - ((char)&vu1_state.regs.VF[0][0]),
93	((char)&vu1_state.regs.VI[0]) - ((char)&vu1_state.regs.VF[0][0]) + VU1_REGISTER_WINDOW_START
94	);
95	printf("%x,%x,%x,%x\n", &vu1_state.regs.VF[0][0], &vu1_state.regs.MST,
96	((char)&vu1_state.regs.MST) - ((char)&vu1_state.regs.VF[0][0]),
97	((char)&vu1_state.regs.MST) - ((char)&vu1_state.regs.VF[0][0]) + VU1_REGISTER_WINDOW_START
98	);
99	return nr_bytes;
100	}
101
102	printf("%s: Write: %x, %d, source: %x, space: %d!\n", me->name, addr, nr_bytes, source, space);
103
104	if (addr + nr_bytes > VU1_REGISTER_WINDOW_END) {
105	fprintf(stderr, "Error: Read past end of vu1 register window!!!\n");
106	exit(1);
107	}
108
109	dest = ((char*) (&vu1_state.regs)) + (addr - VU1_REGISTER_WINDOW_START);
110
111	memcpy(dest, source, nr_bytes);
112
113	return nr_bytes;
114	}
115
116	device vu1_device =
117	{
118	"vu1",
119	&vu1_io_read_register_window,
120	&vu1_io_write_register_window
121	};
122
123	void
124	vu1_init(SIM_DESC sd)
125	{
126
127	sim_core_attach (sd,
128	NULL,
129	0 /level/,
130	access_read_write,
131	0 /space ???/,
132	VU1_REGISTER_WINDOW_START,
133	VU1_REGISTER_WINDOW_SIZE /nr_bytes/,
134	0 /modulo/,
135	&vu1_device,
136	NULL /buffer/);
137
138	sim_core_attach (sd,
139	NULL,
140	0 /level/,
141	access_read_write,
142	0 /space ???/,
143	VU1_MEM0_WINDOW_START,
144	VU1_MEM0_SIZE /nr_bytes/,
145	0 /modulo/,
146	0 /device/,
147	&vu1_umem_buffer /buffer/);
148
149	sim_core_attach (sd,
150	NULL,
151	0 /level/,
152	access_read_write,
153	0 /space ???/,
154	VU1_MEM1_WINDOW_START,
155	VU1_MEM1_SIZE /nr_bytes/,
156	0 /modulo/,
157	0 /device/,
158	&vu1_mem_buffer /buffer/);
159
160	init_vu1();
161	/initvpe();/
162	vpecallms_init(&vu1_state);
163	}
164
165	/****************************************************************************/
166	/* */
167	/* Sony Computer Entertainment CONFIDENTIAL */
168	/* (C) 1997 Sony Computer Entertainment Inc. All Rights Reserved */
169	/* */
170	/* VPE1 simulator */
171	/* */
172	/****************************************************************************/
173
174	#include <stdio.h>
175	#include <sys/types.h>
176	#include <strings.h>
72db5610	177	#include "sky-libvpe.h"
aea481da DE	178
	179	char ifilename[64] = "vu.bin";
	180	char ofilename[64] = "";
	181	char pfilename[64] = "";
	182
	183	void abend2(char fmt, char p) {
	184	fprintf(stderr, fmt, p);
	185	exit(1);
	186	}
	187
	188	void getoption();
	189
	190	void init_vu1() {
	191	init_vu(&vu1_state, &vu1_umem_buffer[0], &vu1_mem_buffer[0]);
	192	}
	193
	194	void init_vu(VectorUnitState state, char umem_buffer, char* mem_buffer)
	195	{
	196	FILE *fp;
	197	int i, j;
	198	u_long data[4];
	199
	200	/* set up memory buffers */
	201	state->uMEM = (uMEM_Entry_Type *) umem_buffer;
	202	state->MEM = (MEM_Entry_Type*) mem_buffer;
	203
	204	/* set up run state */
	205	state->runState = VU_READY;
	206
	207	/* read option */
	208	getoption();
	209
	210	/* read instruction file (mandatory) */
	211	if (*ifilename) {
dde66fa7 IC	212	if((fp = fopen(ifilename, "r")) != NULL) {
	213	for (i = 0; fread(&data[0], 4, 1, fp) != 0; i++) {
	214	fread(&data[1], 4, 1, fp);
	215	LoadMMem(state, i, data, 1);
	216	}
	217	fclose(fp);
aea481da	218	}
aea481da DE	219	}
	220
	221	/* PKE dirven simvpe */
	222	if (*pfilename) {
	223	/* initpke(pfilename); */
	224	initvpe(&vu1_state);
	225	/* while (simpke() != -1)
	226	simvpe(); */
	227	}
	228
	229	/* conventional simvpe */
	230	else {
	231	initvpe(&vu1_state);
	232	/simvpe();/
	233	}
	234
	235	/* write result memory image (optional) */
	236	if (*ofilename) {
	237	if((fp = fopen(ofilename, "w")) == NULL)
	238	abend2("%s: can not open\n", ofilename);
	239
	240	for(i = 0; i < 2048; i++){
	241	StoreVUMem(i, data, 1);
	242	for(j = 0; j < 4; j++)
	243	fwrite(&data[j], 4, 1, fp);
	244	}
	245	fclose(fp);
	246	}
	247	}
	248
	249	static void Usage(void)
	250	{
	251	fprintf(stderr, "Usage: simvpe [options]\n");
	252	fprintf(stderr, "\t\t-i instruction-file\n");
	253	fprintf(stderr, "\t\t-o output-memory-file\n");
	254	fprintf(stderr, "\t\t-t PKE-file (text type)\n");
	255	fprintf(stderr, "\t\t-s start-address [default = 0]\n");
	256	fprintf(stderr, "\t\t-d [interactive mode enable: default desable]\n");
	257	fprintf(stderr, "\t\t-v [statistics mode enable: default desable]\n");
	258	fprintf(stderr, "\t\t-p [debug print mode enable: default desable]\n");
	259	}
	260
	261	void getoption()
	262	{
	263	int startline = 0;
	264	int count = 1;
	265
	266	_is_dbg = 1;
	267	_vpepc = 0;
	268	_is_verb = 0;
	269	_is_dump = 0;
	270	_pgpuif = 2;
	271	_ITOP = 20;
	272	_TOP = 10;
	273
	274	#if 0
	275	while(argc - count){
	276	if(argv[count][0] == '-'){
	277	switch(argv[count][1]){
	278	case 'i':
	279	strcpy(ifilename, argv[count+1]);
	280	count += 2;
	281	break;
	282	case 'o':
283	strcpy(ofilename, argv[count+1]);
284	count += 2;
285	break;
286	case 't':
287	strcpy(pfilename, argv[count+1]);
288	count += 2;
289	break;
290	case 's':
291	sscanf(argv[count+1], "%d", &startline);
292	_vpepc = startline;
293	count += 2;
294	break;
295	case 'd':
296	_is_dbg = 1;
297	count += 1;
298	break;
299	case 'v':
300	_is_verb = 1;
301	count += 1;
302	break;
303	case 'p':
304	_is_dump = 1;
305	count += 1;
306	break;
307	case 'h':
308	case '?':
309	Usage();
310	exit(1);
311	break;
312	default:
313	Usage();
314	exit(1);
315	}
316	}else{
317	Usage();
318	exit(1);
319	}
320	}
321	#endif
322	}