sim/mips/sky-vu1.c

   1 /*  Copyright (C) 1998, Cygnus Solutions
   2
   3     */
   4
   5 #include "sim-main.h"
   6
   7 #include "sky-device.h"
   8 #include "sky-vu1.h"
   9 #include "sky-libvpe.h"
  10 #include "sky-vu.h"
  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(void);
  18 void init_vu(VectorUnitState *state, char* umem_buffer, char* mem_buffer);
  19
  20 void
  21 vu1_issue(void)
  22 {
  23       if (vu1_state.runState == VU_RUN)
  24           vpecallms_cycle(&vu1_state);
  25 }
  26
  27 static 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, (int)addr, nr_bytes, (int)dest, space, *(int*)&(vu1_state.regs.VPE_STAT));
  58         printf("        vu1_state.regs.VPE_STAT = %x\n", *(int*)&(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 static 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 #if 0
  87 printf("%x,%x,%x,%x\n", &vu1_state.regs.VF[0][0], &vu1_state.regs.VPE_STAT,
  88                         ((char*)&vu1_state.regs.VPE_STAT) - ((char*)&vu1_state.regs.VF[0][0]),
  89                         ((char*)&vu1_state.regs.VPE_STAT) - ((char*)&vu1_state.regs.VF[0][0]) + VU1_REGISTER_WINDOW_START
  90      );
  91
  92 printf("%x,%x,%x,%x\n", &vu1_state.regs.VF[0][0], &vu1_state.regs.VI[0],
  93                         ((char*)&vu1_state.regs.VI[0]) - ((char*)&vu1_state.regs.VF[0][0]),
  94                         ((char*)&vu1_state.regs.VI[0]) - ((char*)&vu1_state.regs.VF[0][0]) + VU1_REGISTER_WINDOW_START
  95      );
  96 printf("%x,%x,%x,%x\n", &vu1_state.regs.VF[0][0], &vu1_state.regs.MST,
  97                         ((char*)&vu1_state.regs.MST) - ((char*)&vu1_state.regs.VF[0][0]),
  98                         ((char*)&vu1_state.regs.MST) - ((char*)&vu1_state.regs.VF[0][0]) + VU1_REGISTER_WINDOW_START
  99      );
 100 #endif
 101             return nr_bytes;
 102         }
 103
 104         printf("%s: Write: %x, %d, source: %x, space: %d!\n", me->name, (int)addr, nr_bytes, (int)source, space);
 105
 106         if (addr + nr_bytes > VU1_REGISTER_WINDOW_END) {
 107             fprintf(stderr, "Error: Read past end of vu1 register window!!!\n");
 108             exit(1);
 109         }
 110
 111         dest = ((char*) (&vu1_state.regs)) + (addr - VU1_REGISTER_WINDOW_START);
 112
 113         memcpy(dest, source, nr_bytes);
 114
 115         return nr_bytes;
 116 }
 117
 118 device vu1_device =
 119   {
 120     "vu1",
 121     &vu1_io_read_register_window,
 122     &vu1_io_write_register_window
 123   };
 124
 125 void
 126 vu1_init(SIM_DESC sd)
 127 {
 128
 129   sim_core_attach (sd,
 130                    NULL,
 131                    0 /*level*/,
 132                    access_read_write,
 133                    0 /*space ???*/,
 134                    VU1_REGISTER_WINDOW_START,
 135                    VU1_REGISTER_WINDOW_SIZE /*nr_bytes*/,
 136                    0 /*modulo*/,
 137                    &vu1_device,
 138                    NULL /*buffer*/);
 139
 140   sim_core_attach (sd,
 141                    NULL,
 142                    0 /*level*/,
 143                    access_read_write,
 144                    0 /*space ???*/,
 145                    VU1_MEM0_WINDOW_START,
 146                    VU1_MEM0_SIZE /*nr_bytes*/,
 147                    0 /*modulo*/,
 148                    0 /*device*/,
 149                    &vu1_umem_buffer /*buffer*/);
 150
 151   sim_core_attach (sd,
 152                    NULL,
 153                    0 /*level*/,
 154                    access_read_write,
 155                    0 /*space ???*/,
 156                    VU1_MEM1_WINDOW_START,
 157                    VU1_MEM1_SIZE /*nr_bytes*/,
 158                    0 /*modulo*/,
 159                    0 /*device*/,
 160                    &vu1_mem_buffer /*buffer*/);
 161
 162   init_vu1();
 163   /*initvpe();*/
 164   vpecallms_init(&vu1_state);
 165 }
 166
 167 /****************************************************************************/
 168 /*                                                                          */
 169 /*             Sony Computer Entertainment CONFIDENTIAL                     */
 170 /*      (C) 1997 Sony Computer Entertainment Inc. All Rights Reserved       */
 171 /*                                                                          */
 172 /*      VPE1 simulator                                                      */
 173 /*                                                                          */
 174 /****************************************************************************/
 175
 176 #include <stdio.h>
 177 #include <sys/types.h>
 178 #include <strings.h>
 179 #include "sky-libvpe.h"
 180
 181 char    ifilename[64] = "vu.bin";
 182 char    ofilename[64] = "";
 183 char    pfilename[64] = "";
 184
 185 static void abend2(char *fmt, char* p) {
 186     fprintf(stderr, fmt, p);
 187     exit(1);
 188 }
 189
 190 void getoption(void);
 191
 192 void init_vu1(void) {
 193     init_vu(&vu1_state, &vu1_umem_buffer[0], &vu1_mem_buffer[0]);
 194 }
 195
 196 void init_vu(VectorUnitState *state, char* umem_buffer, char* mem_buffer)
 197 {
 198         FILE *fp;
 199         int i, j;
 200         u_long  data[4];
 201
 202         /* set up memory buffers */
 203         state->uMEM = (uMEM_Entry_Type *) umem_buffer;
 204         state->MEM =  (MEM_Entry_Type*)   mem_buffer;
 205
 206         /* set up run state */
 207         state->runState = VU_READY;
 208
 209         /* read option */
 210         getoption();
 211
 212         /* read instruction file (mandatory) */
 213         if (*ifilename) {
 214                 if((fp = fopen(ifilename, "r")) != NULL) {
 215                         for (i = 0; fread(&data[0], 4, 1, fp) != 0; i++) {
 216                                 fread(&data[1], 4, 1, fp);
 217                                 LoadMMem(state, i, data, 1);
 218                         }
 219                         fclose(fp);
 220                 }
 221         }
 222
 223         /* PKE dirven simvpe */
 224         if (*pfilename) {
 225                 /* initpke(pfilename); */
 226                 initvpe(&vu1_state);
 227                 /* while (simpke() != -1)
 228                         simvpe(); */
 229         }
 230
 231         /* conventional simvpe */
 232         else {
 233                 initvpe(&vu1_state);
 234                 /*simvpe();*/
 235         }
 236
 237         /* write result memory image (optional) */
 238         if (*ofilename) {
 239                 if((fp = fopen(ofilename, "w")) == NULL)
 240                         abend2("%s: can not open\n", ofilename);
 241
 242                 for(i = 0; i < 2048; i++){
 243                         StoreVUMem(state, i, data, 1);
 244                         for(j = 0; j < 4; j++)
 245                                 fwrite(&data[j], 4, 1, fp);
 246                 }
 247                 fclose(fp);
 248         }
 249 }
 250
 251 #if 0
 252 static void Usage(void)
 253 {
 254         fprintf(stderr, "Usage: simvpe [options]\n");
 255         fprintf(stderr, "\t\t-i instruction-file\n");
 256         fprintf(stderr, "\t\t-o output-memory-file\n");
 257         fprintf(stderr, "\t\t-t PKE-file (text type)\n");
 258         fprintf(stderr, "\t\t-s start-address [default = 0]\n");
 259         fprintf(stderr, "\t\t-d [interactive mode enable: default desable]\n");
 260         fprintf(stderr, "\t\t-v [statistics mode enable: default desable]\n");
 261         fprintf(stderr, "\t\t-p [debug print mode enable: default desable]\n");
 262 }
 263 #endif
 264
 265 void getoption(void)
 266 {
 267 #if 0
 268         int startline = 0;
 269         int count = 1;
 270 #endif
 271
 272         _is_dbg = 1;
 273         _vpepc = 0;
 274         _is_verb = 0;
 275         _is_dump = 0;
 276         _pgpuif  = 2;
 277         _ITOP = 20;
 278         _TOP = 10;
 279
 280 #if 0
 281         while(argc - count){
 282                 if(argv[count][0] == '-'){
 283                         switch(argv[count][1]){
 284                                 case 'i':
 285                                         strcpy(ifilename, argv[count+1]);
 286                                         count += 2;
 287                                         break;
 288                                 case 'o':
 289                                         strcpy(ofilename, argv[count+1]);
 290                                         count += 2;
 291                                         break;
 292                                 case 't':
 293                                         strcpy(pfilename, argv[count+1]);
 294                                         count += 2;
 295                                         break;
 296                                 case 's':
 297                                         sscanf(argv[count+1], "%d", &startline);
 298                                         _vpepc = startline;
 299                                         count += 2;
 300                                         break;
 301                                 case 'd':
 302                                         _is_dbg = 1;
 303                                         count += 1;
 304                                         break;
 305                                 case 'v':
 306                                         _is_verb = 1;
 307                                         count += 1;
 308                                         break;
 309                                 case 'p':
 310                                         _is_dump = 1;
 311                                         count += 1;
 312                                         break;
 313                                 case 'h':
 314                                 case '?':
 315                                         Usage();
 316                                         exit(1);
 317                                         break;
 318                                 default:
 319                                         Usage();
 320                                         exit(1);
 321                         }
 322                 }else{
 323                         Usage();
 324                         exit(1);
 325                 }
 326         }
 327 #endif
 328 }