sim/mips/sky-vu1.c

   1 /*  Copyright (C) 1998, Cygnus Solutions
   2
   3     */
   4
   5 #include "sim-main.h"
   6
   7 #include "device.h"
   8 #include "vu1.h"
   9 #include "libvpe.h"
  10 #include "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();
  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>
 177 #include "libvpe.h"
 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) {
 212                 if((fp = fopen(ifilename, "r")) == NULL)
 213                         abend2("%s: can not open\n", ifilename);
 214
 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         /* PKE dirven simvpe */
 223         if (*pfilename) {
 224                 /* initpke(pfilename); */
 225                 initvpe(&vu1_state);
 226                 /* while (simpke() != -1)
 227                         simvpe(); */
 228         }
 229
 230         /* conventional simvpe */
 231         else {
 232                 initvpe(&vu1_state);
 233                 /*simvpe();*/
 234         }
 235
 236         /* write result memory image (optional) */
 237         if (*ofilename) {
 238                 if((fp = fopen(ofilename, "w")) == NULL)
 239                         abend2("%s: can not open\n", ofilename);
 240
 241                 for(i = 0; i < 2048; i++){
 242                         StoreVUMem(i, data, 1);
 243                         for(j = 0; j < 4; j++)
 244                                 fwrite(&data[j], 4, 1, fp);
 245                 }
 246                 fclose(fp);
 247         }
 248 }
 249
 250 static void Usage(void)
 251 {
 252         fprintf(stderr, "Usage: simvpe [options]\n");
 253         fprintf(stderr, "\t\t-i instruction-file\n");
 254         fprintf(stderr, "\t\t-o output-memory-file\n");
 255         fprintf(stderr, "\t\t-t PKE-file (text type)\n");
 256         fprintf(stderr, "\t\t-s start-address [default = 0]\n");
 257         fprintf(stderr, "\t\t-d [interactive mode enable: default desable]\n");
 258         fprintf(stderr, "\t\t-v [statistics mode enable: default desable]\n");
 259         fprintf(stderr, "\t\t-p [debug print mode enable: default desable]\n");
 260 }
 261
 262 void getoption()
 263 {
 264         int startline = 0;
 265         int count = 1;
 266
 267         _is_dbg = 1;
 268         _vpepc = 0;
 269         _is_verb = 0;
 270         _is_dump = 0;
 271         _pgpuif  = 2;
 272         _ITOP = 20;
 273         _TOP = 10;
 274
 275 #if 0
 276         while(argc - count){
 277                 if(argv[count][0] == '-'){
 278                         switch(argv[count][1]){
 279                                 case 'i':
 280                                         strcpy(ifilename, argv[count+1]);
 281                                         count += 2;
 282                                         break;
 283                                 case 'o':
 284                                         strcpy(ofilename, argv[count+1]);
 285                                         count += 2;
 286                                         break;
 287                                 case 't':
 288                                         strcpy(pfilename, argv[count+1]);
 289                                         count += 2;
 290                                         break;
 291                                 case 's':
 292                                         sscanf(argv[count+1], "%d", &startline);
 293                                         _vpepc = startline;
 294                                         count += 2;
 295                                         break;
 296                                 case 'd':
 297                                         _is_dbg = 1;
 298                                         count += 1;
 299                                         break;
 300                                 case 'v':
 301                                         _is_verb = 1;
 302                                         count += 1;
 303                                         break;
 304                                 case 'p':
 305                                         _is_dump = 1;
 306                                         count += 1;
 307                                         break;
 308                                 case 'h':
 309                                 case '?':
 310                                         Usage();
 311                                         exit(1);
 312                                         break;
 313                                 default:
 314                                         Usage();
 315                                         exit(1);
 316                         }
 317                 }else{
 318                         Usage();
 319                         exit(1);
 320                 }
 321         }
 322 #endif
 323 }