You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
310 lines
7.1 KiB
310 lines
7.1 KiB
/* Copyright (C) 1998, Cygnus Solutions
|
|
|
|
*/
|
|
|
|
#include "sim-main.h"
|
|
#include "sim-endian.h"
|
|
|
|
#include "sky-device.h"
|
|
#include "sky-vu1.h"
|
|
#include "sky-libvpe.h"
|
|
#include "sky-vu.h"
|
|
#include "sky-bits.h"
|
|
|
|
#include <assert.h>
|
|
|
|
VectorUnitState vu1_state;
|
|
|
|
#define sim_warning printf
|
|
|
|
/* these are aligned versions of zalloc() pointers - do not zfree()! */
|
|
static char* vu1_umem_buffer = 0;
|
|
static char* vu1_mem_buffer = 0;
|
|
|
|
void init_vu1(void);
|
|
void init_vu(VectorUnitState *state,
|
|
char* umem_buffer, unsigned umem_dw_size,
|
|
char* mem_buffer, unsigned mem_qw_size);
|
|
|
|
#if 0
|
|
static void dump_mem() {
|
|
int i;
|
|
typedef int T[2048][4];
|
|
T *mem = (T*)&vu1_mem_buffer;
|
|
|
|
for (i = 0; i < 200; i++) {
|
|
printf("%d: %x %x %x %x\n", i, (*mem)[i][0], (*mem)[i][1], (*mem)[i][2], (*mem)[i][3]);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
void
|
|
vu1_issue(void)
|
|
{
|
|
if (vu1_state.runState == VU_RUN)
|
|
vpecallms_cycle(&vu1_state);
|
|
}
|
|
|
|
static int
|
|
vu1_io_read_register_window(device *me,
|
|
void *dest,
|
|
int space,
|
|
address_word addr,
|
|
unsigned nr_bytes,
|
|
sim_cpu *processor,
|
|
sim_cia cia)
|
|
{
|
|
if (addr < VU1_REGISTER_WINDOW_START)
|
|
return 0;
|
|
|
|
addr -= VU1_REGISTER_WINDOW_START;
|
|
|
|
/* Adjust nr_bytes if too big */
|
|
if ((addr + nr_bytes) > VU_REG_END)
|
|
nr_bytes -= addr + nr_bytes - VU_REG_END;
|
|
|
|
return read_vu_registers (&vu1_state, addr, nr_bytes, dest);
|
|
}
|
|
|
|
static 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)
|
|
{
|
|
if (addr < VU1_REGISTER_WINDOW_START)
|
|
return 0;
|
|
|
|
addr -= VU1_REGISTER_WINDOW_START;
|
|
|
|
/* Adjust nr_bytes if too big */
|
|
if ((addr + nr_bytes) > VU_REG_END)
|
|
nr_bytes -= addr + nr_bytes - VU_REG_END;
|
|
|
|
return write_vu_registers (&vu1_state, addr, nr_bytes, source);
|
|
}
|
|
|
|
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,
|
|
VU_REG_END /*nr_bytes*/,
|
|
0 /*modulo*/,
|
|
&vu1_device,
|
|
NULL /*buffer*/);
|
|
|
|
vu1_umem_buffer = zalloc(VU1_MEM0_SIZE);
|
|
vu1_umem_buffer = (void*) ALIGN_16((unsigned)vu1_umem_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*/);
|
|
|
|
vu1_mem_buffer = zalloc(VU1_MEM1_SIZE + 2*sizeof(unsigned_16));
|
|
vu1_mem_buffer = (void*) ALIGN_16((unsigned)vu1_mem_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] = "";
|
|
|
|
static void abend2(char *fmt, char* p) {
|
|
fprintf(stderr, fmt, p);
|
|
exit(1);
|
|
}
|
|
|
|
void getoption(VectorUnitState* state);
|
|
|
|
void init_vu1(void) {
|
|
init_vu(&vu1_state,
|
|
&vu1_umem_buffer[0], VU1_MEM0_SIZE/8,
|
|
&vu1_mem_buffer[0], VU1_MEM1_SIZE/16);
|
|
}
|
|
|
|
void init_vu(VectorUnitState *state,
|
|
char* umem_buffer, unsigned umem_dw_size,
|
|
char* mem_buffer, unsigned mem_qw_size)
|
|
{
|
|
FILE *fp;
|
|
int i, j;
|
|
u_long data[4];
|
|
|
|
/* set up memory buffers */
|
|
state->uMEM_buffer = (uMEM_Entry_Type *) umem_buffer;
|
|
state->uMEM_size = umem_dw_size;
|
|
state->MEM_buffer = (MEM_Entry_Type*) mem_buffer;
|
|
state->MEM_size = mem_qw_size;
|
|
|
|
/* set up run state */
|
|
state->runState = VU_READY;
|
|
|
|
/* read option */
|
|
getoption(state);
|
|
|
|
/* 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(state, i, data, 1);
|
|
for(j = 0; j < 4; j++)
|
|
fwrite(&data[j], 4, 1, fp);
|
|
}
|
|
fclose(fp);
|
|
}
|
|
}
|
|
|
|
#if 0
|
|
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");
|
|
}
|
|
#endif
|
|
|
|
void getoption(VectorUnitState* state)
|
|
{
|
|
#if 0
|
|
int startline = 0;
|
|
int count = 1;
|
|
#endif
|
|
|
|
state->junk._is_dbg = 1;
|
|
state->junk._vpepc = 0;
|
|
state->junk._is_verb = 0;
|
|
state->junk._is_dump = 0;
|
|
state->junk._pgpuif = 4; /* MEMGPUIF */
|
|
state->junk._ITOP = 20;
|
|
state->junk._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);
|
|
state->junk._vpepc = startline;
|
|
count += 2;
|
|
break;
|
|
case 'd':
|
|
state->junk._is_dbg = 1;
|
|
count += 1;
|
|
break;
|
|
case 'v':
|
|
state->junk._is_verb = 1;
|
|
count += 1;
|
|
break;
|
|
case 'p':
|
|
state->junk._is_dump = 1;
|
|
count += 1;
|
|
break;
|
|
case 'h':
|
|
case '?':
|
|
Usage();
|
|
exit(1);
|
|
break;
|
|
default:
|
|
Usage();
|
|
exit(1);
|
|
}
|
|
}else{
|
|
Usage();
|
|
exit(1);
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|