Commit | Line | Data |
---|---|---|
aea481da DE |
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 | } |