1 // FinalBurn Neo Seibu SPI System driver module
2 // Based on MAME driver by Ville Linde, hap, Nicola Salmoria
3
4 /*
5 Notes:
6 Raiden Fighters 2 has a problem with flip screen handling *fixed with hack, read on*
7 - even with it disabled, it doesn't seem to respect the setting
8 - force it by going into the diagnostics and exiting, then resetting the game
9 - right now use default NVRAM data - only needs the first 32 bytes is necessary to correct the issue
10 - works with single board versions, use default EEPROM data
11
12 to do:
13 test extensively
14 */
15
16 #include "tiles_generic.h"
17 #include "i386_intf.h"
18 #include "z80_intf.h"
19 #include "msm6295.h"
20 #include "burn_ymf271.h"
21 #include "ymz280b.h"
22 #include "ds2404.h"
23 #include "intelfsh.h"
24 #include "eeprom.h"
25 #include "burn_pal.h"
26 #include "bitswap.h"
27
28 static UINT8 *AllMem;
29 static UINT8 *AllRam;
30 static UINT8 *RamEnd;
31 static UINT8 *MemEnd;
32 static UINT8 *DrvMainROM;
33 static UINT8 *DrvZ80RAM;
34 static UINT8 *DrvZ80WorkRAM;
35 static UINT8 *DrvGfxROM[3];
36 static UINT8 *DrvSndROM[2];
37 static UINT8 *DefaultEEPROM;
38 static UINT8 *DrvMainRAM;
39 static UINT32 *mainram;
40 static UINT32 *tilemap_ram;
41 static UINT16 *tilemap_ram16; // for tilemap_callbacks
42 static UINT32 *palette_ram;
43 static UINT32 *sprite_ram;
44 static UINT8 *DrvCRTCRAM;
45 static const UINT8 *DefaultNVRAM = NULL;
46 static UINT8 *DrvAlphaTable;
47 static UINT32 *bitmap32;
48 static UINT16 *tempdraw;
49
50 static UINT32 *DrvPalette;
51 static UINT8 DrvRecalc;
52
53 static INT32 nExtraCycles;
54
55 static UINT32 video_dma_length;
56 static UINT32 video_dma_address;
57 static INT32 rowscroll_enable;
58 static INT32 rf2_layer_bank;
59 static INT32 text_layer_offset;
60 static INT32 fore_layer_offset;
61 static INT32 midl_layer_offset;
62 static INT32 fore_layer_d13;
63 static INT32 fore_layer_d14;
64 static INT32 back_layer_d14;
65 static INT32 midl_layer_d14;
66
67 #define FIFO_SIZE 512
68 static INT32 fifoin_rpos;
69 static INT32 fifoin_wpos;
70 static INT32 fifoout_rpos;
71 static INT32 fifoout_wpos;
72 static UINT8 fifoin_data[FIFO_SIZE];
73 static UINT8 fifoout_data[FIFO_SIZE];
74 static INT32 fifoin_read_request;
75 static INT32 fifoout_read_request;
76 static INT32 z80_prog_xfer_pos;
77 static INT32 z80_bank;
78 static INT32 oki_bank;
79 static INT32 coin_latch;
80
81 static INT32 input_select;
82
83 // configuration variables
84 static INT32 layer_enable;
85 static INT32 sprite_ram_size;
86 static INT32 bg_fore_layer_position;
87 enum { DECRYPT_SEI252 = 0, DECRYPT_RISE10, DECRYPT_RISE11 };
88
89 static INT32 graphics_len[3];
90 static INT32 sound_system = 0; // 0 = msm6295, 1 = z80 + ymf271, 2 - ymz280b
91 static INT32 rom_based_z80 = 0;
92
93 static INT32 has_eeprom = 0;
94
95 static UINT32 speedhack_address = ~0;
96 static UINT32 speedhack_pc = 0;
97
98 static UINT8 DrvJoy1[32];
99 static UINT8 DrvJoy2[32];
100 static UINT8 DrvJoy3[32];
101 static UINT8 DrvJoy4[32];
102 static UINT8 DrvJoy5[16];
103 static UINT8 DrvJoy6[16];
104 static UINT8 DrvJoy7[16];
105 static UINT8 DrvJoy8[16];
106 static UINT8 DrvJoy9[16];
107 static UINT32 DrvInputs[10];
108 static UINT8 DrvDips[1];
109 static UINT8 DrvReset;
110
111 static struct BurnInputInfo Spi_3buttonInputList[] = {
112 {"P1 Coin", BIT_DIGITAL, DrvJoy4 + 0, "p1 coin" },
113 {"P1 Start", BIT_DIGITAL, DrvJoy2 + 0, "p1 start" },
114 {"P1 Up", BIT_DIGITAL, DrvJoy1 + 0, "p1 up" },
115 {"P1 Down", BIT_DIGITAL, DrvJoy1 + 1, "p1 down" },
116 {"P1 Left", BIT_DIGITAL, DrvJoy1 + 2, "p1 left" },
117 {"P1 Right", BIT_DIGITAL, DrvJoy1 + 3, "p1 right" },
118 {"P1 Button 1", BIT_DIGITAL, DrvJoy1 + 4, "p1 fire 1" },
119 {"P1 Button 2", BIT_DIGITAL, DrvJoy1 + 5, "p1 fire 2" },
120 {"P1 Button 3", BIT_DIGITAL, DrvJoy1 + 6, "p1 fire 3" },
121
122 {"P2 Coin", BIT_DIGITAL, DrvJoy4 + 1, "p2 coin" },
123 {"P2 Start", BIT_DIGITAL, DrvJoy2 + 1, "p2 start" },
124 {"P2 Up", BIT_DIGITAL, DrvJoy1 + 8, "p2 up" },
125 {"P2 Down", BIT_DIGITAL, DrvJoy1 + 9, "p2 down" },
126 {"P2 Left", BIT_DIGITAL, DrvJoy1 + 10, "p2 left" },
127 {"P2 Right", BIT_DIGITAL, DrvJoy1 + 11, "p2 right" },
128 {"P2 Button 1", BIT_DIGITAL, DrvJoy1 + 12, "p2 fire 1" },
129 {"P2 Button 2", BIT_DIGITAL, DrvJoy1 + 13, "p2 fire 2" },
130 {"P2 Button 3", BIT_DIGITAL, DrvJoy1 + 14, "p2 fire 3" },
131
132 {"Reset", BIT_DIGITAL, &DrvReset, "reset" },
133 {"Service Mode", BIT_DIGITAL, DrvJoy2 + 2, "diag" },
134 {"Service", BIT_DIGITAL, DrvJoy2 + 3, "service" },
135 {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" },
136 };
137
138 STDINPUTINFO(Spi_3button)
139
140 static struct BurnInputInfo Spi_2buttonInputList[] = {
141 {"P1 Coin", BIT_DIGITAL, DrvJoy4 + 0, "p1 coin" },
142 {"P1 Start", BIT_DIGITAL, DrvJoy2 + 0, "p1 start" },
143 {"P1 Up", BIT_DIGITAL, DrvJoy1 + 0, "p1 up" },
144 {"P1 Down", BIT_DIGITAL, DrvJoy1 + 1, "p1 down" },
145 {"P1 Left", BIT_DIGITAL, DrvJoy1 + 2, "p1 left" },
146 {"P1 Right", BIT_DIGITAL, DrvJoy1 + 3, "p1 right" },
147 {"P1 Button 1", BIT_DIGITAL, DrvJoy1 + 4, "p1 fire 1" },
148 {"P1 Button 2", BIT_DIGITAL, DrvJoy1 + 5, "p1 fire 2" },
149
150 {"P2 Coin", BIT_DIGITAL, DrvJoy4 + 1, "p2 coin" },
151 {"P2 Start", BIT_DIGITAL, DrvJoy2 + 1, "p2 start" },
152 {"P2 Up", BIT_DIGITAL, DrvJoy1 + 8, "p2 up" },
153 {"P2 Down", BIT_DIGITAL, DrvJoy1 + 9, "p2 down" },
154 {"P2 Left", BIT_DIGITAL, DrvJoy1 + 10, "p2 left" },
155 {"P2 Right", BIT_DIGITAL, DrvJoy1 + 11, "p2 right" },
156 {"P2 Button 1", BIT_DIGITAL, DrvJoy1 + 12, "p2 fire 1" },
157 {"P2 Button 2", BIT_DIGITAL, DrvJoy1 + 13, "p2 fire 2" },
158
159 {"Reset", BIT_DIGITAL, &DrvReset, "reset" },
160 {"Service Mode", BIT_DIGITAL, DrvJoy2 + 2, "diag" },
161 {"Service", BIT_DIGITAL, DrvJoy2 + 3, "service" },
162 {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" },
163 };
164
165 STDINPUTINFO(Spi_2button)
166
167 static struct BurnInputInfo Sys386iInputList[] = {
168 {"P1 Coin", BIT_DIGITAL, DrvJoy2 + 4, "p1 coin" },
169 {"P1 Start", BIT_DIGITAL, DrvJoy2 + 0, "p1 start" },
170 {"P1 Up", BIT_DIGITAL, DrvJoy1 + 0, "p1 up" },
171 {"P1 Down", BIT_DIGITAL, DrvJoy1 + 1, "p1 down" },
172 {"P1 Left", BIT_DIGITAL, DrvJoy1 + 2, "p1 left" },
173 {"P1 Right", BIT_DIGITAL, DrvJoy1 + 3, "p1 right" },
174 {"P1 Button 1", BIT_DIGITAL, DrvJoy1 + 4, "p1 fire 1" },
175 {"P1 Button 2", BIT_DIGITAL, DrvJoy1 + 5, "p1 fire 2" },
176 {"P1 Button 3", BIT_DIGITAL, DrvJoy1 + 6, "p1 fire 3" },
177
178 {"P2 Coin", BIT_DIGITAL, DrvJoy2 + 5, "p2 coin" },
179 {"P2 Start", BIT_DIGITAL, DrvJoy2 + 1, "p2 start" },
180 {"P2 Up", BIT_DIGITAL, DrvJoy1 + 8, "p2 up" },
181 {"P2 Down", BIT_DIGITAL, DrvJoy1 + 9, "p2 down" },
182 {"P2 Left", BIT_DIGITAL, DrvJoy1 + 10, "p2 left" },
183 {"P2 Right", BIT_DIGITAL, DrvJoy1 + 11, "p2 right" },
184 {"P2 Button 1", BIT_DIGITAL, DrvJoy1 + 12, "p2 fire 1" },
185 {"P2 Button 2", BIT_DIGITAL, DrvJoy1 + 13, "p2 fire 2" },
186 {"P2 Button 3", BIT_DIGITAL, DrvJoy1 + 14, "p2 fire 3" },
187
188 {"Reset", BIT_DIGITAL, &DrvReset, "reset" },
189 {"Service Mode", BIT_DIGITAL, DrvJoy2 + 2, "diag" },
190 {"Service", BIT_DIGITAL, DrvJoy2 + 3, "service" },
191 };
192
193 STDINPUTINFO(Sys386i)
194
195 static struct BurnInputInfo Spi_ejanhsInputList[] = {
196 {"P1 Coin", BIT_DIGITAL, DrvJoy4 + 0, "p1 coin" },
197 {"P1 Start", BIT_DIGITAL, DrvJoy8 + 5, "p1 start" },
198 {"P1 A", BIT_DIGITAL, DrvJoy8 + 4, "mah a" },
199 {"P1 B", BIT_DIGITAL, DrvJoy9 + 4, "mah b" },
200 {"P1 C", BIT_DIGITAL, DrvJoy7 + 1, "mah c" },
201 {"P1 D", BIT_DIGITAL, DrvJoy5 + 4, "mah d" },
202 {"P1 E", BIT_DIGITAL, DrvJoy8 + 3, "mah e" },
203 {"P1 F", BIT_DIGITAL, DrvJoy9 + 3, "mah f" },
204 {"P1 G", BIT_DIGITAL, DrvJoy7 + 3, "mah g" },
205 {"P1 H", BIT_DIGITAL, DrvJoy5 + 3, "mah h" },
206 {"P1 I", BIT_DIGITAL, DrvJoy8 + 2, "mah i" },
207 {"P1 J", BIT_DIGITAL, DrvJoy9 + 2, "mah j" },
208 {"P1 K", BIT_DIGITAL, DrvJoy7 + 2, "mah k" },
209 {"P1 L", BIT_DIGITAL, DrvJoy5 + 2, "mah l" },
210 {"P1 M", BIT_DIGITAL, DrvJoy8 + 1, "mah m" },
211 {"P1 N", BIT_DIGITAL, DrvJoy9 + 1, "mah n" },
212 {"P1 Pon", BIT_DIGITAL, DrvJoy5 + 1, "mah pon" },
213 {"P1 Chi", BIT_DIGITAL, DrvJoy7 + 1, "mah chi" },
214 {"P1 Kan", BIT_DIGITAL, DrvJoy8 + 0, "mah kan" },
215 {"P1 Ron", BIT_DIGITAL, DrvJoy7 + 0, "mah ron" },
216 {"P1 Reach", BIT_DIGITAL, DrvJoy9 + 0, "mah reach" },
217
218 {"Reset", BIT_DIGITAL, &DrvReset, "reset" },
219 {"Service Mode", BIT_DIGITAL, DrvJoy2 + 2, "diag" },
220 {"Service", BIT_DIGITAL, DrvJoy2 + 3, "service" },
221 {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" },
222 };
223
224 STDINPUTINFO(Spi_ejanhs)
225
226 static struct BurnInputInfo EjsakuraInputList[] = {
227 {"P1 Coin", BIT_DIGITAL, DrvJoy1 + 6, "p1 coin" },
228 {"P1 Start", BIT_DIGITAL, DrvJoy8 + 5, "p1 start" },
229 {"P1 Payout", BIT_DIGITAL, DrvJoy9 + 11, "payout" },
230 {"P1 A", BIT_DIGITAL, DrvJoy8 + 4, "mah a" },
231 {"P1 B", BIT_DIGITAL, DrvJoy6 + 0, "mah b" },
232 {"P1 C", BIT_DIGITAL, DrvJoy7 + 1, "mah c" },
233 {"P1 D", BIT_DIGITAL, DrvJoy5 + 4, "mah d" },
234 {"P1 E", BIT_DIGITAL, DrvJoy8 + 3, "mah e" },
235 {"P1 F", BIT_DIGITAL, DrvJoy6 + 1, "mah f" },
236 {"P1 G", BIT_DIGITAL, DrvJoy7 + 3, "mah g" },
237 {"P1 H", BIT_DIGITAL, DrvJoy5 + 3, "mah h" },
238 {"P1 I", BIT_DIGITAL, DrvJoy8 + 2, "mah i" },
239 {"P1 J", BIT_DIGITAL, DrvJoy9 + 2, "mah j" },
240 {"P1 K", BIT_DIGITAL, DrvJoy7 + 2, "mah k" },
241 {"P1 L", BIT_DIGITAL, DrvJoy5 + 2, "mah l" },
242 {"P1 M", BIT_DIGITAL, DrvJoy8 + 1, "mah m" },
243 {"P1 N", BIT_DIGITAL, DrvJoy9 + 1, "mah n" },
244 {"P1 Pon", BIT_DIGITAL, DrvJoy5 + 1, "mah pon" },
245 {"P1 Chi", BIT_DIGITAL, DrvJoy7 + 1, "mah chi" },
246 {"P1 Kan", BIT_DIGITAL, DrvJoy8 + 0, "mah kan" },
247 {"P1 Ron", BIT_DIGITAL, DrvJoy7 + 0, "mah ron" },
248 {"P1 Reach", BIT_DIGITAL, DrvJoy9 + 0, "mah reach" },
249 {"P1 Flip Flip", BIT_DIGITAL, DrvJoy6 + 1, "mah ff" },
250 {"P1 Bet", BIT_DIGITAL, DrvJoy9 + 5, "mah bet" },
251
252 {"Reset", BIT_DIGITAL, &DrvReset, "reset" },
253 {"Service Mode", BIT_DIGITAL, DrvJoy9 + 9, "diag" },
254 };
255
256 STDINPUTINFO(Ejsakura)
257
258 static struct BurnDIPInfo DefaultDIPList[]=
259 {
260 {0 , 0xfe, 0 , 3, "JP1" },
261 {0x00, 0x01, 0x03, 0x03, "Update" },
262 {0x00, 0x01, 0x03, 0x01, "Off" },
263 {0x00, 0x01, 0x03, 0x00, "On" },
264 };
265
266 static struct BurnDIPInfo Spi_3buttonDIPList[]=
267 {
268 DIP_OFFSET(0x15)
269 {0x00, 0xff, 0xff, 0xff, NULL },
270 };
271
272 static struct BurnDIPInfo Spi_2buttonDIPList[]=
273 {
274 DIP_OFFSET(0x13)
275 {0x00, 0xff, 0xff, 0xff, NULL },
276 };
277
278 static struct BurnDIPInfo Spi_ejanhsDIPList[]=
279 {
280 DIP_OFFSET(0x18)
281 {0x00, 0xff, 0xff, 0xff, NULL },
282 };
283
STDDIPINFOEXT(Spi_3button,Spi_3button,Default)284 STDDIPINFOEXT(Spi_3button, Spi_3button, Default)
285 STDDIPINFOEXT(Spi_2button, Spi_2button, Default)
286 STDDIPINFOEXT(Spi_ejanhs, Spi_ejanhs, Default)
287
288 static void crtc_write()
289 {
290 UINT16 *ram = (UINT16*)DrvCRTCRAM;
291
292 UINT16 layer_bank = BURN_ENDIAN_SWAP_INT16(ram[0x1a / 2]);
293
294 rowscroll_enable = (layer_bank >> 15) & 1;
295
296 fore_layer_offset = 0x1000 / 4;
297 midl_layer_offset = 0x2000 / 4;
298 text_layer_offset = 0x3000 / 4;
299
300 if (rowscroll_enable == 0)
301 {
302 fore_layer_offset /= 2;
303 midl_layer_offset /= 2;
304 text_layer_offset /= 2;
305 }
306
307 fore_layer_d13 = (layer_bank << 2) & 0x2000;
308 back_layer_d14 = (rf2_layer_bank << 14) & 0x4000;
309 midl_layer_d14 = (rf2_layer_bank << 13) & 0x4000;
310 fore_layer_d14 = (rf2_layer_bank << 12) & 0x4000;
311 }
312
tilemap_dma_start_write()313 static void tilemap_dma_start_write()
314 {
315 INT32 index = video_dma_address / 4;
316 INT32 offsets[7] = { 0, 0x800/4, fore_layer_offset, 0x2800/4, midl_layer_offset, 0x1800/4, text_layer_offset };
317
318 for (INT32 i = 0; i < 7; i++)
319 {
320 if ((i & 1) && rowscroll_enable == 0) continue; // copy rowscroll data.. or not
321
322 memmove (&tilemap_ram[offsets[i]], &mainram[index], i == 6 ? 0x1000 : 0x800); // text is 1000
323 index += 0x800/4;
324 }
325 }
326
palette_dma_start_write()327 static void palette_dma_start_write()
328 {
329 const INT32 dma_length = (video_dma_length + 1) * 2;
330
331 for (INT32 i = 0; i < dma_length / 4; i++)
332 {
333 UINT32 color = BURN_ENDIAN_SWAP_INT32(mainram[video_dma_address / 4 + i]);
334
335 if (BURN_ENDIAN_SWAP_INT32(palette_ram[i]) != color)
336 {
337 palette_ram[i] = BURN_ENDIAN_SWAP_INT32(color);
338
339 DrvPalette[(i * 2) + 0] = (pal5bit(color >> 0) << 16) | (pal5bit(color >> 5) << 8) | pal5bit(color >> 10);
340 DrvPalette[(i * 2) + 1] = (pal5bit(color >> 16) << 16) | (pal5bit(color >> 21) << 8) | pal5bit(color >> 26);
341 }
342 }
343 }
344
sprite_dma_start_write()345 static void sprite_dma_start_write()
346 {
347 memmove (&sprite_ram[0], &mainram[video_dma_address / 4], sprite_ram_size);
348 }
349
oki_bankswitch(INT32 data)350 static void oki_bankswitch(INT32 data)
351 {
352 oki_bank = data & 0x04;
353
354 MSM6295SetBank(0, DrvSndROM[0], 0, 0x3ffff);
355 MSM6295SetBank(1, DrvSndROM[1] + ((oki_bank) ? 0x40000 : 0), 0, 0x3ffff);
356 }
357
layerbanks_eeprom_write(UINT16 data)358 static void layerbanks_eeprom_write(UINT16 data)
359 {
360 rf2_layer_bank = data;
361 crtc_write();
362
363 EEPROMWriteBit((data & 0x80) ? 1 : 0);
364 EEPROMSetClockLine((data & 0x40) ? EEPROM_ASSERT_LINE : EEPROM_CLEAR_LINE);
365 EEPROMSetCSLine((data & 0x20) ? EEPROM_CLEAR_LINE : EEPROM_ASSERT_LINE);
366 }
367
common_write_byte(UINT32 address,UINT8 data)368 static void common_write_byte(UINT32 address, UINT8 data)
369 {
370 if ((address & 0xffffffc0) == 0x00000400) {
371 DrvCRTCRAM[(address & 0x3f)] = data;
372 if ((address & 0x3e) == 0x1a) crtc_write();
373 return;
374 }
375
376 if (address < 0x40000) {
377 DrvMainRAM[address] = data;
378 return;
379 }
380 }
381
common_write_word(UINT32 address,UINT16 data)382 static void common_write_word(UINT32 address, UINT16 data)
383 {
384 if ((address & 0xffffffc0) == 0x00000400) {
385 UINT16 *crtc = (UINT16*)DrvCRTCRAM;
386 crtc[(address / 2) & 0x1f] = BURN_ENDIAN_SWAP_INT16(data);
387 if ((address & 0x3e) == 0x1a) crtc_write();
388 return;
389 }
390
391 switch (address)
392 {
393 case 0x480:
394 tilemap_dma_start_write();
395 return;
396
397 case 0x484:
398 palette_dma_start_write();
399 return;
400
401 case 0x490:
402 video_dma_length = (video_dma_length & 0xffff0000) | data;
403 //bprintf(0, _T("ww video_dma_len %x data %x\n"),video_dma_length, data);
404 return;
405
406 case 0x494:
407 video_dma_address = data;
408 //bprintf(0, _T("ww video_dma_address %x\n"),video_dma_address);
409 return;
410
411 case 0x498:
412 break; //nop
413
414 // case 0x50e: // (50e) -sei252
415 // case 0x562: // (562) -rise
416 // sprite_dma_start_write();
417 // break;
418 }
419
420 if (address < 0x40000) {
421 UINT16 *ram = (UINT16*)DrvMainRAM;
422 ram[address/2] = BURN_ENDIAN_SWAP_INT16(data);
423 return;
424 }
425 }
426
common_write_dword(UINT32 address,UINT32 data)427 static void common_write_dword(UINT32 address, UINT32 data)
428 {
429 if ((address & 0xffffffc0) == 0x00000400) {
430 UINT32 *crtc = (UINT32*)DrvCRTCRAM;
431 crtc[(address / 4) & 0xf] = BURN_ENDIAN_SWAP_INT32(data);
432 if ((address & 0x3c) == 0x18) crtc_write();
433 return;
434 }
435
436 switch (address)
437 {
438 case 0x480:
439 tilemap_dma_start_write();
440 return;
441
442 case 0x484:
443 palette_dma_start_write();
444 return;
445
446 case 0x490:
447 video_dma_length = data;
448 return;
449
450 case 0x494:
451 video_dma_address = data;
452 return;
453
454 case 0x498:
455 return; //nop
456 }
457
458 if (address < 0x40000) {
459 UINT32 *ram = (UINT32*)DrvMainRAM;
460 ram[address/4] = BURN_ENDIAN_SWAP_INT32(data);
461 return;
462 }
463 }
464
ejanhs_encode(INT32 N)465 static INT32 ejanhs_encode(INT32 N)
466 {
467 static const UINT8 encoding[6] = { 6, 5, 4, 3, 2, 7 };
468 static UINT8 state = ~DrvInputs[4 + N];
469
470 for (INT32 bit = 0; bit < 6; bit++)
471 if (state & (1 << bit))
472 return encoding[bit];
473
474 return 0;
475 }
476
common_read_dword(UINT32 address)477 static UINT32 common_read_dword(UINT32 address)
478 {
479 if ((address & 0xffffffc0) == 0x00000400) {
480 UINT32 *crtc = (UINT32*)DrvCRTCRAM;
481 return BURN_ENDIAN_SWAP_INT32(crtc[(address / 4) & 0xf]);
482 }
483
484 switch (address)
485 {
486 case 0x600:
487 return 1; // spi status
488
489 case 0x604:
490 {
491 UINT32 ret = DrvInputs[0]; // FLIPSCREEN & ~0x8000;
492
493 if (BurnDrvGetGenreFlags() & GBF_MAHJONG) { // ejanhs
494 ret &= 0xffff4000;
495 ret |= ejanhs_encode(3) << 0;
496 ret |= ejanhs_encode(4) << 3;
497 ret |= ejanhs_encode(2) << 6;
498 ret |= ejanhs_encode(0) << 9;
499 }
500
501 return ret; // inputs
502 }
503
504 case 0x608:
505 return DrvInputs[2]; // exch
506
507 case 0x60c:
508 {
509 UINT32 ret = DrvInputs[1];
510
511 if (has_eeprom) ret = (ret & ~0x40) | (EEPROMRead() ? 0x40 : 0);
512
513 return ret; // system
514 }
515
516 case 0x688: return 0; // rdft2us
517 }
518
519 if (address < 0x40000) {
520 if (speedhack_address == address) {
521 if (speedhack_pc == i386GetPC(-1)) {
522 i386RunEnd();
523 i386HaltUntilInterrupt(1);
524 }
525 // if (speedhack_pc == 1) { // speedhack finder
526 // bprintf (0, _T("SPEEDHACK: %5.5x\n"), i386GetPC(-1));
527 // }
528 }
529
530 UINT32 *ram = (UINT32*)DrvMainRAM;
531 return BURN_ENDIAN_SWAP_INT32(ram[address/4]);
532 }
533
534 return 0;
535 }
536
common_read_word(UINT32 address)537 static UINT16 common_read_word(UINT32 address)
538 {
539 return i386ReadLong(address & ~3) >> ((address & 2) * 8);
540 }
541
common_read_byte(UINT32 address)542 static UINT8 common_read_byte(UINT32 address)
543 {
544 return i386ReadLong(address & ~3) >> ((address & 3) * 8);
545 }
546
sync_cpu()547 static void sync_cpu()
548 {
549 // main is 25000 000
550 // sound is 7159 000
551
552 UINT32 cycles = (i386TotalCycles() * 7159) / 25000;
553
554 if (cycles > (UINT32)ZetTotalCycles())
555 BurnTimerUpdate(cycles);
556 }
557
z80_fifoout_pop()558 static UINT8 z80_fifoout_pop()
559 {
560 UINT8 r = fifoout_data[fifoout_rpos++];
561 if (fifoout_rpos == FIFO_SIZE) fifoout_rpos = 0;
562 if (fifoout_wpos == fifoout_rpos) fifoout_read_request = 0;
563 return r;
564 }
565
z80_fifoout_push(UINT8 data)566 static void z80_fifoout_push(UINT8 data)
567 {
568 fifoout_data[fifoout_wpos++] = data;
569 if (fifoout_wpos == FIFO_SIZE) fifoout_wpos = 0;
570 fifoout_read_request = 1;
571 }
572
z80_fifoin_pop()573 static UINT8 z80_fifoin_pop()
574 {
575 UINT8 r = fifoin_data[fifoin_rpos++];
576 if (fifoin_rpos == FIFO_SIZE) fifoin_rpos = 0;
577 if (fifoin_wpos == fifoin_rpos) fifoin_read_request = 0;
578 return r;
579 }
580
z80_fifoin_push(UINT8 data)581 static void z80_fifoin_push(UINT8 data)
582 {
583 fifoin_data[fifoin_wpos++] = data;
584 if (fifoin_wpos == FIFO_SIZE) fifoin_wpos = 0;
585 fifoin_read_request = 1;
586 }
587
spi_write_byte(UINT32 address,UINT8 data)588 static void spi_write_byte(UINT32 address, UINT8 data)
589 {
590 switch (address)
591 {
592 case 0x68e:
593 rf2_layer_bank = (rf2_layer_bank & 0xff00) | data;
594 crtc_write();
595 if (has_eeprom) {
596 EEPROMWriteBit((data & 0x80) ? 1 : 0);
597 EEPROMSetClockLine((data & 0x40) ? EEPROM_ASSERT_LINE : EEPROM_CLEAR_LINE);
598 EEPROMSetCSLine((data & 0x20) ? EEPROM_CLEAR_LINE : EEPROM_ASSERT_LINE);
599 }
600 return;
601
602 case 0x68f:
603 rf2_layer_bank = (rf2_layer_bank & 0x00ff) | (data << 8);
604 crtc_write();
605 return;
606
607 case 0x690:
608 case 0x691:
609 return;
610 }
611
612 common_write_byte(address, data);
613 }
614
spi_write_word(UINT32 address,UINT16 data)615 static void spi_write_word(UINT32 address, UINT16 data)
616 {
617 switch (address)
618 {
619 case 0x50e:
620 case 0x562: // rdft2 (can these co-exist peacefully??)
621 sprite_dma_start_write();
622 return;
623
624 case 0x600:
625 return; // nop?
626
627 case 0x680:
628 sync_cpu();
629 z80_fifoin_push(data & 0xff);
630 return;
631
632 case 0x688:
633 if (rom_based_z80 == 0) {
634 if (z80_prog_xfer_pos < 0x40000) {
635 DrvZ80RAM[z80_prog_xfer_pos] = data & 0xff;
636 z80_prog_xfer_pos++;
637 }
638 }
639 return;
640
641 case 0x68c:
642 if (rom_based_z80 == 0) {
643 sync_cpu();
644 z80_prog_xfer_pos = 0;
645 ZetSetRESETLine((data & 1) ? CPU_IRQSTATUS_NONE : CPU_IRQSTATUS_ACK);
646 }
647 return;
648
649 case 0x68e:
650 rf2_layer_bank = data;
651 crtc_write();
652 if (has_eeprom) {
653 EEPROMWriteBit((data & 0x80) ? 1 : 0);
654 EEPROMSetClockLine((data & 0x40) ? EEPROM_ASSERT_LINE : EEPROM_CLEAR_LINE);
655 EEPROMSetCSLine((data & 0x20) ? EEPROM_CLEAR_LINE : EEPROM_ASSERT_LINE);
656 }
657 return;
658 }
659
660 common_write_word(address, data);
661 }
662
spi_write_dword(UINT32 address,UINT32 data)663 static void spi_write_dword(UINT32 address, UINT32 data)
664 {
665 switch (address)
666 {
667 case 0x524: // rise decryption key
668 case 0x528: // unknown
669 case 0x530: // rise decryption table key
670 case 0x534: // unknown
671 case 0x53c: // rise decryption table index
672 return;
673
674 case 0x6d0:
675 ds2404_1w_reset_write(data);
676 return;
677
678 case 0x6d4:
679 ds2404_data_write(data);
680 return;
681
682 case 0x6d8:
683 ds2404_clk_write(data);
684 return;
685 }
686
687 common_write_dword(address, data);
688 }
689
spi_read_dword(UINT32 address)690 static UINT32 spi_read_dword(UINT32 address)
691 {
692 switch (address)
693 {
694 case 0x680:
695 {
696 if (rom_based_z80 == 0) return z80_fifoout_pop();
697
698 INT32 ret = coin_latch;
699 coin_latch = 0;
700 return ret;
701 }
702
703 case 0x684:
704 return fifoout_read_request ? 3 : 1;
705
706 case 0x6dc:
707 return ds2404_data_read() | (0x00 << 8); // must be clear on this byte
708 }
709
710 return common_read_dword(address);
711 }
712
spi_i386_write_word(UINT32 address,UINT16 data)713 static void spi_i386_write_word(UINT32 address, UINT16 data)
714 {
715 switch (address)
716 {
717 case 0x562:
718 sprite_dma_start_write();
719 return;
720
721 case 0x68e:
722 layerbanks_eeprom_write(data);
723 oki_bankswitch(data >> 8);
724 return;
725 }
726
727 common_write_word(address, data);
728 }
729
spi_i386_write_dword(UINT32 address,UINT32 data)730 static void spi_i386_write_dword(UINT32 address, UINT32 data)
731 {
732 switch (address)
733 {
734 case 0x1200000:
735 case 0x1200004:
736 MSM6295Write((address / 4) & 1, data);
737 return;
738 }
739
740 common_write_dword(address, data);
741 }
742
spi_i386_read_dword(UINT32 address)743 static UINT32 spi_i386_read_dword(UINT32 address)
744 {
745 switch (address)
746 {
747 case 0x60c:
748 {
749 UINT32 ret = DrvInputs[1] & ~0x40;
750 if (EEPROMRead()) ret |= 0x40;
751 return ret; // system
752 }
753
754 case 0x1200000:
755 case 0x1200004:
756 return MSM6295Read((address / 4) & 1);
757 }
758
759 return common_read_dword(address);
760 }
761
ejsakura_keyboard_read()762 static UINT32 ejsakura_keyboard_read()
763 {
764 // coins/eeprom data
765 UINT32 ret = DrvInputs[0] & ~0x4000;
766 if (EEPROMRead()) ret |= 0x4000;
767
768 for (INT32 i = 0; i < 5; i++)
769 if ((input_select >> i) & 1)
770 ret &= DrvInputs[4 + i];
771
772 return ret;
773 }
774
sys386f_read_dword(UINT32 address)775 static UINT32 sys386f_read_dword(UINT32 address)
776 {
777 switch (address)
778 {
779 case 0x010:
780 return 1; // spi status
781
782 case 0x400:
783 return ~0; // system (not used)
784
785 case 0x600:
786 case 0x604:
787 return YMZ280BReadStatus();
788
789 case 0x60c:
790 return ejsakura_keyboard_read();
791 }
792
793 return common_read_dword(address);
794 }
795
sys386f_write_word(UINT32 address,UINT16 data)796 static void sys386f_write_word(UINT32 address, UINT16 data)
797 {
798 switch (address)
799 {
800 case 0x400:
801 input_select = data;
802 return;
803
804 case 0x404:
805 EEPROMWriteBit((data & 0x80) ? 1 : 0);
806 EEPROMSetClockLine((data & 0x40) ? EEPROM_ASSERT_LINE : EEPROM_CLEAR_LINE);
807 EEPROMSetCSLine((data & 0x20) ? EEPROM_CLEAR_LINE : EEPROM_ASSERT_LINE);
808 return;
809
810 case 0x408:
811 YMZ280BSelectRegister(data);
812 return;
813
814 case 0x40c:
815 YMZ280BWriteRegister(data);
816 return;
817
818 case 0x562: // (562) -rise
819 sprite_dma_start_write();
820 return;
821 }
822
823 common_write_word(address, data);
824 }
825
sound_bankswitch(INT32 data)826 static void sound_bankswitch(INT32 data)
827 {
828 z80_bank = data & 7;
829
830 ZetMapMemory(DrvZ80RAM + z80_bank * 0x8000, 0x8000, 0xffff, MAP_ROM);
831 }
832
spi_sound_write(UINT16 address,UINT8 data)833 static void __fastcall spi_sound_write(UINT16 address, UINT8 data)
834 {
835 if ((address & 0xfff0) == 0x6000) {
836 BurnYMF271Write(address & 0xf, data);
837 return;
838 }
839
840 switch (address)
841 {
842 case 0x4002:
843 case 0x4003:
844 case 0x400b:
845 return; // nop
846
847 case 0x4004:
848 coin_latch = data ? (data | 0xa0) : 0;
849 // coin counter = data & 3
850 return;
851
852 case 0x4008:
853 z80_fifoout_push(data);
854 return;
855
856 case 0x401b:
857 sound_bankswitch(data);
858 return;
859 }
860 }
861
spi_sound_read(UINT16 address)862 static UINT8 __fastcall spi_sound_read(UINT16 address)
863 {
864 if ((address & 0xfff0) == 0x6000) {
865 return BurnYMF271Read(address & 0xf);
866 }
867
868 switch (address)
869 {
870 case 0x4008:
871 return z80_fifoin_pop();
872
873 case 0x4009:
874 return fifoin_read_request ? 3 : 1;
875
876 case 0x4013:
877 return DrvInputs[3]; // coin
878
879 case 0x400a:
880 return DrvDips[0]; // jumpers
881 }
882
883 return 0;
884 }
885
ymf271_external_write(UINT32 address,UINT8 data)886 static void ymf271_external_write(UINT32 address, UINT8 data)
887 {
888 intelflash_write((address >> 20) & 1, address & 0xfffff, data);
889 }
890
ymf271_external_read(UINT32 address)891 static UINT8 ymf271_external_read(UINT32 address)
892 {
893 return intelflash_read((address >> 20) & 1, address & 0xfffff);
894 }
895
spiZ80IRQCallback(INT32,INT32 state)896 static void spiZ80IRQCallback(INT32, INT32 state)
897 {
898 if (state) ZetSetVector(0xd7);
899 ZetSetIRQLine(0, state ? CPU_IRQSTATUS_ACK : CPU_IRQSTATUS_NONE);
900 }
901
tilemap_callback(text)902 static tilemap_callback( text )
903 {
904 UINT16 tile = BURN_ENDIAN_SWAP_INT16(tilemap_ram16[offs + (text_layer_offset * 2)]);
905
906 TILE_SET_INFO(2, tile, tile >> 12, 0);
907 }
908
tilemap_callback(back)909 static tilemap_callback( back )
910 {
911 UINT16 tile = BURN_ENDIAN_SWAP_INT16(tilemap_ram16[offs]);
912
913 TILE_SET_INFO(1, (tile & 0x1fff) | back_layer_d14, tile >> 13, 0);
914 }
915
tilemap_callback(midl)916 static tilemap_callback( midl )
917 {
918 UINT16 tile = BURN_ENDIAN_SWAP_INT16(tilemap_ram16[offs + (midl_layer_offset * 2)]);
919
920 TILE_SET_INFO(1, (tile & 0x1fff) | 0x2000 | midl_layer_d14, (tile >> 13) + 0x10, 0);
921 }
922
tilemap_callback(fore)923 static tilemap_callback( fore )
924 {
925 UINT16 tile = BURN_ENDIAN_SWAP_INT16(tilemap_ram16[offs + (fore_layer_offset * 2)]);
926
927 TILE_SET_INFO(1, (tile & 0x1fff) | bg_fore_layer_position | fore_layer_d13 | fore_layer_d14, (tile >> 13) + 8, 0);
928 }
929
SeibuspiIRQCallback(INT32)930 static INT32 SeibuspiIRQCallback(INT32)
931 {
932 return 0x20;
933 }
934
DrvDoReset(INT32 clear_mem)935 static INT32 DrvDoReset(INT32 clear_mem)
936 {
937 if (clear_mem) {
938 memset (AllRam, 0, RamEnd - AllRam);
939 }
940
941 DrvRecalc = 1; // re-cache the palette (fixes seibu logo fade-in on reset rdftua etc)
942
943 i386Open(0);
944 i386Reset();
945 i386Close();
946
947 // if flash update gets interrupted, reset will fix hw.err.81
948 DrvSndROM[0][0xa00000] = DrvMainROM[0x1ffffc]; // HACK! -set flash region...
949
950 if (sound_system == 0)
951 {
952 MSM6295Reset(0);
953 MSM6295Reset(1);
954 }
955 else if (sound_system == 1)
956 {
957 ZetOpen(0);
958 ZetReset();
959 ZetSetRESETLine(rom_based_z80 ? 0 : 1); // RAM-based starts in reset
960 sound_bankswitch(0);
961 BurnYMF271Reset();
962 ZetClose();
963
964 z80_prog_xfer_pos = 0;
965
966 ds2404Init((UINT8*)DefaultNVRAM, 1995, 1, 1);
967 }
968 else if (sound_system == 2)
969 {
970 YMZ280BReset();
971 }
972
973 if (has_eeprom) {
974 EEPROMReset();
975
976 if (EEPROMAvailable() == 0) {
977 EEPROMFill(DefaultEEPROM, 0, 0x80);
978 }
979 }
980
981 coin_latch = 0;
982 input_select = 0;
983
984 video_dma_length = 0;
985 video_dma_address = 0;
986 rowscroll_enable = 0;
987 rf2_layer_bank = 0;
988 text_layer_offset = 0;
989 fore_layer_offset = 0;
990 midl_layer_offset = 0;
991 fore_layer_d13 = 0;
992 fore_layer_d14 = 0;
993 back_layer_d14 = 0;
994 midl_layer_d14 = 0;
995
996 fifoin_rpos = 0;
997 fifoin_wpos = 0;
998 fifoout_rpos = 0;
999 fifoout_wpos = 0;
1000 memset (fifoin_data, 0, sizeof(fifoin_data));
1001 memset (fifoout_data, 0, sizeof(fifoout_data));
1002 fifoin_read_request = 0;
1003 fifoout_read_request = 0;
1004 z80_prog_xfer_pos = 0;
1005
1006 nExtraCycles = 0;
1007
1008 HiscoreReset();
1009
1010 return 0;
1011 }
1012
MemIndex()1013 static INT32 MemIndex()
1014 {
1015 UINT8 *Next; Next = AllMem;
1016
1017 DrvMainROM = Next; Next += 0x200000;
1018
1019 if (rom_based_z80) {
1020 DrvZ80RAM = Next; Next += 0x040000;
1021 }
1022
1023 DrvGfxROM[0] = Next; Next += 0x100000; // must be 1mb or glitches
1024 DrvGfxROM[1] = Next; Next += 0x1000000;
1025 DrvGfxROM[2] = Next; Next += 0x2000000;
1026
1027 YMZ280BROM = Next;
1028 MSM6295ROM = Next;
1029 DrvSndROM[0] = Next; Next += 0x100000; // allow overflow into DrvSndROM[1] (spi sound is 0xa00000 in size) + 0x100000 for flash, YMZ280B needs 16mb
1030 DrvSndROM[1] = Next; Next += 0xf00000;
1031
1032 DefaultEEPROM = Next; Next += 0x000080;
1033
1034 DrvPalette = (UINT32*)Next; Next += 0x2001 * sizeof(UINT32);
1035
1036 bitmap32 = (UINT32*)Next; Next += 320 * 256 * sizeof(UINT32);
1037 DrvAlphaTable = Next; Next += 0x002000;
1038
1039 tempdraw = (UINT16*)Next; Next += 320 * 256 * sizeof(UINT16);
1040
1041 AllRam = Next;
1042
1043 DrvMainRAM = Next;
1044 mainram = (UINT32*)Next; Next += 0x040000;
1045 palette_ram = (UINT32*)Next; Next += 0x004000;
1046 sprite_ram = (UINT32*)Next; Next += 0x002000;
1047 tilemap_ram16 = (UINT16*)Next;
1048 tilemap_ram = (UINT32*)Next; Next += 0x004000;
1049
1050 DrvCRTCRAM = Next; Next += 0x000040;
1051
1052 if (rom_based_z80 == 0) {
1053 DrvZ80RAM = Next; Next += 0x040000;
1054 }
1055
1056 DrvZ80WorkRAM = Next; Next += 0x002000;
1057
1058 RamEnd = Next;
1059
1060 MemEnd = Next;
1061
1062 return 0;
1063 }
1064
partial_carry_sum(UINT32 add1,UINT32 add2,UINT32 carry_mask,INT32 bits)1065 static UINT32 partial_carry_sum(UINT32 add1,UINT32 add2,UINT32 carry_mask,INT32 bits)
1066 {
1067 INT32 res = 0, carry = 0;
1068 for (INT32 i = 0; i < bits; i++)
1069 {
1070 INT32 bit = BIT(add1,i) + BIT(add2,i) + carry;
1071
1072 res += (bit & 1) << i;
1073
1074 if (BIT(carry_mask,i))
1075 carry = bit >> 1;
1076 else
1077 carry = 0;
1078 }
1079
1080 if (carry) res ^=1;
1081
1082 return res;
1083 }
1084
decrypt_tile(UINT32 val,int tileno,UINT32 key1,UINT32 key2,UINT32 key3)1085 static inline UINT32 decrypt_tile(UINT32 val, int tileno, UINT32 key1, UINT32 key2, UINT32 key3)
1086 {
1087 return partial_carry_sum(BITSWAP24(val, 18,19,9,5, 10,17,16,20, 21,22,6,11, 15,14,4,23, 0,1,7,8, 13,12,3,2), tileno + key1, key2, 24 ) ^ key3;
1088 }
1089
decrypt_text(UINT8 * rom,INT32 length,UINT32 key1,UINT32 key2,UINT32 key3)1090 static void decrypt_text(UINT8 *rom, INT32 length, UINT32 key1, UINT32 key2, UINT32 key3)
1091 {
1092 for (INT32 i = 0; i < length; i++)
1093 {
1094 UINT32 w = (rom[(i * 3) + 0] << 16) | (rom[(i * 3) + 1] << 8) | (rom[(i * 3) + 2]);
1095
1096 w = decrypt_tile(w, i >> 4, key1, key2, key3);
1097
1098 rom[(i * 3) + 0] = (w >> 16) & 0xff;
1099 rom[(i * 3) + 1] = (w >> 8) & 0xff;
1100 rom[(i * 3) + 2] = w & 0xff;
1101 }
1102 }
1103
decrypt_bg(UINT8 * rom,INT32 length,UINT32 key1,UINT32 key2,UINT32 key3)1104 static void decrypt_bg(UINT8 *rom, INT32 length, UINT32 key1, UINT32 key2, UINT32 key3)
1105 {
1106 for (INT32 j = 0; j < length; j += 0xc0000)
1107 {
1108 for (INT32 i = 0; i < 0x40000; i++)
1109 {
1110 UINT32 w = (rom[j + (i * 3) + 0] << 16) | (rom[j + (i * 3) + 1] << 8) | (rom[j + (i * 3) + 2]);
1111
1112 w = decrypt_tile(w, i >> 6, key1, key2, key3);
1113
1114 rom[j + (i * 3) + 0] = (w >> 16) & 0xff;
1115 rom[j + (i * 3) + 1] = (w >> 8) & 0xff;
1116 rom[j + (i * 3) + 2] = w & 0xff;
1117 }
1118 }
1119 }
1120
sprite_reorder(UINT8 * buffer)1121 static inline void sprite_reorder(UINT8 *buffer)
1122 {
1123 UINT8 temp[64];
1124
1125 for (INT32 j = 0; j < 16; j++)
1126 {
1127 temp[2 * (j * 2) + 0] = buffer[2 * j + 0];
1128 temp[2 * (j * 2) + 1] = buffer[2 * j + 1];
1129 temp[2 * (j * 2) + 2] = buffer[2 * j + 32];
1130 temp[2 * (j * 2) + 3] = buffer[2 * j + 33];
1131 }
1132
1133 memcpy(buffer, temp, 64);
1134 }
1135
seibuspi_rise10_sprite_decrypt(UINT8 * rom,INT32 size)1136 static void seibuspi_rise10_sprite_decrypt(UINT8 *rom, INT32 size)
1137 {
1138 for (INT32 i = 0; i < size / 2; i++)
1139 {
1140 UINT32 plane54 = rom[0 * size + 2 * i] + (rom[0 * size + 2 * i + 1] << 8);
1141 UINT32 plane3210 = BITSWAP32(rom[2 * size + 2 * i] + (rom[2 * size + 2 * i + 1] << 8) + (rom[1 * size + 2 * i] << 16) + (rom[1 * size + 2 * i + 1] << 24),
1142 23,13,24,4,16,12,25,30,3,5,29,17,14,22,2,11,27,6,15,21,1,28,10,20,7,31,26,0,18,9,19,8);
1143
1144 plane54 = partial_carry_sum( plane54, 0xabcb, 0x55aa, 16 ) ^ 0x6699;
1145 plane3210 = partial_carry_sum( plane3210, 0x654321d9 ^ 0x42, 0x1d463748, 32 ) ^ 0x0ca352a9;
1146
1147 rom[0 * size + 2 * i] = plane54 >> 8;
1148 rom[0 * size + 2 * i + 1] = plane54 >> 0;
1149 rom[1 * size + 2 * i] = plane3210 >> 24;
1150 rom[1 * size + 2 * i + 1] = plane3210 >> 16;
1151 rom[2 * size + 2 * i] = plane3210 >> 8;
1152 rom[2 * size + 2 * i + 1] = plane3210 >> 0;
1153 }
1154
1155 for (INT32 i = 0; i < size / 2; i += 32)
1156 {
1157 sprite_reorder(&rom[0 * size + 2 * i]);
1158 sprite_reorder(&rom[1 * size + 2 * i]);
1159 sprite_reorder(&rom[2 * size + 2 * i]);
1160 }
1161 }
1162
seibuspi_rise11_sprite_decrypt(UINT8 * rom,int size,UINT32 k1,UINT32 k2,UINT32 k3,UINT32 k4,UINT32 k5)1163 static void seibuspi_rise11_sprite_decrypt(UINT8 *rom, int size, UINT32 k1, UINT32 k2, UINT32 k3, UINT32 k4, UINT32 k5)
1164 {
1165 for (INT32 i = 0; i < size/2; i++)
1166 {
1167 const UINT16 b1 = rom[0 * size + 2 * i] + (rom[0 * size + 2 * i + 1] << 8);
1168 const UINT16 b2 = rom[1 * size + 2 * i] + (rom[1 * size + 2 * i + 1] << 8);
1169 const UINT16 b3 = rom[2 * size + 2 * i] + (rom[2 * size + 2 * i + 1] << 8);
1170
1171 UINT32 plane543 = (BIT(b2,11)<< 0) | (BIT(b1, 6)<< 1) | (BIT(b3,12)<< 2) | (BIT(b3, 3)<< 3) | (BIT(b2,12)<< 4) | (BIT(b3,14)<< 5) | (BIT(b3, 4)<< 6) | (BIT(b1,11)<< 7) |
1172 (BIT(b1,12)<< 8) | (BIT(b1, 2)<< 9) | (BIT(b2, 5)<<10) | (BIT(b1, 9)<<11) | (BIT(b3, 1)<<12) | (BIT(b2, 2)<<13) | (BIT(b2,10)<<14) | (BIT(b3, 5)<<15) |
1173 (BIT(b1, 3)<<16) | (BIT(b2, 7)<<17) | (BIT(b1,15)<<18) | (BIT(b3, 9)<<19) | (BIT(b2,13)<<20) | (BIT(b1, 4)<<21) | (BIT(b3, 2)<<22) | (BIT(b2, 0)<<23);
1174
1175 UINT32 plane210 = (BIT(b1,14)<< 0) | (BIT(b1, 1)<< 1) | (BIT(b1,13)<< 2) | (BIT(b3, 0)<< 3) | (BIT(b1, 7)<< 4) | (BIT(b2,14)<< 5) | (BIT(b2, 4)<< 6) | (BIT(b2, 9)<< 7) |
1176 (BIT(b3, 8)<< 8) | (BIT(b2, 1)<< 9) | (BIT(b3, 7)<<10) | (BIT(b2, 6)<<11) | (BIT(b1, 0)<<12) | (BIT(b3,11)<<13) | (BIT(b2, 8)<<14) | (BIT(b3,13)<<15) |
1177 (BIT(b1, 8)<<16) | (BIT(b3,10)<<17) | (BIT(b3, 6)<<18) | (BIT(b1,10)<<19) | (BIT(b2,15)<<20) | (BIT(b2, 3)<<21) | (BIT(b1, 5)<<22) | (BIT(b3,15)<<23);
1178
1179 plane543 = partial_carry_sum( plane543, k1, k2, 32 ) ^ k3;
1180 plane210 = partial_carry_sum( plane210, i, k4, 24 ) ^ k5;
1181
1182 rom[0 * size + 2 * i] = plane543 >> 16;
1183 rom[0 * size + 2 * i + 1] = plane543 >> 8;
1184 rom[1 * size + 2 * i] = plane543 >> 0;
1185 rom[1 * size + 2 * i + 1] = plane210 >> 16;
1186 rom[2 * size + 2 * i] = plane210 >> 8;
1187 rom[2 * size + 2 * i + 1] = plane210 >> 0;
1188 }
1189
1190 for (INT32 i = 0; i < size / 2; i += 32)
1191 {
1192 sprite_reorder(&rom[0 * size + 2 * i]);
1193 sprite_reorder(&rom[1 * size + 2 * i]);
1194 sprite_reorder(&rom[2 * size + 2 * i]);
1195 }
1196 }
1197
1198 static const UINT16 key_table[256] = {
1199 0x3ad7,0x54b1,0x2d41,0x8ca0,0xa69b,0x9018,0x9db9,0x6559,0xe9a7,0xb087,0x8a5e,0x821c,0xaafc,0x2ae7,0x557b,0xcd80,
1200 0xcfee,0x653e,0x9b31,0x7ab5,0x8b2a,0xbda8,0x707a,0x3c83,0xcbb7,0x7157,0x8226,0x5c4a,0x8bf2,0x6397,0x13e2,0x3102,
1201 0x8093,0x44cd,0x5f2d,0x7639,0xa7a4,0x9974,0x5263,0x8318,0xb78c,0xa120,0xafb4,0x615f,0x6e0b,0x1d7d,0x8c29,0x4466,
1202 0x3f35,0x794e,0xaea6,0x601c,0xe478,0xcf6e,0x4ee3,0xa009,0x4b99,0x51d3,0x3474,0x3e4d,0xe5b7,0x9088,0xb5c0,0xba9f,
1203 0x5646,0xa0af,0x970b,0xb14f,0x8216,0x2386,0x496d,0x9245,0x7e4c,0xad5f,0x89d9,0xb801,0xdf64,0x8ca8,0xe019,0xde9b,
1204 0x6836,0x70e2,0x7dcd,0x7ac1,0x98ef,0x71aa,0x7d6f,0x70bd,0x9e14,0x75b6,0x8153,0xab6c,0x1f85,0x79cd,0xb2a1,0x934a,
1205 0x6f74,0x37d7,0xa05a,0x6563,0x1972,0x2dcd,0x7e59,0x6a60,0x5163,0x84c4,0xc451,0x8d80,0x4287,0x57e8,0xacc9,0x539d,
1206 0xbe71,0xdb7c,0x9424,0xb224,0xcc0f,0xe3dd,0xb79c,0x461e,0x96a9,0x4c7c,0x5443,0x6b2b,0x3cdc,0xbee8,0x2602,0x3282,
1207 0x7f9c,0x59c3,0xc69a,0x39f4,0x5138,0xb7ca,0x6ca7,0x62e7,0xc455,0x56cf,0x8a9a,0x695c,0x5af2,0xdebf,0x4dbb,0xdaec,
1208 0xb564,0xc89c,0x7d2d,0x6dc3,0xa15a,0x6584,0xb8ea,0xb7ac,0x88d8,0xc5aa,0x98c5,0xc506,0xc13c,0x7f59,0xab65,0x8fc8,
1209 0x3a3c,0xd5f6,0x554d,0x5682,0x8ce7,0x40fc,0x8fd7,0x535c,0x6aa0,0x52fe,0x8834,0x5316,0x6c27,0x80a9,0x9e6f,0x2c08,
1210 0x4092,0xc7c1,0xc468,0x9520,0xbc4d,0xb621,0x3cdb,0xdce8,0x481f,0xd0bd,0x3a57,0x807e,0x3025,0x5aa0,0x5e49,0xa29b,
1211 0xd2d6,0x7bee,0x97f0,0xe28e,0x2fff,0x48e4,0x6367,0x933f,0x57c5,0x28d4,0x68a0,0xd22e,0x39a6,0x9d2b,0x7a64,0x7e72,
1212 0x5379,0xe86c,0x7554,0x8fbb,0xc06a,0x9533,0x7eec,0x4d52,0xa800,0x5d35,0xa47d,0xe515,0x8d19,0x703b,0x5a2e,0x627c,
1213 0x7cea,0x1b2c,0x5a05,0x8598,0x9e00,0xcf01,0x62d9,0x7a10,0x1f42,0x87ce,0x575d,0x6e23,0x86ef,0x93c2,0x3d1a,0x89aa,
1214 0xe199,0xba1d,0x1b72,0x4513,0x5131,0xc23c,0xba9f,0xa069,0xfbfb,0xda92,0x42b2,0x3a48,0xdb96,0x5fad,0xba96,0xc6eb,
1215 };
1216
1217 static const UINT8 spi_bitswap[16][16] = {
1218 { 15,14,13,12,11,10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, },
1219 { 7, 6, 5,14, 0,15, 4, 3, 2, 8, 9,10,11,12,13, 1, },
1220 { 9,15,14,13,12, 0, 1, 2,10, 8, 7, 6, 5, 4, 3,11, },
1221 { 5, 4, 3, 2, 9,14,13,12,11, 6, 7, 8, 1,15, 0,10, },
1222 { 12,11, 0, 7, 8, 5, 6,15,10,13,14, 1, 2, 3, 4, 9, },
1223 { 14, 0, 1, 2, 3, 9, 8, 7,15, 5, 6,13,12,11,10, 4, },
1224 { 13,12,11,10, 2, 7, 8, 9, 0,14,15, 3, 4, 5, 6, 1, },
1225 { 2, 9,10,11,12, 7, 6, 5,14, 3, 4, 0,15, 1, 8,13, },
1226 { 8, 7, 4, 3, 2,13,12,11, 0, 9,10,14,15, 6, 5, 1, },
1227 { 3, 2,10,11,12, 5,14, 0, 1, 4,15, 6, 7, 8, 9,13, },
1228 { 2,10, 6, 5, 4,14,13,12,11, 1, 0,15, 9, 8, 7, 3, },
1229 { 12,11, 8, 1,15, 3, 2, 9,10,13,14, 4, 5, 6, 7, 0, },
1230 { 8, 7, 0,11,12, 5, 6,15,14, 9,10, 1, 2, 3, 4,13, },
1231 { 3, 2, 1, 0,14, 9, 8, 7, 6, 4,15,13,12,11,10, 5, },
1232 { 2,10,11,12,13, 7, 8, 9,15, 1, 0, 3, 4, 5, 6,14, },
1233 { 12,11,10, 9, 2, 7, 6, 5, 4,13,14, 0,15, 1, 8, 3, },
1234 };
1235
key(INT32 table,INT32 addr)1236 static inline INT32 key(INT32 table, INT32 addr)
1237 {
1238 return BIT(key_table[addr & 0xff] >> 4, table) ^ BIT(addr,(8 + ((table & 0xc) >> 2)));
1239 }
1240
seibuspi_sprite_decrypt(UINT8 * src,int rom_size)1241 void seibuspi_sprite_decrypt(UINT8 *src, int rom_size)
1242 {
1243 for (int i = 0; i < rom_size/2; i++)
1244 {
1245 const INT32 addr = i >> 8;
1246 const UINT16 y1 = src[2 * i + 0 * rom_size + 0] + (src[2 * i + 0 * rom_size + 1] << 8);
1247 const UINT16 y2 = src[2 * i + 1 * rom_size + 0] + (src[2 * i + 1 * rom_size + 1] << 8);
1248 UINT16 y3 = src[2 * i + 2 * rom_size + 0] + (src[2 * i + 2 * rom_size + 1] << 8);
1249
1250 const UINT8 *bs = spi_bitswap[key_table[addr & 0xff] & 0xf];
1251 y3 = BITSWAP16(y3, bs[0],bs[1],bs[2],bs[3],bs[4],bs[5],bs[6],bs[7],
1252 bs[8],bs[9],bs[10],bs[11],bs[12],bs[13],bs[14],bs[15]);
1253
1254 UINT32 s1 = (BIT(y1, 4) << 0) | (BIT(y3, 7) << 1) | (BIT(y3, 6) << 2) | (BIT(y2,12) << 3) | (BIT(y2, 3) << 4) | (BIT(y1,10) << 5) | (BIT(y1, 1) << 6) | (BIT(y3,14) << 7) |
1255 (BIT(y3, 2) << 8) | (BIT(y2, 9) << 9) | (BIT(y2, 0) << 10) | (BIT(y1, 7) << 11) | (BIT(y3,12) << 12) | (BIT(y2,15) << 13) | (BIT(y2, 6) << 14) | (BIT(y1,13) << 15);
1256
1257 UINT32 add1 = (BIT(addr,11) << 0) | (BIT(addr,10) << 1) | (key(10,addr) << 2) | (key( 5,addr) << 3) | (key( 4,addr) << 4) | (BIT(addr,11) << 5) | (BIT(addr,11) << 6) | (key( 7,addr) << 7) |
1258 (key( 6,addr) << 8) | (key( 1,addr) << 9) | (key( 0,addr) << 10) | (BIT(addr,11) << 11) | (key( 9,addr) << 12) | (key( 8,addr) << 13) | (key( 3,addr) << 14) | (key( 2,addr) << 15);
1259
1260 UINT32 s2 = (BIT(y1, 5) << 0) | (BIT(y3, 0) << 1) | (BIT(y3, 5) << 2) | (BIT(y2,13) << 3) | (BIT(y2, 4) << 4) | (BIT(y1,11) << 5) | (BIT(y1, 2) << 6) | (BIT(y3, 9) << 7) |
1261 (BIT(y3, 3) << 8) | (BIT(y2, 8) << 9) | (BIT(y1,15) << 10) | (BIT(y1, 6) << 11) | (BIT(y3,11) << 12) | (BIT(y2,14) << 13) | (BIT(y2, 5) << 14) | (BIT(y1,12) << 15) |
1262 (BIT(y1, 3) << 16) | (BIT(y3, 8) << 17) | (BIT(y3,15) << 18) | (BIT(y2,11) << 19) | (BIT(y2, 2) << 20) | (BIT(y1, 9) << 21) | (BIT(y1, 0) << 22) | (BIT(y3,10) << 23) |
1263 (BIT(y3, 1) << 24) | (BIT(y2,10) << 25) | (BIT(y2, 1) << 26) | (BIT(y1, 8) << 27) | (BIT(y3,13) << 28) | (BIT(y3, 4) << 29) | (BIT(y2, 7) << 30) | (BIT(y1,14) << 31);
1264
1265 UINT32 add2 = (key( 0,addr) << 0) | (key( 1,addr) << 1) | (key( 2,addr) << 2) | (key( 3,addr) << 3) | (key( 4,addr) << 4) | (key( 5,addr) << 5) | (key( 6,addr) << 6) | (key( 7,addr) << 7) |
1266 (key( 8,addr) << 8) | (key( 9,addr) << 9) | (key(10,addr) << 10) | (BIT(addr,10) << 11) | (BIT(addr,11) << 12) | (BIT(addr,11) << 13) | (BIT(addr,11) << 14) | (BIT(addr,11) << 15) |
1267 (BIT(addr,11) << 16) | (key( 7,addr) << 17) | (BIT(addr,11) << 18) | (key( 6,addr) << 19) | (BIT(addr,11) << 20) | (key( 5,addr) << 21) | (BIT(addr,11) << 22) | (key( 4,addr) << 23) |
1268 (BIT(addr,10) << 24) | (key( 3,addr) << 25) | (key(10,addr) << 26) | (key( 2,addr) << 27) | (key( 9,addr) << 28) | (key( 1,addr) << 29) | (key( 8,addr) << 30) | (key( 0,addr) << 31);
1269
1270 s1 = partial_carry_sum( s1, add1, 0x3a59, 16 ) ^ 0x843a;
1271 s2 = partial_carry_sum( s2, add2, 0x28d49cac, 32 ) ^ 0xc8e29f84;
1272
1273 UINT8 plane0 = 0, plane1 = 0, plane2 = 0, plane3 = 0, plane4 = 0, plane5 = 0;
1274 for (INT32 j = 0; j < 8; j++)
1275 {
1276 plane5 |= (BIT(s1, 2 * j + 1) << j);
1277 plane4 |= (BIT(s1, 2 * j + 0) << j);
1278 plane3 |= (BIT(s2, 4 * j + 3) << j);
1279 plane2 |= (BIT(s2, 4 * j + 2) << j);
1280 plane1 |= (BIT(s2, 4 * j + 1) << j);
1281 plane0 |= (BIT(s2, 4 * j + 0) << j);
1282 }
1283
1284 src[2 * i + 0 * rom_size + 0] = plane5;
1285 src[2 * i + 0 * rom_size + 1] = plane4;
1286 src[2 * i + 1 * rom_size + 0] = plane3;
1287 src[2 * i + 1 * rom_size + 1] = plane2;
1288 src[2 * i + 2 * rom_size + 0] = plane1;
1289 src[2 * i + 2 * rom_size + 1] = plane0;
1290 }
1291 }
1292
DrvGfxDecode(INT32 len0,INT32 len1,INT32 len2)1293 static INT32 DrvGfxDecode(INT32 len0, INT32 len1, INT32 len2)
1294 {
1295 INT32 Plane0[5] = { 4, 8, 12, 16, 20 };
1296 INT32 Plane1[6] = { 0, 4, 8, 12, 16, 20 };
1297 INT32 Plane2[6] = { 0, 8, (((len2 * 8) / 3) * 1) + 0, (((len2 * 8) / 3) * 1) + 8, (((len2 * 8) / 3) * 2) + 0, (((len2 * 8) / 3) * 2) + 8 };
1298 INT32 XOffs0[8] = { STEP4(3,-1), STEP4(4*6+3,-1) };
1299 INT32 XOffs1[16] = { STEP4(3,-1), STEP4(4*6+3,-1), STEP4(4*6*2+3,-1), STEP4(4*6*3+3,-1) };
1300 INT32 XOffs2[16] = { STEP8(7,-1), STEP8(8*2+7,-1) };
1301 INT32 YOffs0[8] = { STEP8(0,4*6*2) };
1302 INT32 YOffs1[16] = { STEP16(0,4*6*4) };
1303 INT32 YOffs2[16] = { STEP16(0,8*4) };
1304
1305 UINT8 *tmp = (UINT8*)BurnMalloc(len2);
1306 if (tmp == NULL) {
1307 return 1;
1308 }
1309
1310 memcpy (tmp, DrvGfxROM[0], len0);
1311
1312 GfxDecode(((len0 * 8) / 5) / (8 * 8), 5, 8, 8, Plane0, XOffs0, YOffs0, 0x180, tmp, DrvGfxROM[0]);
1313
1314 memcpy (tmp, DrvGfxROM[1], len1);
1315
1316 GfxDecode(((len1 * 8) / 6) / (16 * 16), 6, 16, 16, Plane1, XOffs1, YOffs1, 0x600, tmp, DrvGfxROM[1]);
1317
1318 memcpy (tmp, DrvGfxROM[2], len2);
1319
1320 GfxDecode(((len2 * 8) / 6) / (16 * 16), 6, 16, 16, Plane2, XOffs2, YOffs2, 0x200, tmp, DrvGfxROM[2]);
1321
1322 BurnFree (tmp);
1323
1324 return 0;
1325 }
1326
sys386fGfxDecode()1327 static void sys386fGfxDecode()
1328 {
1329 INT32 fraq = (0x1000000 * 8) / 4;
1330 INT32 Planes[8] = { 0, 8, (fraq * 1) + 0, (fraq * 1) + 8, (fraq * 2) + 0, (fraq * 2) + 8, (fraq * 3) + 0, (fraq * 3) + 8 };
1331 INT32 XOffs[16] = { STEP8(7,-1), STEP8(8*2+7,-1) };
1332 INT32 YOffs[16] = { STEP16(0,8*4) };
1333
1334 UINT8 *tmp = (UINT8*)BurnMalloc(0x1000000);
1335 if (tmp == NULL) {
1336 return;
1337 }
1338
1339 BurnByteswap(DrvGfxROM[2], 0x1000000);
1340
1341 for (INT32 i = 0; i < 0x1000000; i++) {
1342 tmp[i] = DrvGfxROM[2][(i & 0xffffffc1) | ((i & 2) << 4) | ((i & 0x3c) >> 1)];
1343 }
1344
1345 GfxDecode(0x10000, 8, 16, 16, Planes, XOffs, YOffs, 0x200, tmp, DrvGfxROM[2]);
1346
1347 BurnFree(tmp);
1348 }
1349
1350 static const eeprom_interface seibuspi_eeprom =
1351 {
1352 6, // address bits
1353 16, // data bits
1354 "*110", // read command
1355 "*101", // write command
1356 "*111", // erase command
1357 "*10000xxxx", // lock command
1358 "*10011xxxx", // unlock command
1359 1, // enable_multi_read
1360 1 // reset_delay
1361 };
1362
graphics_init(INT32 decrypt_type,INT32 graphics_len0,INT32 graphics_len1,INT32 graphics_len2)1363 static void graphics_init(INT32 decrypt_type, INT32 graphics_len0, INT32 graphics_len1, INT32 graphics_len2)
1364 {
1365 switch (decrypt_type)
1366 {
1367 case DECRYPT_SEI252: // Senkyu / Viprph1 / Rdft / Rdfts
1368 decrypt_text(DrvGfxROM[0], graphics_len0, 0x5a3845, 0x77cf5b, 0x1378df);
1369 decrypt_bg(DrvGfxROM[1], graphics_len1, 0x5a3845, 0x77cf5b, 0x1378df);
1370 seibuspi_sprite_decrypt(DrvGfxROM[2], 0x400000);
1371 break;
1372
1373 case DECRYPT_RISE10: // Rdft2
1374 decrypt_text(DrvGfxROM[0], graphics_len0, 0x823146, 0x4de2f8, 0x157adc);
1375 decrypt_bg(DrvGfxROM[1], graphics_len1, 0x823146, 0x4de2f8, 0x157adc);
1376 seibuspi_rise10_sprite_decrypt(DrvGfxROM[2], 0x600000);
1377 break;
1378
1379 case DECRYPT_RISE11: // Rfjet
1380 decrypt_text(DrvGfxROM[0], graphics_len0, 0xaea754, 0xfe8530, 0xccb666);
1381 decrypt_bg(DrvGfxROM[1], graphics_len1, 0xaea754, 0xfe8530, 0xccb666);
1382 seibuspi_rise11_sprite_decrypt(DrvGfxROM[2], 0x800000, 0xabcb64, 0x55aadd, 0xab6a4c, 0xd6375b, 0x8bf23b);
1383 break;
1384 }
1385
1386 DrvGfxDecode(graphics_len0, graphics_len1, graphics_len2);
1387
1388 GenericTilesInit();
1389 GenericTilemapInit(0, TILEMAP_SCAN_ROWS, text_map_callback, 8, 8, 64, 32);
1390 GenericTilemapInit(1, TILEMAP_SCAN_COLS, back_map_callback, 16, 16, 32, 32);
1391 GenericTilemapInit(2, TILEMAP_SCAN_COLS, midl_map_callback, 16, 16, 32, 32);
1392 GenericTilemapInit(3, TILEMAP_SCAN_COLS, fore_map_callback, 16, 16, 32, 32);
1393 GenericTilemapSetGfx(0, DrvGfxROM[2], 6, 16, 16, (graphics_len2 * 8) / 6, 0x0000, 0x3f);
1394 GenericTilemapSetGfx(1, DrvGfxROM[1], 6, 16, 16, (graphics_len1 * 8) / 6, 0x1000, 0x3f);
1395 GenericTilemapSetGfx(2, DrvGfxROM[0], 5, 8, 8, 0x0040000, 0x1600, 0x3f);
1396 GenericTilemapSetTransparent(0, 0x1f);
1397 GenericTilemapSetTransparent(1, 0x3f);
1398 GenericTilemapSetTransparent(2, 0x3f);
1399 GenericTilemapSetTransparent(3, 0x3f);
1400 GenericTilemapSetScrollRows(1, 512);
1401 GenericTilemapSetScrollRows(2, 512);
1402 GenericTilemapSetScrollRows(3, 512);
1403 GenericTilemapBuildSkipTable(0, 2, 0x1f);
1404 GenericTilemapBuildSkipTable(1, 1, 0x3f);
1405 GenericTilemapBuildSkipTable(2, 1, 0x3f);
1406 GenericTilemapBuildSkipTable(3, 1, 0x3f);
1407
1408 bg_fore_layer_position = (graphics_len1 <= 0x300000) ? 0x2000 : ((graphics_len1 <= 0x600000) ? 0x4000 : 0x8000);
1409 sprite_ram_size = 0x1000; // always 1000 unless hardware only has sprites...
1410
1411 memset(DrvAlphaTable, 0, 0x2000);
1412 memset(DrvAlphaTable + 0x730, 1, 0x10);
1413 memset(DrvAlphaTable + 0x780, 1, 0x20);
1414 memset(DrvAlphaTable + 0xfc0, 1, 0x40);
1415 memset(DrvAlphaTable + 0x1200 + 0x160, 1, 0x20);
1416 memset(DrvAlphaTable + 0x1200 + 0x1b0, 1, 0x10);
1417 memset(DrvAlphaTable + 0x1200 + 0x1f0, 1, 0x10);
1418 memset(DrvAlphaTable + 0x1400 + 0x1b0, 1, 0x10);
1419 memset(DrvAlphaTable + 0x1400 + 0x1f0, 1, 0x10);
1420 memset(DrvAlphaTable + 0x1600 + 0x170, 1, 0x10);
1421 memset(DrvAlphaTable + 0x1600 + 0x1f0, 1, 0x10);
1422 }
1423
install_speedhack(UINT32 address,UINT32 pc)1424 static void install_speedhack(UINT32 address, UINT32 pc)
1425 {
1426 if (address >= 0x40000) return;
1427
1428 speedhack_address = address;
1429 speedhack_pc = pc;
1430
1431 i386Open(0);
1432 i386MapMemory(NULL, address & ~0xfff, address | 0xfff, MAP_ROM);
1433 i386Close();
1434 }
1435
DrvLoadRom(bool bLoad)1436 static INT32 DrvLoadRom(bool bLoad)
1437 {
1438 char *pRomName;
1439 struct BurnRomInfo ri, ci, di, ei;
1440 UINT8 *pLoad[4] = { DrvGfxROM[1], DrvGfxROM[2], DrvSndROM[0], DrvGfxROM[0] };
1441 INT32 sampletype = 0; // 1 = flash, 2 = ymf271/ymz280b, 3 = msm6295
1442 INT32 samplelength = 0;
1443
1444 for (INT32 i = 0; !BurnDrvGetRomName(&pRomName, i, 0); i++)
1445 {
1446 BurnDrvGetRomInfo(&ri, i);
1447 BurnDrvGetRomInfo(&ci, i+1);
1448 BurnDrvGetRomInfo(&di, i+2);
1449 BurnDrvGetRomInfo(&ei, i+3);
1450
1451 if ((ri.nType & BRF_PRG) && (ri.nType & 7) == 1)
1452 {
1453 if (ei.nType == ri.nType) // 4x program roms
1454 {
1455 if (bLoad) {
1456 UINT8 *dest = DrvMainROM + ((ri.nLen < 0x80000) ? ((0x80000 - ri.nLen) * 4) : 0); // program roms need to inhabit end of rom space
1457 if (BurnLoadRomExt(dest + 0, i+0, 4, LD_GROUP(1))) return 1;
1458 if (BurnLoadRomExt(dest + 1, i+1, 4, LD_GROUP(1))) return 1;
1459 if (BurnLoadRomExt(dest + 2, i+2, 4, LD_GROUP(1))) return 1;
1460 if (BurnLoadRomExt(dest + 3, i+3, 4, LD_GROUP(1))) return 1;
1461 }
1462 i += 3;
1463 }
1464 else if (di.nType == ri.nType) // 3x program roms
1465 {
1466 if (bLoad) {
1467 if (BurnLoadRomExt(DrvMainROM + 0, i+0, 4, LD_GROUP(1))) return 1;
1468 if (BurnLoadRomExt(DrvMainROM + 1, i+1, 4, LD_GROUP(1))) return 1;
1469 if (BurnLoadRomExt(DrvMainROM + 2, i+2, 4, LD_GROUP(2))) return 1;
1470 }
1471 i += 2;
1472 }
1473 else if (ci.nType == ri.nType) // 2x program roms
1474 {
1475 if (bLoad) {
1476 if (BurnLoadRomExt(DrvMainROM + 0, i+0, 4, LD_GROUP(2))) return 1;
1477 if (BurnLoadRomExt(DrvMainROM + 2, i+1, 4, LD_GROUP(2))) return 1;
1478 }
1479 i += 1;
1480 }
1481
1482 continue;
1483 }
1484
1485 if ((ri.nType & BRF_PRG) && (ri.nType & 7) == 2) { // z80 rom
1486 if (bLoad) {
1487 if (BurnLoadRomExt(DrvZ80RAM, i, 1, LD_GROUP(1))) return 1;
1488 }
1489 rom_based_z80 = 1;
1490 continue;
1491 }
1492
1493 if ((ri.nType & BRF_PRG) && (ri.nType & 7) == 7) { // default eeprom
1494 if (bLoad) {
1495 if (BurnLoadRomExt(DefaultEEPROM, i, 1, LD_GROUP(1))) return 1;
1496 }
1497 continue;
1498 }
1499
1500 if ((ri.nType & BRF_GRA) && (ri.nType & 7) == 1) // character roms
1501 {
1502 pLoad[3] += 0x30000;
1503 if (ri.nType == di.nType) // 3x character roms
1504 {
1505 if (bLoad) {
1506 if (BurnLoadRomExt(DrvGfxROM[0] + 1, i+0, 3, LD_GROUP(1))) return 1; // most loaded this way!
1507 if (BurnLoadRomExt(DrvGfxROM[0] + 0, i+1, 3, LD_GROUP(1))) return 1;
1508 if (BurnLoadRomExt(DrvGfxROM[0] + 2, i+2, 3, LD_GROUP(1))) return 1;
1509 }
1510 i += 2;
1511 }
1512 else if (ri.nType == ci.nType) // 2x character roms
1513 {
1514 if (bLoad) {
1515 if (BurnLoadRomExt(DrvGfxROM[0] + 0, i+0, 3, LD_GROUP(2) | LD_BYTESWAP)) return 1;
1516 if (BurnLoadRomExt(DrvGfxROM[0] + 2, i+1, 3, LD_GROUP(1))) return 1;
1517 }
1518 i += 1;
1519 }
1520
1521 continue;
1522 }
1523
1524 if ((ri.nType & BRF_GRA) && (ri.nType & 7) == 2) // background tiles
1525 {
1526 if (bLoad) {
1527 if (BurnLoadRomExt(pLoad[0] + 0, i+0, 3, LD_GROUP(2) | LD_BYTESWAP)) return 1;
1528 if (BurnLoadRomExt(pLoad[0] + 2, i+1, 3, LD_GROUP(1))) return 1;
1529 }
1530 pLoad[0] += ri.nLen + ci.nLen;
1531 i += 1;
1532 continue;
1533 }
1534
1535 if ((ri.nType & BRF_GRA) && (ri.nType & 7) == 3) // sprites
1536 {
1537 if (bLoad) {
1538 if (BurnLoadRomExt(pLoad[1], i, 1, LD_GROUP(1))) return 1;
1539 }
1540 pLoad[1] += ri.nLen;
1541 continue;
1542 }
1543
1544 if ((ri.nType & BRF_PRG) && (ri.nType & 7) == 3) // ymf samples (flash rom)
1545 {
1546 sampletype = 1;
1547 samplelength += ri.nLen;
1548 if (bLoad) {
1549 if (BurnLoadRomExt(DrvSndROM[0] + 0x0000000, i+0, 4, LD_GROUP((ri.nLen <= 0x100000) ? 1 : 2))) return 1;
1550
1551 memcpy (DrvSndROM[0] + 0x400000, DrvSndROM[0] + 0x200000, 0x200000);
1552 memset (DrvSndROM[0] + 0x200000, 0, 0x200000);
1553
1554 if (ci.nType == ri.nType) {
1555 if (BurnLoadRomExt(DrvSndROM[0] + 0x0800000, i+1, 4, LD_GROUP(1))) return 1;
1556 }
1557 }
1558
1559 if (ci.nType == ri.nType) {
1560 i += 1;
1561 samplelength += ci.nLen;
1562 }
1563
1564 continue;
1565 }
1566
1567 if ((ri.nType & BRF_SND) && (ri.nType & 7) == 1) // ymf samples (no flash rom) / ymz280b samples
1568 {
1569 sampletype = 2;
1570 if (bLoad) {
1571 if (BurnLoadRomExt(pLoad[2], i, 1, LD_GROUP(1))) return 1;
1572 }
1573 pLoad[2] += ri.nLen;
1574 continue;
1575 }
1576
1577 if ((ri.nType & BRF_SND) && (ri.nType & 6) == 4) // MSM6295 samples
1578 {
1579 sampletype = 3;
1580 samplelength += ri.nLen;
1581
1582 if (bLoad) {
1583 if (BurnLoadRomExt(DrvSndROM[ri.nType & 1], i, 1, LD_GROUP(1))) return 1;
1584 }
1585 continue;
1586 }
1587 }
1588
1589 if (!bLoad) {
1590 graphics_len[0] = pLoad[3] - DrvGfxROM[0];
1591 graphics_len[1] = pLoad[0] - DrvGfxROM[1];
1592 graphics_len[2] = pLoad[1] - DrvGfxROM[2];
1593 bprintf (0, _T("gfx0: %x, gfx1: %x, gfx2: %x\n"), graphics_len[0], graphics_len[1], graphics_len[2]);
1594 switch (sampletype) {
1595 case 0: bprintf(0, _T("no samples.\n")); break;
1596 case 1: bprintf(0, _T("ymf271 flash samples: %x\n"), samplelength); break;
1597 case 2: bprintf(0, _T("ymf271/ymz280b samples: %x\n"), pLoad[2] - DrvSndROM[0]); break;
1598 case 3: bprintf(0, _T("msm6295 samples: %x\n"), samplelength); break;
1599 }
1600 if (rom_based_z80) bprintf (0, _T("Has ROM-based Z80\n"));
1601 }
1602
1603 return 0;
1604 }
1605
CommonInit(INT32 decrypt_type,void (* pCallback)(),UINT32 speedhack_addr,UINT32 speedhack_pc_val)1606 static INT32 CommonInit(INT32 decrypt_type, void (*pCallback)(), UINT32 speedhack_addr, UINT32 speedhack_pc_val)
1607 {
1608 BurnSetRefreshRate(54.00);
1609
1610 DrvLoadRom(false);
1611 BurnAllocMemIndex();
1612 DrvLoadRom(true);
1613
1614 i386Init(0);
1615 i386Open(0);
1616 i386MapMemory(DrvMainRAM + 0x1000, 0x00001000, 0x0003ffff, MAP_RAM);
1617 i386MapMemory(DrvMainROM, 0x00200000, 0x003fffff, MAP_ROM);
1618 i386MapMemory(DrvSndROM[0], 0x00a00000, 0x013fffff, MAP_ROM);
1619 i386MapMemory(DrvMainROM, 0xffe00000, 0xffffffff, MAP_ROM);
1620 i386SetReadHandlers(common_read_byte, common_read_word, spi_read_dword);
1621 i386SetWriteHandlers(spi_write_byte, spi_write_word, spi_write_dword);
1622 i386SetIRQCallback(SeibuspiIRQCallback);
1623 i386Close();
1624
1625 ZetInit(0);
1626 ZetOpen(0);
1627 ZetMapMemory(DrvZ80RAM, 0x0000, 0x1fff, MAP_ROM);
1628 ZetMapMemory(DrvZ80WorkRAM, 0x2000, 0x3fff, MAP_RAM);
1629 ZetSetWriteHandler(spi_sound_write);
1630 ZetSetReadHandler(spi_sound_read);
1631 ZetClose();
1632
1633 intelflash_init(0, FLASH_INTEL_E28F008SA, DrvSndROM[0] + 0xa00000 );
1634 intelflash_init(1, FLASH_INTEL_E28F008SA, DrvSndROM[0] + 0xb00000 );
1635
1636 DrvSndROM[0][0xa00000] = DrvMainROM[0x1ffffc]; // HACK! -set flash region...
1637
1638 BurnYMF271Init(16934400, DrvSndROM[0], 0x280000, spiZ80IRQCallback, 0);
1639 #if 0
1640 BurnYMF271SetRoute(0, 1.00, BURN_SND_ROUTE_LEFT);
1641 BurnYMF271SetRoute(1, 1.00, BURN_SND_ROUTE_RIGHT);
1642 BurnYMF271SetRoute(2, 1.00, BURN_SND_ROUTE_LEFT);
1643 BurnYMF271SetRoute(3, 1.00, BURN_SND_ROUTE_RIGHT);
1644 #endif
1645 BurnYMF271SetAllRoutes(1.00, BURN_SND_ROUTE_BOTH); // sounds better MONO.
1646 BurnTimerAttachZet(7159090);
1647
1648 ymf271_set_external_handlers(rom_based_z80 ? NULL : ymf271_external_read, rom_based_z80 ? NULL : ymf271_external_write);
1649 sound_system = 1;
1650
1651 graphics_init(decrypt_type, graphics_len[0], graphics_len[1], graphics_len[2]);
1652
1653 if (speedhack_addr) install_speedhack(speedhack_addr, speedhack_pc_val);
1654
1655 if (pCallback) {
1656 pCallback();
1657 }
1658
1659 DrvDoReset(1);
1660
1661 return 0;
1662 }
1663
Sys386fInit()1664 static INT32 Sys386fInit()
1665 {
1666 BurnSetRefreshRate(54.00);
1667
1668 sound_system = 2;
1669
1670 DrvLoadRom(false);
1671 BurnAllocMemIndex();
1672 DrvLoadRom(true);
1673
1674 sys386fGfxDecode();
1675 sprite_ram_size = 0x2000;
1676
1677 i386Init(0);
1678 i386Open(0);
1679 i386MapMemory(DrvMainRAM + 0x1000, 0x00001000, 0x0003ffff, MAP_RAM);
1680 i386MapMemory(DrvMainROM, 0x00200000, 0x003fffff, MAP_ROM);
1681 i386MapMemory(DrvMainROM, 0xffe00000, 0xffffffff, MAP_ROM);
1682 i386SetReadHandlers(common_read_byte, common_read_word, sys386f_read_dword);
1683 i386SetWriteHandlers(common_write_byte, sys386f_write_word, common_write_dword);
1684 i386SetIRQCallback(SeibuspiIRQCallback);
1685 i386Close();
1686
1687 EEPROMInit(&seibuspi_eeprom);
1688 has_eeprom = 1;
1689
1690 YMZ280BInit(16934400, NULL);
1691 YMZ280BSetRoute(BURN_SND_YMZ280B_YMZ280B_ROUTE_1, 0.80, BURN_SND_ROUTE_LEFT);
1692 YMZ280BSetRoute(BURN_SND_YMZ280B_YMZ280B_ROUTE_2, 0.80, BURN_SND_ROUTE_RIGHT);
1693
1694 GenericTilesInit();
1695 GenericTilemapSetGfx(0, DrvGfxROM[2], 8, 16, 16, 0x1000000, 0x0000, 0x1f);
1696
1697 // install_speedhack(0, 0);
1698
1699 DrvDoReset(1);
1700
1701 return 0;
1702 }
1703
Sys368iCommonInit(INT32 decrypt_type,void (* pCallback)(),UINT32 speedhack_addr,UINT32 speedhack_pc_val)1704 static INT32 Sys368iCommonInit(INT32 decrypt_type, void (*pCallback)(), UINT32 speedhack_addr, UINT32 speedhack_pc_val)
1705 {
1706 BurnSetRefreshRate(54.00);
1707
1708 DrvLoadRom(false);
1709 BurnAllocMemIndex();
1710 DrvLoadRom(true);
1711
1712 i386Init(0);
1713 i386Open(0);
1714 i386MapMemory(DrvMainRAM + 0x1000, 0x00001000, 0x0003ffff, MAP_RAM);
1715 i386MapMemory(DrvMainROM, 0x00200000, 0x003fffff, MAP_ROM);
1716 i386MapMemory(DrvMainROM, 0xffe00000, 0xffffffff, MAP_ROM);
1717 i386SetReadHandlers(common_read_byte, common_read_word, spi_i386_read_dword);
1718 i386SetWriteHandlers(common_write_byte, spi_i386_write_word, spi_i386_write_dword);
1719 i386SetIRQCallback(SeibuspiIRQCallback);
1720 i386Close();
1721
1722 install_speedhack(speedhack_addr, speedhack_pc_val);
1723
1724 EEPROMInit(&seibuspi_eeprom);
1725 has_eeprom = 1;
1726
1727 MSM6295Init(0, 1431818 / MSM6295_PIN7_HIGH, 0);
1728 MSM6295Init(1, 1431818 / MSM6295_PIN7_HIGH, 0);
1729 MSM6295SetRoute(0, 0.47, BURN_SND_ROUTE_BOTH);
1730 MSM6295SetRoute(1, 0.47, BURN_SND_ROUTE_BOTH);
1731
1732 sound_system = 0;
1733
1734 if (pCallback) {
1735 pCallback();
1736 }
1737
1738 graphics_init(decrypt_type, graphics_len[0], graphics_len[1], graphics_len[2]);
1739
1740 DrvDoReset(1);
1741
1742 return 0;
1743 }
1744
DrvExit()1745 static INT32 DrvExit()
1746 {
1747 GenericTilesExit();
1748
1749 i386Exit();
1750
1751 if (sound_system == 0) {
1752 MSM6295Exit(0);
1753 MSM6295Exit(1);
1754 }
1755 else if (sound_system == 1)
1756 {
1757 #if 0
1758 char name[128];
1759 sprintf (name, "%s-flash0.bin", BurnDrvGetTextA(DRV_NAME));
1760 FILE *fa = fopen(name, "wb");
1761 fwrite (DrvSndROM[0] + 0xa00000, 0x100000, 1, fa);
1762 fclose (fa);
1763
1764 sprintf (name, "%s-flash1.bin", BurnDrvGetTextA(DRV_NAME));
1765
1766 fa = fopen(name, "wb");
1767 fwrite (DrvSndROM[0] + 0xb00000, 0x100000, 1, fa);
1768 fclose (fa);
1769 #endif
1770 ZetExit();
1771 BurnYMF271Exit();
1772 intelflash_exit();
1773 }
1774 else if (sound_system == 2)
1775 {
1776 YMZ280BExit();
1777 YMZ280BROM = NULL;
1778 }
1779
1780 if (has_eeprom) EEPROMExit();
1781
1782 sound_system = 0;
1783 rom_based_z80 = 0;
1784 has_eeprom = 0;
1785 DefaultNVRAM = NULL;
1786
1787 BurnFreeMemIndex();
1788
1789 return 0;
1790 }
1791
DrvPaletteUpdate()1792 static void DrvPaletteUpdate()
1793 {
1794 for (INT32 i = 0; i < BurnDrvGetPaletteEntries()/2; i++)
1795 {
1796 UINT32 color = BURN_ENDIAN_SWAP_INT32(palette_ram[i]);
1797
1798 DrvPalette[(i * 2) + 0] = (pal5bit(color >> 0) << 16) | (pal5bit(color >> 5) << 8) | pal5bit(color >> 10);
1799 DrvPalette[(i * 2) + 1] = (pal5bit(color >> 16) << 16) | (pal5bit(color >> 21) << 8) | pal5bit(color >> 26);
1800 }
1801
1802 DrvPalette[0x2000] = 0; // black
1803 }
1804
alpha_blend(UINT32 d,UINT32 s)1805 static inline UINT32 alpha_blend(UINT32 d, UINT32 s)
1806 {
1807 return (((((s & 0xff00ff) * 0x7f) + ((d & 0xff00ff) * 0x81)) & 0xff00ff00) +
1808 ((((s & 0x00ff00) * 0x7f) + ((d & 0x00ff00) * 0x81)) & 0x00ff0000)) / 0x100;
1809 }
1810
drawgfx_blend(GenericTilesGfx * gfx,UINT32 code,UINT32 color,INT32 flipx,INT32 flipy,INT32 sx,INT32 sy,UINT8 primask)1811 static void drawgfx_blend(GenericTilesGfx *gfx, UINT32 code, UINT32 color, INT32 flipx, INT32 flipy, INT32 sx, INT32 sy, UINT8 primask)
1812 {
1813 const INT32 width = gfx->width;
1814 const INT32 height = gfx->height;
1815
1816 INT32 x1 = sx;
1817 INT32 x2 = sx + width - 1;
1818 INT32 y1 = sy;
1819 INT32 y2 = sy + height - 1;
1820
1821 if (x1 > (nScreenWidth - 1) || x2 < 0) {
1822 return;
1823 }
1824
1825 if (y1 > (nScreenHeight - 1) || y2 < 0) {
1826 return;
1827 }
1828
1829 INT32 px = 0;
1830 INT32 py = 0;
1831 INT32 xd = 1;
1832 INT32 yd = 1;
1833
1834 if (flipx)
1835 {
1836 xd = -xd;
1837 px = width - 1;
1838 }
1839
1840 if (flipy)
1841 {
1842 yd = -yd;
1843 py = height - 1;
1844 }
1845
1846 if (x1 < 0)
1847 {
1848 if (flipx)
1849 {
1850 px = width - (0 - x1) - 1;
1851 }
1852 else
1853 {
1854 px = (0 - x1);
1855 }
1856 x1 = 0;
1857 }
1858
1859 if (x2 > (nScreenWidth - 1))
1860 {
1861 x2 = (nScreenWidth - 1);
1862 }
1863
1864 if (y1 < 0)
1865 {
1866 if (flipy)
1867 {
1868 py = height - (0 - y1) - 1;
1869 }
1870 else
1871 {
1872 py = (0 - y1);
1873 }
1874 y1 = 0;
1875 }
1876
1877 if (y2 > (nScreenHeight - 1))
1878 {
1879 y2 = (nScreenHeight - 1);
1880 }
1881
1882 color = gfx->color_offset + ((color & gfx->color_mask) << gfx->depth);
1883 const UINT8 *src = gfx->gfxbase + ((code % gfx->code_mask) * gfx->width * gfx->height);
1884 const UINT8 trans_pen = (1 << gfx->depth) - 1;
1885
1886 for (int y = y1; y <= y2; y++)
1887 {
1888 UINT32 *pal = DrvPalette;
1889 UINT32 *dest = bitmap32 + y * nScreenWidth;
1890 UINT8 *pri = pPrioDraw + y * nScreenWidth;
1891 int src_i = (py * width) + px;
1892 py += yd;
1893
1894 for (int x = x1; x <= x2; x++)
1895 {
1896 const UINT8 pen = src[src_i];
1897 if (!(pri[x] & primask) && pen != trans_pen)
1898 {
1899 pri[x] |= primask;
1900 const UINT16 global_pen = pen + color;
1901 if (DrvAlphaTable[global_pen])
1902 dest[x] = alpha_blend(dest[x], pal[global_pen]);
1903 else
1904 dest[x] = pal[global_pen];
1905 }
1906 src_i += xd;
1907 }
1908 }
1909 }
1910
draw_sprites(UINT32 priority)1911 static void draw_sprites(UINT32 priority)
1912 {
1913 if ((nSpriteEnable & 1) == 0 || (layer_enable & 0x10)) return;
1914
1915 GenericTilesGfx *gfx = &GenericGfxData[0];
1916
1917 for (INT32 a = 0; a < sprite_ram_size / 4; a += 2)
1918 {
1919 INT32 code = (BURN_ENDIAN_SWAP_INT32(sprite_ram[a + 0]) >> 16) | ((BURN_ENDIAN_SWAP_INT32(sprite_ram[a + 1]) & 0x1000) << 4);
1920 if ((code % gfx->code_mask) == 0) continue; // speed-up
1921
1922 if (priority != ((BURN_ENDIAN_SWAP_INT32(sprite_ram[a + 0]) >> 6) & 0x3))
1923 continue;
1924
1925 INT16 xpos = BURN_ENDIAN_SWAP_INT32(sprite_ram[a + 1]) & 0x3ff;
1926 INT16 ypos = BURN_ENDIAN_SWAP_INT32(sprite_ram[a + 1]) >> 16 & 0x1ff;
1927 INT32 color = BURN_ENDIAN_SWAP_INT32(sprite_ram[a + 0]) & 0x3f;
1928 if (xpos & 0x200) xpos |= 0xfc00;
1929 if (ypos & 0x100) ypos |= 0xfe00;
1930
1931 INT32 width =((BURN_ENDIAN_SWAP_INT32(sprite_ram[a + 0]) >> 8) & 7) + 1;
1932 INT32 height =((BURN_ENDIAN_SWAP_INT32(sprite_ram[a + 0]) >> 12) & 7) + 1;
1933 INT32 flip_x = (BURN_ENDIAN_SWAP_INT32(sprite_ram[a + 0]) >> 11) & 1;
1934 INT32 flip_y = (BURN_ENDIAN_SWAP_INT32(sprite_ram[a + 0]) >> 15) & 1;
1935 INT32 x1 = 0;
1936 INT32 y1 = 0;
1937 INT32 flip_y_pos = 0;
1938 INT32 flip_x_pos = 0;
1939
1940 if (flip_x)
1941 {
1942 x1 = 8 - width;
1943 width = width + x1;
1944 flip_x_pos = 0x70;
1945 }
1946
1947 if (flip_y)
1948 {
1949 y1 = 8 - height;
1950 height = height + y1;
1951 flip_y_pos = 0x70;
1952 }
1953
1954 for (INT32 x = x1; x < width; x++)
1955 {
1956 for (INT32 y = y1; y < height; y++, code++)
1957 {
1958 #if 0
1959 // wrong, but good for testing...
1960 RenderPrioSprite(pTransDraw, gfx->gfxbase, code % gfx->code_mask, ((color & gfx->color_mask) << gfx->depth) + gfx->color_offset, (1 << gfx->depth) - 1, xpos + ((x ^ (flip_x * 7)) * 16), ypos + ((y ^ (flip_y * 7)) * 16), flip_x, flip_y, gfx->width, gfx->height, 1 << priority);
1961
1962 if ((xpos + (16 * x) + 16) >= 512)
1963 RenderPrioSprite(pTransDraw, gfx->gfxbase, code % gfx->code_mask, ((color & gfx->color_mask) << gfx->depth) + gfx->color_offset, (1 << gfx->depth) - 1, xpos - 512 + ((x ^ (flip_x * 7)) * 16), ypos + ((y ^ (flip_y * 7)) * 16), flip_x, flip_y, gfx->width, gfx->height, 1 << priority);
1964 #else
1965 drawgfx_blend(gfx, code, color, flip_x, flip_y, xpos + ((x * 16) ^ flip_x_pos), ypos + ((y * 16) ^ flip_y_pos), 1 << priority);
1966
1967 if ((xpos + (16 * x) + 16) >= 512)
1968 drawgfx_blend(gfx, code, color, flip_x, flip_y, xpos - 512 + ((x * 16) ^ flip_x_pos), ypos + ((y * 16) ^ flip_y_pos), 1 << priority);
1969 #endif
1970 }
1971 }
1972 }
1973 }
1974
DrvTransferBitmap32()1975 static void DrvTransferBitmap32()
1976 {
1977 switch (nBurnBpp) {
1978 case 4:
1979 memcpy(pBurnDraw, bitmap32, nScreenHeight * nScreenWidth * sizeof(UINT32));
1980 break;
1981
1982 default:
1983 for (INT32 i = 0; i < nScreenWidth * nScreenHeight; i++) {
1984 PutPix(pBurnDraw + (i * nBurnBpp), BurnHighCol(bitmap32[i]>>16, (bitmap32[i]>>8)&0xff, bitmap32[i]&0xff, 0));
1985 }
1986 break;
1987 }
1988 }
1989
mix_in_tmap(INT32 layer,INT32 flags)1990 static void mix_in_tmap(INT32 layer, INT32 flags)
1991 {
1992 // clear temp bitmap
1993 memset(tempdraw, 0, 320 * 256 * sizeof(UINT16));
1994
1995 // draw tilemap
1996 GenericTilemapDraw(layer, tempdraw, flags, 0xff);
1997
1998 // mix it in, applying alpha where needed
1999 UINT16 *src0 = tempdraw;
2000 UINT32 *dest = (UINT32*)bitmap32;
2001
2002 for (INT32 y = 0; y < nScreenHeight; y++) {
2003 for (INT32 x = 0; x < nScreenWidth; x++) {
2004 UINT16 src = src0[x];
2005 if (src) {
2006 if (DrvAlphaTable[src])
2007 dest[x] = alpha_blend(dest[x], DrvPalette[src]);
2008 else
2009 dest[x] = DrvPalette[src];
2010 }
2011 }
2012 src0 += nScreenWidth;
2013 dest += nScreenWidth;
2014 }
2015
2016 pBurnDrvPalette = DrvPalette;
2017 }
2018
DrvDraw()2019 static INT32 DrvDraw()
2020 {
2021 if (DrvRecalc) {
2022 DrvPaletteUpdate();
2023 DrvRecalc = 0;
2024 }
2025
2026 UINT16 *crtc = (UINT16*)DrvCRTCRAM;
2027
2028 layer_enable = BURN_ENDIAN_SWAP_INT16(crtc[0x1c/2]);
2029
2030 BurnPrioClear();
2031
2032 GenericTilemapSetScrollY(1, BURN_ENDIAN_SWAP_INT16(crtc[0x22/2]));
2033 GenericTilemapSetScrollY(2, BURN_ENDIAN_SWAP_INT16(crtc[0x26/2]));
2034 GenericTilemapSetScrollY(3, BURN_ENDIAN_SWAP_INT16(crtc[0x2a/2]));
2035
2036 if (rowscroll_enable)
2037 {
2038 INT16 *back_rowscroll = (INT16*)&tilemap_ram[0x200];
2039 INT16 *midl_rowscroll = (INT16*)&tilemap_ram[0x600];
2040 INT16 *fore_rowscroll = (INT16*)&tilemap_ram[0xa00];
2041
2042 GenericTilemapSetScrollRows(1, 512);
2043 GenericTilemapSetScrollRows(2, 512);
2044 GenericTilemapSetScrollRows(3, 512);
2045
2046 for (INT32 y = 0; y < 512; y++) {
2047 GenericTilemapSetScrollRow(1, y, BURN_ENDIAN_SWAP_INT16(crtc[0x20/2]) + BURN_ENDIAN_SWAP_INT16(back_rowscroll[(0x19 + y) & 0x1ff]));
2048 GenericTilemapSetScrollRow(2, y, BURN_ENDIAN_SWAP_INT16(crtc[0x24/2]) + BURN_ENDIAN_SWAP_INT16(midl_rowscroll[(0x19 + y) & 0x1ff]));
2049 GenericTilemapSetScrollRow(3, y, BURN_ENDIAN_SWAP_INT16(crtc[0x28/2]) + BURN_ENDIAN_SWAP_INT16(fore_rowscroll[(0x19 + y) & 0x1ff]));
2050 }
2051 } else {
2052 GenericTilemapSetScrollRows(1, 1);
2053 GenericTilemapSetScrollRows(2, 1);
2054 GenericTilemapSetScrollRows(3, 1);
2055
2056 GenericTilemapSetScrollX(1, BURN_ENDIAN_SWAP_INT16(crtc[0x20 / 2]));
2057 GenericTilemapSetScrollX(2, BURN_ENDIAN_SWAP_INT16(crtc[0x24 / 2]));
2058 GenericTilemapSetScrollX(3, BURN_ENDIAN_SWAP_INT16(crtc[0x28/2]));
2059 }
2060
2061 memset(bitmap32, 0x00, 320 * 256 * sizeof(UINT32));
2062
2063 if (~layer_enable & 1 && nBurnLayer & 1)
2064 mix_in_tmap(1, TMAP_FORCEOPAQUE);
2065
2066 draw_sprites(0);
2067
2068 if ((layer_enable & 0x15) == 0 && nSpriteEnable & 1)
2069 mix_in_tmap(1, 0);
2070
2071 if (~layer_enable & 4)
2072 draw_sprites(1);
2073
2074 if (~layer_enable & 2 && nBurnLayer & 2)
2075 mix_in_tmap(2, 0);
2076
2077 if (layer_enable & 4)
2078 draw_sprites(1);
2079
2080 draw_sprites(2);
2081
2082 if (~layer_enable & 4 && nBurnLayer & 4)
2083 mix_in_tmap(3, 0);
2084
2085 draw_sprites(3);
2086
2087 if (~layer_enable & 8 && nBurnLayer & 8)
2088 mix_in_tmap(0, 0);
2089
2090 DrvTransferBitmap32();
2091
2092 return 0;
2093 }
2094
Sys386fDraw()2095 static INT32 Sys386fDraw()
2096 {
2097 if (DrvRecalc) {
2098 DrvPaletteUpdate();
2099 DrvRecalc = 0;
2100 }
2101
2102 BurnPrioClear();
2103
2104 memset(bitmap32, 0x00, 320 * 256 * sizeof(UINT32));
2105
2106 for (INT32 i = 0; i < 4; i++) {
2107 draw_sprites(i);
2108 }
2109
2110 DrvTransferBitmap32();
2111
2112 return 0;
2113 }
2114
DrvFrame()2115 static INT32 DrvFrame()
2116 {
2117 if (DrvReset) {
2118 DrvDoReset(1);
2119 }
2120
2121 i386NewFrame();
2122 ZetNewFrame();
2123
2124 {
2125 memset (DrvInputs, 0xff, sizeof(DrvInputs));
2126
2127 for (INT32 i = 0; i < 32; i++) {
2128 DrvInputs[0] ^= (DrvJoy1[i] & 1) << i;
2129 DrvInputs[1] ^= (DrvJoy2[i] & 1) << i;
2130 DrvInputs[2] ^= (DrvJoy3[i] & 1) << i;
2131 DrvInputs[3] ^= (DrvJoy4[i] & 1) << i;
2132 }
2133
2134 if (BurnDrvGetGenreFlags() & GBF_MAHJONG) {
2135 for (INT32 i = 0; i < 8; i++) {
2136 DrvInputs[4] ^= (DrvJoy5[i] & 1) << i;
2137 DrvInputs[5] ^= (DrvJoy6[i] & 1) << i;
2138 DrvInputs[6] ^= (DrvJoy7[i] & 1) << i;
2139 DrvInputs[7] ^= (DrvJoy8[i] & 1) << i;
2140 DrvInputs[8] ^= (DrvJoy9[i] & 1) << i;
2141 }
2142 }
2143 }
2144
2145 INT32 nInterleave = 296; // vtotal
2146 INT32 nCyclesTotal[2] = { 25000000 / 54 /*(((28636363)/4)/448)/296*/, 7159090 / 54 };
2147 INT32 nCyclesDone[2] = { nExtraCycles, 0 };
2148
2149 i386Open(0);
2150 ZetOpen(0);
2151
2152 for (INT32 i = 0; i < nInterleave; i++)
2153 {
2154 CPU_RUN(0, i386);
2155 CPU_RUN_TIMER(1);
2156
2157 ds2404_counter++;
2158 if (ds2404_counter == 63) { // ~256 / sec
2159 ds2404_counter = 0;
2160 ds2404_timer_update();
2161 }
2162
2163 if (i == 239) {
2164 i386SetIRQLine(0, CPU_IRQSTATUS_HOLD);
2165 }
2166 }
2167
2168 if (pBurnSoundOut) {
2169 BurnYMF271Update(nBurnSoundLen);
2170 }
2171
2172 ZetClose();
2173 i386Close();
2174
2175 nExtraCycles = nCyclesDone[0] - nCyclesTotal[0];
2176
2177 if (pBurnDraw) {
2178 BurnDrvRedraw();
2179 }
2180
2181 return 0;
2182 }
2183
Sys386Frame()2184 static INT32 Sys386Frame()
2185 {
2186 if (DrvReset) {
2187 DrvDoReset(1);
2188 }
2189
2190 i386NewFrame();
2191
2192 {
2193 memset (DrvInputs, 0xff, sizeof(DrvInputs));
2194
2195 for (INT32 i = 0; i < 32; i++) {
2196 DrvInputs[0] ^= (DrvJoy1[i] & 1) << i;
2197 DrvInputs[1] ^= (DrvJoy2[i] & 1) << i;
2198 DrvInputs[2] ^= (DrvJoy3[i] & 1) << i;
2199 DrvInputs[3] ^= (DrvJoy4[i] & 1) << i;
2200 }
2201 }
2202
2203 INT32 nInterleave = 296; // vtotal
2204 INT32 nCyclesTotal[1] = { 40000000 / 54 /*(((28636363)/4)/448)/296*/ }; // sys386i others are 25mhz
2205 INT32 nCyclesDone[1] = { 0 };
2206
2207 for (INT32 i = 0; i < nInterleave; i++)
2208 {
2209 CPU_RUN(0, i386);
2210
2211 if (i == 239) {
2212 i386SetIRQLine(0, CPU_IRQSTATUS_HOLD);
2213 }
2214 }
2215
2216 if (pBurnSoundOut) {
2217 MSM6295Render(pBurnSoundOut, nBurnSoundLen);
2218 }
2219
2220 if (pBurnDraw) {
2221 BurnDrvRedraw();
2222 }
2223
2224 return 0;
2225 }
2226
Sys386fFrame()2227 static INT32 Sys386fFrame()
2228 {
2229 if (DrvReset) {
2230 DrvDoReset(1);
2231 }
2232
2233 i386NewFrame();
2234
2235 {
2236 memset (DrvInputs, 0xff, sizeof(DrvInputs));
2237
2238 for (INT32 i = 0; i < 32; i++) {
2239 DrvInputs[0] ^= (DrvJoy1[i] & 1) << i;
2240 DrvInputs[1] ^= (DrvJoy2[i] & 1) << i;
2241 DrvInputs[2] ^= (DrvJoy3[i] & 1) << i;
2242 DrvInputs[3] ^= (DrvJoy4[i] & 1) << i;
2243 }
2244
2245 if (BurnDrvGetGenreFlags() & GBF_MAHJONG) {
2246 for (INT32 i = 0; i < 16; i++) {
2247 DrvInputs[4] ^= (DrvJoy5[i] & 1) << i;
2248 DrvInputs[5] ^= (DrvJoy6[i] & 1) << i;
2249 DrvInputs[6] ^= (DrvJoy7[i] & 1) << i;
2250 DrvInputs[7] ^= (DrvJoy8[i] & 1) << i;
2251 DrvInputs[8] ^= (DrvJoy9[i] & 1) << i;
2252 }
2253 }
2254 }
2255
2256 INT32 nInterleave = 296; // vtotal
2257 INT32 nCyclesTotal[1] = { 25000000 / 54 /*(((28636363)/4)/448)/296*/ };
2258 INT32 nCyclesDone[1] = { 0 };
2259
2260 for (INT32 i = 0; i < nInterleave; i++)
2261 {
2262 CPU_RUN(0, i386);
2263
2264 if (i == 239) {
2265 i386SetIRQLine(0, CPU_IRQSTATUS_HOLD);
2266 }
2267 }
2268
2269 if (pBurnSoundOut) {
2270 YMZ280BRender(pBurnSoundOut, nBurnSoundLen);
2271 }
2272
2273 if (pBurnDraw) {
2274 BurnDrvRedraw();
2275 }
2276
2277 return 0;
2278 }
2279
DrvScan(INT32 nAction,INT32 * pnMin)2280 static INT32 DrvScan(INT32 nAction, INT32 *pnMin)
2281 {
2282 struct BurnArea ba;
2283
2284 if (pnMin) {
2285 *pnMin = 0x029702;
2286 }
2287
2288 if (nAction & ACB_VOLATILE) {
2289 memset(&ba, 0, sizeof(ba));
2290
2291 ba.Data = AllRam;
2292 ba.nLen = RamEnd - AllRam;
2293 ba.szName = "All Ram";
2294 BurnAcb(&ba);
2295
2296 i386Scan(nAction);
2297
2298 if (sound_system == 0) MSM6295Scan(nAction, pnMin);
2299
2300 if (sound_system == 1) ZetScan(nAction);
2301 if (sound_system == 1) {bprintf(0, _T("scan ymf271 from seibuspi.\n")); BurnYMF271Scan(nAction, pnMin);}
2302 if (sound_system == 1 && rom_based_z80 == 0 && has_eeprom == 0) intelflash_scan(nAction, pnMin);
2303 if (sound_system == 2) YMZ280BScan(nAction, pnMin);
2304
2305 SCAN_VAR(video_dma_length);
2306 SCAN_VAR(video_dma_address);
2307 SCAN_VAR(rowscroll_enable);
2308 SCAN_VAR(rf2_layer_bank);
2309 SCAN_VAR(text_layer_offset);
2310 SCAN_VAR(fore_layer_offset);
2311 SCAN_VAR(midl_layer_offset);
2312 SCAN_VAR(fore_layer_d13);
2313 SCAN_VAR(fore_layer_d14);
2314 SCAN_VAR(back_layer_d14);
2315 SCAN_VAR(midl_layer_d14);
2316 SCAN_VAR(fifoin_rpos);
2317 SCAN_VAR(fifoin_wpos);
2318 SCAN_VAR(fifoout_rpos);
2319 SCAN_VAR(fifoout_wpos);
2320 SCAN_VAR(fifoin_data);
2321 SCAN_VAR(fifoout_data);
2322 SCAN_VAR(fifoin_read_request);
2323 SCAN_VAR(fifoout_read_request);
2324 SCAN_VAR(z80_prog_xfer_pos);
2325 SCAN_VAR(z80_bank);
2326 SCAN_VAR(oki_bank);
2327 SCAN_VAR(coin_latch);
2328 SCAN_VAR(input_select);
2329
2330 SCAN_VAR(nExtraCycles);
2331 }
2332
2333 if (has_eeprom)
2334 EEPROMScan(nAction, pnMin);
2335 else
2336 ds2404_scan(nAction, pnMin);
2337
2338 if (nAction & ACB_NVRAM)
2339 {
2340 if (sound_system == 1 && rom_based_z80 == 0 && has_eeprom == 0) intelflash_scan(nAction, pnMin);
2341 }
2342
2343 if (nAction & ACB_WRITE) {
2344 if (sound_system == 0) {
2345 oki_bankswitch(oki_bank);
2346 }
2347 else if (sound_system == 1) {
2348 ZetOpen(0);
2349 sound_bankswitch(z80_bank);
2350 ZetClose();
2351 // if flash update gets interrupted, this will fix it so it can be re-flased.
2352 DrvSndROM[0][0xa00000] = DrvMainROM[0x1ffffc]; // HACK! -set flash region...
2353 }
2354 }
2355
2356 return 0;
2357 }
2358
2359
2360 // Senkyu (Japan, newer)
2361
2362 static struct BurnRomInfo senkyuRomDesc[] = {
2363 { "fb_1.211", 0x040000, 0x20a3e5db, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
2364 { "fb_2.212", 0x040000, 0x38e90619, 1 | BRF_PRG | BRF_ESS }, // 1
2365 { "fb_3.210", 0x040000, 0x226f0429, 1 | BRF_PRG | BRF_ESS }, // 2
2366 { "fb_4.29", 0x040000, 0xb46d66b7, 1 | BRF_PRG | BRF_ESS }, // 3
2367
2368 { "fb_6.413", 0x020000, 0xb57115c9, 1 | BRF_GRA }, // 4 Characters
2369 { "fb_5.48", 0x010000, 0x440a9ae3, 1 | BRF_GRA }, // 5
2370
2371 { "fb_bg-1d.415", 0x200000, 0xeae7a1fc, 2 | BRF_GRA }, // 6 Background Tiles
2372 { "fb_bg-1p.410", 0x100000, 0xb46e774e, 2 | BRF_GRA }, // 7
2373
2374 { "fb_obj-1.322", 0x400000, 0x29f86f68, 3 | BRF_GRA }, // 8 Sprites
2375 { "fb_obj-2.324", 0x400000, 0xc9e3130b, 3 | BRF_GRA }, // 9
2376 { "fb_obj-3.323", 0x400000, 0xf6c3bc49, 3 | BRF_GRA }, // 10
2377
2378 { "fb_pcm-1.215", 0x100000, 0x1d83891c, 3 | BRF_PRG | BRF_ESS }, // 11 Sample Data (Mapped to i386)
2379 { "fb_7.216", 0x080000, 0x874d7b59, 3 | BRF_PRG | BRF_ESS }, // 12
2380
2381 { "flash0_blank_region01.u1053", 0x100000, 0x7ae7ab76, 0 | BRF_SND }, // 13 Intel Flash (Samples)
2382 };
2383
2384 STD_ROM_PICK(senkyu)
STD_ROM_FN(senkyu)2385 STD_ROM_FN(senkyu)
2386
2387 static INT32 SenkyuInit()
2388 {
2389 return CommonInit(DECRYPT_SEI252, NULL, 0x18cb4, 0x305bb2);
2390 }
2391
2392 struct BurnDriver BurnDrvSenkyu = {
2393 "senkyu", NULL, NULL, NULL, "1995",
2394 "Senkyu (Japan, newer)\0", NULL, "Seibu Kaihatsu", "SPI",
2395 NULL, NULL, NULL, NULL,
2396 BDF_GAME_WORKING, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
2397 NULL, senkyuRomInfo, senkyuRomName, NULL, NULL, NULL, NULL, Spi_3buttonInputInfo, Spi_3buttonDIPInfo,
2398 SenkyuInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
2399 320, 240, 4, 3
2400 };
2401
2402
2403 // Senkyu (Japan, earlier)
2404
2405 static struct BurnRomInfo senkyuaRomDesc[] = {
2406 { "1.bin", 0x040000, 0x6102c3fb, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
2407 { "2.bin", 0x040000, 0xd5b8ce46, 1 | BRF_PRG | BRF_ESS }, // 1
2408 { "3.bin", 0x040000, 0xe27ceccd, 1 | BRF_PRG | BRF_ESS }, // 2
2409 { "4.bin", 0x040000, 0x7c6d4549, 1 | BRF_PRG | BRF_ESS }, // 3
2410
2411 { "fb_6.413", 0x020000, 0xb57115c9, 1 | BRF_GRA }, // 4 Characters
2412 { "fb_5.48", 0x010000, 0x440a9ae3, 1 | BRF_GRA }, // 5
2413
2414 { "fb_bg-1d.415", 0x200000, 0xeae7a1fc, 2 | BRF_GRA }, // 6 Background Tiles
2415 { "fb_bg-1p.410", 0x100000, 0xb46e774e, 2 | BRF_GRA }, // 7
2416
2417 { "fb_obj-1.322", 0x400000, 0x29f86f68, 3 | BRF_GRA }, // 8 Sprites
2418 { "fb_obj-2.324", 0x400000, 0xc9e3130b, 3 | BRF_GRA }, // 9
2419 { "fb_obj-3.323", 0x400000, 0xf6c3bc49, 3 | BRF_GRA }, // 10
2420
2421 { "fb_pcm-1.215", 0x100000, 0x1d83891c, 3 | BRF_PRG | BRF_ESS }, // 11 Sample Data (Mapped to i386)
2422 { "fb_7.216", 0x080000, 0x874d7b59, 3 | BRF_PRG | BRF_ESS }, // 12
2423
2424 { "flash0_blank_region01.u1053", 0x100000, 0x7ae7ab76, 0 | BRF_SND }, // 13 Intel Flash (Samples)
2425 };
2426
2427 STD_ROM_PICK(senkyua)
STD_ROM_FN(senkyua)2428 STD_ROM_FN(senkyua)
2429
2430 static INT32 SenkyuaInit()
2431 {
2432 return CommonInit(DECRYPT_SEI252, NULL, 0x18c9c, 0x30582e);
2433 }
2434
2435 struct BurnDriver BurnDrvSenkyua = {
2436 "senkyua", "senkyu", NULL, NULL, "1995",
2437 "Senkyu (Japan, earlier)\0", NULL, "Seibu Kaihatsu", "SPI",
2438 NULL, NULL, NULL, NULL,
2439 BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
2440 NULL, senkyuaRomInfo, senkyuaRomName, NULL, NULL, NULL, NULL, Spi_3buttonInputInfo, Spi_3buttonDIPInfo,
2441 SenkyuaInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
2442 320, 240, 4, 3
2443 };
2444
2445
2446 // Battle Balls (Germany, newer)
2447
2448 static struct BurnRomInfo batlballRomDesc[] = {
2449 { "1.211", 0x040000, 0xd4e48f89, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
2450 { "2.212", 0x040000, 0x3077720b, 1 | BRF_PRG | BRF_ESS }, // 1
2451 { "3.210", 0x040000, 0x520d31e1, 1 | BRF_PRG | BRF_ESS }, // 2
2452 { "4.029", 0x040000, 0x22419b78, 1 | BRF_PRG | BRF_ESS }, // 3
2453
2454 { "fb_6.413", 0x020000, 0xb57115c9, 1 | BRF_GRA }, // 4 Characters
2455 { "fb_5.48", 0x010000, 0x440a9ae3, 1 | BRF_GRA }, // 5
2456
2457 { "fb_bg-1d.415", 0x200000, 0xeae7a1fc, 2 | BRF_GRA }, // 6 Background Tiles
2458 { "fb_bg-1p.410", 0x100000, 0xb46e774e, 2 | BRF_GRA }, // 7
2459
2460 { "fb_obj-1.322", 0x400000, 0x29f86f68, 3 | BRF_GRA }, // 8 Sprites
2461 { "fb_obj-2.324", 0x400000, 0xc9e3130b, 3 | BRF_GRA }, // 9
2462 { "fb_obj-3.323", 0x400000, 0xf6c3bc49, 3 | BRF_GRA }, // 10
2463
2464 { "fb_pcm-1.215", 0x100000, 0x1d83891c, 3 | BRF_PRG | BRF_ESS }, // 11 Sample Data (Mapped to i386)
2465 { "fb_7.216", 0x080000, 0x874d7b59, 3 | BRF_PRG | BRF_ESS }, // 12
2466
2467 { "flash0_blank_region80.u1053", 0x100000, 0xe2adaff5, 0 | BRF_SND }, // 13 Intel Flash (Samples)
2468 };
2469
2470 STD_ROM_PICK(batlball)
STD_ROM_FN(batlball)2471 STD_ROM_FN(batlball)
2472
2473 static INT32 BatlballInit()
2474 {
2475 return CommonInit(DECRYPT_SEI252, NULL, 0x18db4, 0x3058aa);
2476 }
2477
2478 struct BurnDriver BurnDrvBatlball = {
2479 "batlball", "senkyu", NULL, NULL, "1995",
2480 "Battle Balls (Germany, newer)\0", NULL, "Seibu Kaihatsu (Tuning license)", "SPI",
2481 NULL, NULL, NULL, NULL,
2482 BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
2483 NULL, batlballRomInfo, batlballRomName, NULL, NULL, NULL, NULL, Spi_3buttonInputInfo, Spi_3buttonDIPInfo,
2484 BatlballInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
2485 320, 240, 4, 3
2486 };
2487
2488
2489 // Battle Balls (Germany, earlier)
2490
2491 static struct BurnRomInfo batlballoRomDesc[] = {
2492 { "seibu_1a.211", 0x040000, 0x90340e8c, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
2493 { "seibu_2a.212", 0x040000, 0xdb655d3e, 1 | BRF_PRG | BRF_ESS }, // 1
2494 { "seibu_3a.210", 0x040000, 0x659a54a2, 1 | BRF_PRG | BRF_ESS }, // 2
2495 { "seibu_4a.029", 0x040000, 0x51183421, 1 | BRF_PRG | BRF_ESS }, // 3
2496
2497 { "seibu_6.413", 0x020000, 0x338556f9, 1 | BRF_GRA }, // 4 Characters
2498 { "seibu_5.48", 0x010000, 0x6ccfb72e, 1 | BRF_GRA }, // 5
2499
2500 { "fb_bg-1d.415", 0x200000, 0xeae7a1fc, 2 | BRF_GRA }, // 6 Background Tiles
2501 { "fb_bg-1p.410", 0x100000, 0xb46e774e, 2 | BRF_GRA }, // 7
2502
2503 { "fb_obj-1.322", 0x400000, 0x29f86f68, 3 | BRF_GRA }, // 8 Sprites
2504 { "fb_obj-2.324", 0x400000, 0xc9e3130b, 3 | BRF_GRA }, // 9
2505 { "fb_obj-3.323", 0x400000, 0xf6c3bc49, 3 | BRF_GRA }, // 10
2506
2507 { "fb_pcm-1.215", 0x100000, 0x1d83891c, 3 | BRF_PRG | BRF_ESS }, // 11 Sample Data (Mapped to i386)
2508 { "seibu_7.216", 0x080000, 0x874d7b59, 3 | BRF_PRG | BRF_ESS }, // 12
2509
2510 { "flash0_blank_region80.u1053", 0x100000, 0xe2adaff5, 0 | BRF_SND }, // 13 Intel Flash (Samples)
2511 };
2512
2513 STD_ROM_PICK(batlballo)
STD_ROM_FN(batlballo)2514 STD_ROM_FN(batlballo)
2515
2516 static INT32 BatlballoInit()
2517 {
2518 return CommonInit(DECRYPT_SEI252, NULL, 0x18db4, 0x3058aa);
2519 }
2520
2521 struct BurnDriver BurnDrvBatlballo = {
2522 "batlballo", "senkyu", NULL, NULL, "1995",
2523 "Battle Balls (Germany, earlier)\0", NULL, "Seibu Kaihatsu (Tuning license)", "SPI",
2524 NULL, NULL, NULL, NULL,
2525 BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
2526 NULL, batlballoRomInfo, batlballoRomName, NULL, NULL, NULL, NULL, Spi_3buttonInputInfo, Spi_3buttonDIPInfo,
2527 BatlballoInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
2528 320, 240, 4, 3
2529 };
2530
2531
2532 // Battle Balls (Hong Kong)
2533
2534 static struct BurnRomInfo batlballaRomDesc[] = {
2535 { "senkyua1.bin", 0x040000, 0xec3c4d4d, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
2536 { "2.212", 0x040000, 0x3077720b, 1 | BRF_PRG | BRF_ESS }, // 1
2537 { "3.210", 0x040000, 0x520d31e1, 1 | BRF_PRG | BRF_ESS }, // 2
2538 { "4.029", 0x040000, 0x22419b78, 1 | BRF_PRG | BRF_ESS }, // 3
2539
2540 { "fb_6.413", 0x020000, 0xb57115c9, 1 | BRF_GRA }, // 4 Characters
2541 { "fb_5.48", 0x010000, 0x440a9ae3, 1 | BRF_GRA }, // 5
2542
2543 { "fb_bg-1d.415", 0x200000, 0xeae7a1fc, 2 | BRF_GRA }, // 6 Background Tiles
2544 { "fb_bg-1p.410", 0x100000, 0xb46e774e, 2 | BRF_GRA }, // 7
2545
2546 { "fb_obj-1.322", 0x400000, 0x29f86f68, 3 | BRF_GRA }, // 8 Sprites
2547 { "fb_obj-2.324", 0x400000, 0xc9e3130b, 3 | BRF_GRA }, // 9
2548 { "fb_obj-3.323", 0x400000, 0xf6c3bc49, 3 | BRF_GRA }, // 10
2549
2550 { "fb_pcm-1.215", 0x100000, 0x1d83891c, 3 | BRF_PRG | BRF_ESS }, // 11 Sample Data (Mapped to i386)
2551 { "fb_7.216", 0x080000, 0x874d7b59, 3 | BRF_PRG | BRF_ESS }, // 12
2552
2553 { "flash0_blank_region22.u1053", 0x100000, 0x5fee8413, 0 | BRF_SND }, // 13 Intel Flash (Samples)
2554 };
2555
2556 STD_ROM_PICK(batlballa)
STD_ROM_FN(batlballa)2557 STD_ROM_FN(batlballa)
2558
2559 static INT32 BatlballaInit()
2560 {
2561 return CommonInit(DECRYPT_SEI252, NULL, 0x18db4, 0x3058aa);
2562 }
2563
2564 struct BurnDriver BurnDrvBatlballa = {
2565 "batlballa", "senkyu", NULL, NULL, "1995",
2566 "Battle Balls (Hong Kong)\0", NULL, "Seibu Kaihatsu (Metrotainment license)", "SPI",
2567 NULL, NULL, NULL, NULL,
2568 BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
2569 NULL, batlballaRomInfo, batlballaRomName, NULL, NULL, NULL, NULL, Spi_3buttonInputInfo, Spi_3buttonDIPInfo,
2570 BatlballaInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
2571 320, 240, 4, 3
2572 };
2573
2574
2575 // Battle Balls (Hong Kong, earlier)
2576
2577 static struct BurnRomInfo batlballeRomDesc[] = {
2578 { "1_10-16", 0x040000, 0x6b1baa07, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
2579 { "2_10-16", 0x040000, 0x3c890639, 1 | BRF_PRG | BRF_ESS }, // 1
2580 { "3_10-16", 0x040000, 0x8c30180e, 1 | BRF_PRG | BRF_ESS }, // 2
2581 { "4_10-16", 0x040000, 0x048c7aaa, 1 | BRF_PRG | BRF_ESS }, // 3
2582
2583 { "fb_6.413", 0x020000, 0xb57115c9, 1 | BRF_GRA }, // 4 Characters
2584 { "fb_5.48", 0x010000, 0x440a9ae3, 1 | BRF_GRA }, // 5
2585
2586 { "fb_bg-1d.415", 0x200000, 0xeae7a1fc, 2 | BRF_GRA }, // 6 Background Tiles
2587 { "fb_bg-1p.410", 0x100000, 0xb46e774e, 2 | BRF_GRA }, // 7
2588
2589 { "fb_obj-1.322", 0x400000, 0x29f86f68, 3 | BRF_GRA }, // 8 Sprites
2590 { "fb_obj-2.324", 0x400000, 0xc9e3130b, 3 | BRF_GRA }, // 9
2591 { "fb_obj-3.323", 0x400000, 0xf6c3bc49, 3 | BRF_GRA }, // 10
2592
2593 { "fb_pcm-1.215", 0x100000, 0x1d83891c, 3 | BRF_PRG | BRF_ESS }, // 11 Sample Data (Mapped to i386)
2594 { "fb_7.216", 0x080000, 0x874d7b59, 3 | BRF_PRG | BRF_ESS }, // 12
2595
2596 { "flash0_blank_region22.u1053", 0x100000, 0x5fee8413, 0 | BRF_SND }, // 13 Intel Flash (Samples)
2597 };
2598
2599 STD_ROM_PICK(batlballe)
STD_ROM_FN(batlballe)2600 STD_ROM_FN(batlballe)
2601
2602 static INT32 BatlballeInit()
2603 {
2604 return CommonInit(DECRYPT_SEI252, NULL, 0x18db4, 0x3058b2);
2605 }
2606
2607 struct BurnDriver BurnDrvBatlballe = {
2608 "batlballe", "senkyu", NULL, NULL, "1995",
2609 "Battle Balls (Hong Kong, earlier)\0", NULL, "Seibu Kaihatsu (Metrotainment license)", "SPI",
2610 NULL, NULL, NULL, NULL,
2611 BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
2612 NULL, batlballeRomInfo, batlballeRomName, NULL, NULL, NULL, NULL, Spi_3buttonInputInfo, Spi_3buttonDIPInfo,
2613 BatlballeInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
2614 320, 240, 4, 3
2615 };
2616
2617
2618 // Battle Balls (US)
2619
2620 static struct BurnRomInfo batlballuRomDesc[] = {
2621 { "sen1.bin", 0x040000, 0x13849bf0, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
2622 { "sen2.bin", 0x040000, 0x2ae5f7e2, 1 | BRF_PRG | BRF_ESS }, // 1
2623 { "sen3.bin", 0x040000, 0x98e6f19f, 1 | BRF_PRG | BRF_ESS }, // 2
2624 { "sen4.bin", 0x040000, 0x1343ec56, 1 | BRF_PRG | BRF_ESS }, // 3
2625
2626 { "fb_6.413", 0x020000, 0xb57115c9, 1 | BRF_GRA }, // 4 Characters
2627 { "fb_5.48", 0x010000, 0x440a9ae3, 1 | BRF_GRA }, // 5
2628
2629 { "fb_bg-1d.415", 0x200000, 0xeae7a1fc, 2 | BRF_GRA }, // 6 Background Tiles
2630 { "fb_bg-1p.410", 0x100000, 0xb46e774e, 2 | BRF_GRA }, // 7
2631
2632 { "fb_obj-1.322", 0x400000, 0x29f86f68, 3 | BRF_GRA }, // 8 Sprites
2633 { "fb_obj-2.324", 0x400000, 0xc9e3130b, 3 | BRF_GRA }, // 9
2634 { "fb_obj-3.323", 0x400000, 0xf6c3bc49, 3 | BRF_GRA }, // 10
2635
2636 { "fb_pcm-1.215", 0x100000, 0x1d83891c, 3 | BRF_PRG | BRF_ESS }, // 11 Sample Data (Mapped to i386)
2637 { "fb_7.216", 0x080000, 0x874d7b59, 3 | BRF_PRG | BRF_ESS }, // 12
2638
2639 { "flash0_blank_region10.u1053", 0x100000, 0x4319d998, 0 | BRF_SND }, // 13 Intel Flash (Samples)
2640 };
2641
2642 STD_ROM_PICK(batlballu)
STD_ROM_FN(batlballu)2643 STD_ROM_FN(batlballu)
2644
2645 static INT32 BatlballuInit()
2646 {
2647 return CommonInit(DECRYPT_SEI252, NULL, 0x18db4, 0x305996);
2648 }
2649
2650 struct BurnDriver BurnDrvBatlballu = {
2651 "batlballu", "senkyu", NULL, NULL, "1995",
2652 "Battle Balls (US)\0", NULL, "Seibu Kaihatsu (Fabtek license)", "SPI",
2653 NULL, NULL, NULL, NULL,
2654 BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
2655 NULL, batlballuRomInfo, batlballuRomName, NULL, NULL, NULL, NULL, Spi_3buttonInputInfo, Spi_3buttonDIPInfo,
2656 BatlballuInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
2657 320, 240, 4, 3
2658 };
2659
2660
2661 // Battle Balls (Portugal)
2662
2663 static struct BurnRomInfo batlballptRomDesc[] = {
2664 { "senkyu_prog0_171195.u0211", 0x040000, 0xdcc227b6, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
2665 { "2.u0212", 0x040000, 0x03ab203f, 1 | BRF_PRG | BRF_ESS }, // 1
2666 { "3.u0210", 0x040000, 0x9eb9c8b4, 1 | BRF_PRG | BRF_ESS }, // 2
2667 { "4.u029", 0x040000, 0xc37ae2a5, 1 | BRF_PRG | BRF_ESS }, // 3
2668
2669 { "fb_6.413", 0x020000, 0xb57115c9, 1 | BRF_GRA }, // 4 Characters
2670 { "fb_5.48", 0x010000, 0x440a9ae3, 1 | BRF_GRA }, // 5
2671
2672 { "fb_bg-1d.415", 0x200000, 0xeae7a1fc, 2 | BRF_GRA }, // 6 Background Tiles
2673 { "fb_bg-1p.410", 0x100000, 0xb46e774e, 2 | BRF_GRA }, // 7
2674
2675 { "fb_obj-1.322", 0x400000, 0x29f86f68, 3 | BRF_GRA }, // 8 Sprites
2676 { "fb_obj-2.324", 0x400000, 0xc9e3130b, 3 | BRF_GRA }, // 9
2677 { "fb_obj-3.323", 0x400000, 0xf6c3bc49, 3 | BRF_GRA }, // 10
2678
2679 { "fb_pcm-1.215", 0x100000, 0x1d83891c, 3 | BRF_PRG | BRF_ESS }, // 11 Sample Data (Mapped to i386)
2680 { "fb_7.216", 0x080000, 0x874d7b59, 3 | BRF_PRG | BRF_ESS }, // 12
2681
2682 { "flash0_blank_region96.u1053", 0x100000, 0xa0ebae75, 0 | BRF_SND }, // 13 Intel Flash (Samples)
2683 };
2684
2685 STD_ROM_PICK(batlballpt)
STD_ROM_FN(batlballpt)2686 STD_ROM_FN(batlballpt)
2687
2688 static INT32 BatlballptInit()
2689 {
2690 return CommonInit(DECRYPT_SEI252, NULL, 0x18db4, 0x3058aa);
2691 }
2692
2693 struct BurnDriver BurnDrvBatlballpt = {
2694 "batlballpt", "senkyu", NULL, NULL, "1995",
2695 "Battle Balls (Portugal)\0", NULL, "Seibu Kaihatsu", "SPI",
2696 NULL, NULL, NULL, NULL,
2697 BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
2698 NULL, batlballptRomInfo, batlballptRomName, NULL, NULL, NULL, NULL, Spi_3buttonInputInfo, Spi_3buttonDIPInfo,
2699 BatlballptInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
2700 320, 240, 4, 3
2701 };
2702
2703
2704 // E Jong High School (Japan)
2705
2706 static struct BurnRomInfo ejanhsRomDesc[] = {
2707 { "ejan3_1.211", 0x040000, 0xe626d3d2, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
2708 { "ejan3_2.212", 0x040000, 0x83c39da2, 1 | BRF_PRG | BRF_ESS }, // 1
2709 { "ejan3_3.210", 0x040000, 0x46897b7d, 1 | BRF_PRG | BRF_ESS }, // 2
2710 { "ejan3_4.29", 0x040000, 0xb3187a2b, 1 | BRF_PRG | BRF_ESS }, // 3
2711
2712 { "ejan3_6.413", 0x020000, 0x837e012c, 1 | BRF_GRA }, // 4 Characters
2713 { "ejan3_5.48", 0x010000, 0xd62db7bf, 1 | BRF_GRA }, // 5
2714
2715 { "ej3_bg1d.415", 0x200000, 0xbcacabe0, 2 | BRF_GRA }, // 6 Background Tiles
2716 { "ej3_bg1p.410", 0x100000, 0x1fd0eb5e, 2 | BRF_GRA }, // 7
2717 { "ej3_bg2d.416", 0x100000, 0xea2acd69, 2 | BRF_GRA }, // 8
2718 { "ej3_bg2p.49", 0x080000, 0xa4a9cb0f, 2 | BRF_GRA }, // 9
2719
2720 { "ej3_obj1.322", 0x400000, 0x852f180e, 3 | BRF_GRA }, // 10 Sprites
2721 { "ej3_obj2.324", 0x400000, 0x1116ad08, 3 | BRF_GRA }, // 11
2722 { "ej3_obj3.323", 0x400000, 0xccfe02b6, 3 | BRF_GRA }, // 12
2723
2724 { "ej3_pcm1.215", 0x100000, 0xa92a3a82, 3 | BRF_PRG | BRF_ESS }, // 13 Sample Data (Mapped to i386)
2725 { "ejan3_7.216", 0x080000, 0xc6fc6bcf, 3 | BRF_PRG | BRF_ESS }, // 14
2726
2727 { "flash0_blank_region01.u1053", 0x100000, 0x7ae7ab76, 0 | BRF_SND }, // 15 Intel Flash (Samples)
2728 };
2729
2730 STD_ROM_PICK(ejanhs)
STD_ROM_FN(ejanhs)2731 STD_ROM_FN(ejanhs)
2732
2733 static INT32 EjanhsInit()
2734 {
2735 return CommonInit(DECRYPT_SEI252, NULL, 0, 0);
2736 }
2737
2738 struct BurnDriver BurnDrvEjanhs = {
2739 "ejanhs", NULL, NULL, NULL, "1996",
2740 "E Jong High School (Japan)\0", NULL, "Seibu Kaihatsu", "SPI",
2741 NULL, NULL, NULL, NULL,
2742 BDF_GAME_WORKING, 1, HARDWARE_MISC_POST90S, GBF_MAHJONG, 0,
2743 NULL, ejanhsRomInfo, ejanhsRomName, NULL, NULL, NULL, NULL, Spi_ejanhsInputInfo, Spi_ejanhsDIPInfo,
2744 EjanhsInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
2745 320, 240, 4, 3
2746 };
2747
2748
2749 // Viper Phase 1 (New Version, World)
2750
2751 static struct BurnRomInfo viprp1RomDesc[] = {
2752 { "seibu1.211", 0x080000, 0xe5caf4ff, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
2753 { "seibu2.212", 0x080000, 0x688a998e, 1 | BRF_PRG | BRF_ESS }, // 1
2754 { "seibu3.210", 0x080000, 0x990fa76a, 1 | BRF_PRG | BRF_ESS }, // 2
2755 { "seibu4.29", 0x080000, 0x13e3e343, 1 | BRF_PRG | BRF_ESS }, // 3
2756
2757 { "seibu5.u0413", 0x020000, 0x5ece677c, 1 | BRF_GRA }, // 4 Characters
2758 { "seibu6.u048", 0x010000, 0x44844ef8, 1 | BRF_GRA }, // 5
2759
2760 { "v_bg-11.415", 0x200000, 0x6fc96736, 2 | BRF_GRA }, // 6 Background Tiles
2761 { "v_bg-12.415", 0x100000, 0xd3c7281c, 2 | BRF_GRA }, // 7
2762 { "v_bg-21.410", 0x100000, 0xd65b4318, 2 | BRF_GRA }, // 8
2763 { "v_bg-22.416", 0x080000, 0x24a0a23a, 2 | BRF_GRA }, // 9
2764
2765 { "v_obj-1.322", 0x400000, 0x3be5b631, 3 | BRF_GRA }, // 10 Sprites
2766 { "v_obj-2.324", 0x400000, 0x924153b4, 3 | BRF_GRA }, // 11
2767 { "v_obj-3.323", 0x400000, 0xe9fb9062, 3 | BRF_GRA }, // 12
2768
2769 { "v_pcm.215", 0x100000, 0xe3111b60, 3 | BRF_PRG | BRF_ESS }, // 13 Sample Data (Mapped to i386)
2770
2771 { "flash0_blank_regionbe.u1053", 0x100000, 0xa4c181d0, 0 | BRF_SND }, // 14 Intel Flash (Samples)
2772 };
2773
2774 STD_ROM_PICK(viprp1)
STD_ROM_FN(viprp1)2775 STD_ROM_FN(viprp1)
2776
2777 static INT32 Viprp1Init()
2778 {
2779 return CommonInit(DECRYPT_SEI252, NULL, 0x1e2e0, 0x0202769);
2780 }
2781
2782 struct BurnDriver BurnDrvViprp1 = {
2783 "viprp1", NULL, NULL, NULL, "1995",
2784 "Viper Phase 1 (New Version, World)\0", NULL, "Seibu Kaihatsu", "SPI",
2785 NULL, NULL, NULL, NULL,
2786 BDF_GAME_WORKING | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
2787 NULL, viprp1RomInfo, viprp1RomName, NULL, NULL, NULL, NULL, Spi_3buttonInputInfo, Spi_3buttonDIPInfo,
2788 Viprp1Init, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
2789 240, 320, 3, 4
2790 };
2791
2792
2793 // Viper Phase 1 (New Version, Korea)
2794
2795 static struct BurnRomInfo viprp1kRomDesc[] = {
2796 { "seibu1.211", 0x080000, 0x5495c930, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
2797 { "seibu2.212", 0x080000, 0xe0ad22ae, 1 | BRF_PRG | BRF_ESS }, // 1
2798 { "seibu3.210", 0x080000, 0xdb7bcb90, 1 | BRF_PRG | BRF_ESS }, // 2
2799 { "seibu4.29", 0x080000, 0xc6188bf9, 1 | BRF_PRG | BRF_ESS }, // 3
2800
2801 { "seibu5.u0413", 0x020000, 0x1a35f2d8, 1 | BRF_GRA }, // 4 Characters
2802 { "seibu6.u048", 0x010000, 0xe88bf049, 1 | BRF_GRA }, // 5
2803
2804 { "v_bg-11.415", 0x200000, 0x6fc96736, 2 | BRF_GRA }, // 6 Background Tiles
2805 { "v_bg-12.415", 0x100000, 0xd3c7281c, 2 | BRF_GRA }, // 7
2806 { "v_bg-21.410", 0x100000, 0xd65b4318, 2 | BRF_GRA }, // 8
2807 { "v_bg-22.416", 0x080000, 0x24a0a23a, 2 | BRF_GRA }, // 9
2808
2809 { "v_obj-1.322", 0x400000, 0x3be5b631, 3 | BRF_GRA }, // 10 Sprites
2810 { "v_obj-2.324", 0x400000, 0x924153b4, 3 | BRF_GRA }, // 11
2811 { "v_obj-3.323", 0x400000, 0xe9fb9062, 3 | BRF_GRA }, // 12
2812
2813 { "v_pcm.215", 0x100000, 0xe3111b60, 3 | BRF_PRG | BRF_ESS }, // 13 Sample Data (Mapped to i386)
2814
2815 { "flash0_blank_region24.u1053", 0x100000, 0x72a33dc4, 0 | BRF_SND }, // 14 Intel Flash (Samples)
2816 };
2817
2818 STD_ROM_PICK(viprp1k)
STD_ROM_FN(viprp1k)2819 STD_ROM_FN(viprp1k)
2820
2821 static INT32 Viprp1kInit()
2822 {
2823 return CommonInit(DECRYPT_SEI252, NULL, 0x1e2e0, 0x202769);
2824 }
2825
2826 struct BurnDriver BurnDrvViprp1k = {
2827 "viprp1k", "viprp1", NULL, NULL, "1995",
2828 "Viper Phase 1 (New Version, Korea)\0", NULL, "Seibu Kaihatsu (Dream Island license)", "SPI",
2829 NULL, NULL, NULL, NULL,
2830 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
2831 NULL, viprp1kRomInfo, viprp1kRomName, NULL, NULL, NULL, NULL, Spi_3buttonInputInfo, Spi_3buttonDIPInfo,
2832 Viprp1kInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
2833 240, 320, 3, 4
2834 };
2835
2836
2837 // Viper Phase 1 (New Version, US set 1)
2838
2839 static struct BurnRomInfo viprp1uRomDesc[] = {
2840 { "seibu1.u0211", 0x080000, 0x3f412b80, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
2841 { "seibu2.u0212", 0x080000, 0x2e6c2376, 1 | BRF_PRG | BRF_ESS }, // 1
2842 { "seibu3.u0210", 0x080000, 0xc38f7b4e, 1 | BRF_PRG | BRF_ESS }, // 2
2843 { "seibu4.u029", 0x080000, 0x523cbef3, 1 | BRF_PRG | BRF_ESS }, // 3
2844
2845 { "seibu5.u0413", 0x020000, 0x5ece677c, 1 | BRF_GRA }, // 4 Characters
2846 { "seibu6.u048", 0x010000, 0x44844ef8, 1 | BRF_GRA }, // 5
2847
2848 { "v_bg-11.415", 0x200000, 0x6fc96736, 2 | BRF_GRA }, // 6 Background Tiles
2849 { "v_bg-12.415", 0x100000, 0xd3c7281c, 2 | BRF_GRA }, // 7
2850 { "v_bg-21.410", 0x100000, 0xd65b4318, 2 | BRF_GRA }, // 8
2851 { "v_bg-22.416", 0x080000, 0x24a0a23a, 2 | BRF_GRA }, // 9
2852
2853 { "v_obj-1.322", 0x400000, 0x3be5b631, 3 | BRF_GRA }, // 10 Sprites
2854 { "v_obj-2.324", 0x400000, 0x924153b4, 3 | BRF_GRA }, // 11
2855 { "v_obj-3.323", 0x400000, 0xe9fb9062, 3 | BRF_GRA }, // 12
2856
2857 { "v_pcm.215", 0x100000, 0xe3111b60, 3 | BRF_PRG | BRF_ESS }, // 13 Sample Data (Mapped to i386)
2858
2859 { "flash0_blank_region10.u1053", 0x100000, 0x4319d998, 0 | BRF_SND }, // 14 Intel Flash (Samples)
2860 };
2861
2862 STD_ROM_PICK(viprp1u)
2863 STD_ROM_FN(viprp1u)
2864
2865 struct BurnDriver BurnDrvViprp1u = {
2866 "viprp1u", "viprp1", NULL, NULL, "1995",
2867 "Viper Phase 1 (New Version, US set 1)\0", NULL, "Seibu Kaihatsu (Fabtek license)", "SPI",
2868 NULL, NULL, NULL, NULL,
2869 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
2870 NULL, viprp1uRomInfo, viprp1uRomName, NULL, NULL, NULL, NULL, Spi_3buttonInputInfo, Spi_3buttonDIPInfo,
2871 Viprp1Init, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
2872 240, 320, 3, 4
2873 };
2874
2875
2876 // Viper Phase 1 (New Version, US set 2)
2877
2878 static struct BurnRomInfo viprp1uaRomDesc[] = {
2879 { "seibus_1", 0x080000, 0x882c299c, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
2880 { "seibus_2", 0x080000, 0x6ce586e9, 1 | BRF_PRG | BRF_ESS }, // 1
2881 { "seibus_3", 0x080000, 0xf9dd9128, 1 | BRF_PRG | BRF_ESS }, // 2
2882 { "seibus_4", 0x080000, 0xcb06440c, 1 | BRF_PRG | BRF_ESS }, // 3
2883
2884 { "seibu5.u0413", 0x020000, 0x5ece677c, 1 | BRF_GRA }, // 4 Characters
2885 { "seibu6.u048", 0x010000, 0x44844ef8, 1 | BRF_GRA }, // 5
2886
2887 { "v_bg-11.415", 0x200000, 0x6fc96736, 2 | BRF_GRA }, // 6 Background Tiles
2888 { "v_bg-12.415", 0x100000, 0xd3c7281c, 2 | BRF_GRA }, // 7
2889 { "v_bg-21.410", 0x100000, 0xd65b4318, 2 | BRF_GRA }, // 8
2890 { "v_bg-22.416", 0x080000, 0x24a0a23a, 2 | BRF_GRA }, // 9
2891
2892 { "v_obj-1.322", 0x400000, 0x3be5b631, 3 | BRF_GRA }, // 10 Sprites
2893 { "v_obj-2.324", 0x400000, 0x924153b4, 3 | BRF_GRA }, // 11
2894 { "v_obj-3.323", 0x400000, 0xe9fb9062, 3 | BRF_GRA }, // 12
2895
2896 { "v_pcm.215", 0x100000, 0xe3111b60, 3 | BRF_PRG | BRF_ESS }, // 13 Sample Data (Mapped to i386)
2897
2898 { "flash0_blank_region10.u1053", 0x100000, 0x4319d998, 0 | BRF_SND }, // 14 Intel Flash (Samples)
2899 };
2900
2901 STD_ROM_PICK(viprp1ua)
2902 STD_ROM_FN(viprp1ua)
2903
2904 struct BurnDriver BurnDrvViprp1ua = {
2905 "viprp1ua", "viprp1", NULL, NULL, "1995",
2906 "Viper Phase 1 (New Version, US set 2)\0", NULL, "Seibu Kaihatsu (Fabtek license)", "SPI",
2907 NULL, NULL, NULL, NULL,
2908 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
2909 NULL, viprp1uaRomInfo, viprp1uaRomName, NULL, NULL, NULL, NULL, Spi_3buttonInputInfo, Spi_3buttonDIPInfo,
2910 Viprp1Init, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
2911 240, 320, 3, 4
2912 };
2913
2914
2915 // Viper Phase 1 (New Version, Japan)
2916
2917 static struct BurnRomInfo viprp1jRomDesc[] = {
2918 { "v_1-n.211", 0x080000, 0x55f10b72, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
2919 { "v_2-n.212", 0x080000, 0x0f888283, 1 | BRF_PRG | BRF_ESS }, // 1
2920 { "v_3-n.210", 0x080000, 0x842434ac, 1 | BRF_PRG | BRF_ESS }, // 2
2921 { "v_4-n.29", 0x080000, 0xa3948824, 1 | BRF_PRG | BRF_ESS }, // 3
2922
2923 { "seibu5.u0413", 0x020000, 0x5ece677c, 1 | BRF_GRA }, // 4 Characters
2924 { "seibu6.u048", 0x010000, 0x44844ef8, 1 | BRF_GRA }, // 5
2925
2926 { "v_bg-11.415", 0x200000, 0x6fc96736, 2 | BRF_GRA }, // 6 Background Tiles
2927 { "v_bg-12.415", 0x100000, 0xd3c7281c, 2 | BRF_GRA }, // 7
2928 { "v_bg-21.410", 0x100000, 0xd65b4318, 2 | BRF_GRA }, // 8
2929 { "v_bg-22.416", 0x080000, 0x24a0a23a, 2 | BRF_GRA }, // 9
2930
2931 { "v_obj-1.322", 0x400000, 0x3be5b631, 3 | BRF_GRA }, // 10 Sprites
2932 { "v_obj-2.324", 0x400000, 0x924153b4, 3 | BRF_GRA }, // 11
2933 { "v_obj-3.323", 0x400000, 0xe9fb9062, 3 | BRF_GRA }, // 12
2934
2935 { "v_pcm.215", 0x100000, 0xe3111b60, 3 | BRF_PRG | BRF_ESS }, // 13 Sample Data (Mapped to i386)
2936
2937 { "flash0_blank_region01.u1053", 0x100000, 0x7ae7ab76, 0 | BRF_SND }, // 14 Intel Flash (Samples)
2938 };
2939
2940 STD_ROM_PICK(viprp1j)
2941 STD_ROM_FN(viprp1j)
2942
2943 struct BurnDriver BurnDrvViprp1j = {
2944 "viprp1j", "viprp1", NULL, NULL, "1995",
2945 "Viper Phase 1 (New Version, Japan)\0", NULL, "Seibu Kaihatsu", "SPI",
2946 NULL, NULL, NULL, NULL,
2947 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
2948 NULL, viprp1jRomInfo, viprp1jRomName, NULL, NULL, NULL, NULL, Spi_3buttonInputInfo, Spi_3buttonDIPInfo,
2949 Viprp1Init, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
2950 240, 320, 3, 4
2951 };
2952
2953
2954 // Viper Phase 1 (New Version, Switzerland)
2955
2956 static struct BurnRomInfo viprp1sRomDesc[] = {
2957 { "viper_prg0.bin", 0x080000, 0xed9980b8, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
2958 { "viper_prg1.bin", 0x080000, 0x9d4d3486, 1 | BRF_PRG | BRF_ESS }, // 1
2959 { "viper_prg2.bin", 0x080000, 0xd7ea460b, 1 | BRF_PRG | BRF_ESS }, // 2
2960 { "viper_prg3.bin", 0x080000, 0xca6df094, 1 | BRF_PRG | BRF_ESS }, // 3
2961
2962 { "seibu5.u0413", 0x020000, 0x5ece677c, 1 | BRF_GRA }, // 4 Characters
2963 { "seibu6.u048", 0x010000, 0x44844ef8, 1 | BRF_GRA }, // 5
2964
2965 { "v_bg-11.415", 0x200000, 0x6fc96736, 2 | BRF_GRA }, // 6 Background Tiles
2966 { "v_bg-12.415", 0x100000, 0xd3c7281c, 2 | BRF_GRA }, // 7
2967 { "v_bg-21.410", 0x100000, 0xd65b4318, 2 | BRF_GRA }, // 8
2968 { "v_bg-22.416", 0x080000, 0x24a0a23a, 2 | BRF_GRA }, // 9
2969
2970 { "v_obj-1.322", 0x400000, 0x3be5b631, 3 | BRF_GRA }, // 10 Sprites
2971 { "v_obj-2.324", 0x400000, 0x924153b4, 3 | BRF_GRA }, // 11
2972 { "v_obj-3.323", 0x400000, 0xe9fb9062, 3 | BRF_GRA }, // 12
2973
2974 { "v_pcm.215", 0x100000, 0xe3111b60, 3 | BRF_PRG | BRF_ESS }, // 13 Sample Data (Mapped to i386)
2975
2976 { "flash0_blank_region9c.u1053", 0x100000, 0xd73d640c, 0 | BRF_SND }, // 14 Intel Flash (Samples)
2977 };
2978
2979 STD_ROM_PICK(viprp1s)
2980 STD_ROM_FN(viprp1s)
2981
2982 struct BurnDriver BurnDrvViprp1s = {
2983 "viprp1s", "viprp1", NULL, NULL, "1995",
2984 "Viper Phase 1 (New Version, Switzerland)\0", NULL, "Seibu Kaihatsu", "SPI",
2985 NULL, NULL, NULL, NULL,
2986 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
2987 NULL, viprp1sRomInfo, viprp1sRomName, NULL, NULL, NULL, NULL, Spi_3buttonInputInfo, Spi_3buttonDIPInfo,
2988 Viprp1Init, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
2989 240, 320, 3, 4
2990 };
2991
2992
2993 // Viper Phase 1 (New Version, Holland)
2994
2995 static struct BurnRomInfo viprp1hRomDesc[] = {
2996 { "viper_prg0_010995.u0211", 0x080000, 0xe42fcc93, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
2997 { "viper_prg1_010995.u0212", 0x080000, 0x9d4d3486, 1 | BRF_PRG | BRF_ESS }, // 1
2998 { "viper_prg2_010995.u0210", 0x080000, 0xd7ea460b, 1 | BRF_PRG | BRF_ESS }, // 2
2999 { "viper_prg3_010995.u029", 0x080000, 0xca6df094, 1 | BRF_PRG | BRF_ESS }, // 3
3000
3001 { "viper_fix_010995.u0413", 0x020000, 0x5ece677c, 1 | BRF_GRA }, // 4 Characters
3002 { "viper_fixp_010995.u048", 0x010000, 0x44844ef8, 1 | BRF_GRA }, // 5
3003
3004 { "v_bg-11.415", 0x200000, 0x6fc96736, 2 | BRF_GRA }, // 6 Background Tiles
3005 { "v_bg-12.415", 0x100000, 0xd3c7281c, 2 | BRF_GRA }, // 7
3006 { "v_bg-21.410", 0x100000, 0xd65b4318, 2 | BRF_GRA }, // 8
3007 { "v_bg-22.416", 0x080000, 0x24a0a23a, 2 | BRF_GRA }, // 9
3008
3009 { "v_obj-1.322", 0x400000, 0x3be5b631, 3 | BRF_GRA }, // 10 Sprites
3010 { "v_obj-2.324", 0x400000, 0x924153b4, 3 | BRF_GRA }, // 11
3011 { "v_obj-3.323", 0x400000, 0xe9fb9062, 3 | BRF_GRA }, // 12
3012
3013 { "v_pcm.215", 0x100000, 0xe3111b60, 3 | BRF_PRG | BRF_ESS }, // 13 Sample Data (Mapped to i386)
3014
3015 { "flash0_blank_region90.u1053", 0x100000, 0x8da617a2, 0 | BRF_SND }, // 14 Intel Flash (Samples)
3016 };
3017
3018 STD_ROM_PICK(viprp1h)
3019 STD_ROM_FN(viprp1h)
3020
3021 struct BurnDriver BurnDrvViprp1h = {
3022 "viprp1h", "viprp1", NULL, NULL, "1995",
3023 "Viper Phase 1 (New Version, Holland)\0", NULL, "Seibu Kaihatsu", "SPI",
3024 NULL, NULL, NULL, NULL,
3025 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
3026 NULL, viprp1hRomInfo, viprp1hRomName, NULL, NULL, NULL, NULL, Spi_3buttonInputInfo, Spi_3buttonDIPInfo,
3027 Viprp1Init, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
3028 240, 320, 3, 4
3029 };
3030
3031
3032 // Viper Phase 1 (New Version, Germany)
3033
3034 static struct BurnRomInfo viprp1tRomDesc[] = {
3035 { "viper_prg0_010995.u0211", 0x080000, 0xf998dcf7, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
3036 { "viper_prg1_010995.u0212", 0x080000, 0x9d4d3486, 1 | BRF_PRG | BRF_ESS }, // 1
3037 { "viper_prg2_010995.u0210", 0x080000, 0xd7ea460b, 1 | BRF_PRG | BRF_ESS }, // 2
3038 { "viper_prg3_010995.u029", 0x080000, 0xca6df094, 1 | BRF_PRG | BRF_ESS }, // 3
3039
3040 { "viper_fix_010995.u0413", 0x020000, 0x5ece677c, 1 | BRF_GRA }, // 4 Characters
3041 { "viper_fixp_010995.u048", 0x010000, 0x44844ef8, 1 | BRF_GRA }, // 5
3042
3043 { "v_bg-11.415", 0x200000, 0x6fc96736, 2 | BRF_GRA }, // 6 Background Tiles
3044 { "v_bg-12.415", 0x100000, 0xd3c7281c, 2 | BRF_GRA }, // 7
3045 { "v_bg-21.410", 0x100000, 0xd65b4318, 2 | BRF_GRA }, // 8
3046 { "v_bg-22.416", 0x080000, 0x24a0a23a, 2 | BRF_GRA }, // 9
3047
3048 { "v_obj-1.322", 0x400000, 0x3be5b631, 3 | BRF_GRA }, // 10 Sprites
3049 { "v_obj-2.324", 0x400000, 0x924153b4, 3 | BRF_GRA }, // 11
3050 { "v_obj-3.323", 0x400000, 0xe9fb9062, 3 | BRF_GRA }, // 12
3051
3052 { "v_pcm.215", 0x100000, 0xe3111b60, 3 | BRF_PRG | BRF_ESS }, // 13 Sample Data (Mapped to i386)
3053
3054 { "flash0_blank_region80.u1053", 0x100000, 0xe2adaff5, 0 | BRF_SND }, // 14 Intel Flash (Samples)
3055 };
3056
3057 STD_ROM_PICK(viprp1t)
3058 STD_ROM_FN(viprp1t)
3059
3060 struct BurnDriver BurnDrvViprp1t = {
3061 "viprp1t", "viprp1", NULL, NULL, "1995",
3062 "Viper Phase 1 (New Version, Germany)\0", NULL, "Seibu Kaihatsu (Tuning license)", "SPI",
3063 NULL, NULL, NULL, NULL,
3064 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
3065 NULL, viprp1tRomInfo, viprp1tRomName, NULL, NULL, NULL, NULL, Spi_3buttonInputInfo, Spi_3buttonDIPInfo,
3066 Viprp1Init, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
3067 240, 320, 3, 4
3068 };
3069
3070
3071 // Viper Phase 1 (New Version, Portugal)
3072
3073 static struct BurnRomInfo viprp1ptRomDesc[] = {
3074 { "viper_prg0_010995.u0211", 0x080000, 0x0d4c69a6, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
3075 { "viper_prg1_010995.u0212", 0x080000, 0x9d4d3486, 1 | BRF_PRG | BRF_ESS }, // 1
3076 { "viper_prg2_010995.u0210", 0x080000, 0xd7ea460b, 1 | BRF_PRG | BRF_ESS }, // 2
3077 { "viper_prg3_010995.u029", 0x080000, 0xca6df094, 1 | BRF_PRG | BRF_ESS }, // 3
3078
3079 { "viper_fix_010995.u0413", 0x020000, 0x5ece677c, 1 | BRF_GRA }, // 4 Characters
3080 { "viper_fixp_010995.u048", 0x010000, 0x44844ef8, 1 | BRF_GRA }, // 5
3081
3082 { "v_bg-11.415", 0x200000, 0x6fc96736, 2 | BRF_GRA }, // 6 Background Tiles
3083 { "v_bg-12.415", 0x100000, 0xd3c7281c, 2 | BRF_GRA }, // 7
3084 { "v_bg-21.410", 0x100000, 0xd65b4318, 2 | BRF_GRA }, // 8
3085 { "v_bg-22.416", 0x080000, 0x24a0a23a, 2 | BRF_GRA }, // 9
3086
3087 { "v_obj-1.322", 0x400000, 0x3be5b631, 3 | BRF_GRA }, // 10 Sprites
3088 { "v_obj-2.324", 0x400000, 0x924153b4, 3 | BRF_GRA }, // 11
3089 { "v_obj-3.323", 0x400000, 0xe9fb9062, 3 | BRF_GRA }, // 12
3090
3091 { "v_pcm.215", 0x100000, 0xe3111b60, 3 | BRF_PRG | BRF_ESS }, // 13 Sample Data (Mapped to i386)
3092
3093 { "flash0_blank_region96.u1053", 0x100000, 0xa0ebae75, 0 | BRF_SND }, // 14 Intel Flash (Samples)
3094 };
3095
3096 STD_ROM_PICK(viprp1pt)
3097 STD_ROM_FN(viprp1pt)
3098
3099 struct BurnDriver BurnDrvViprp1pt = {
3100 "viprp1pt", "viprp1", NULL, NULL, "1995",
3101 "Viper Phase 1 (New Version, Portugal)\0", NULL, "Seibu Kaihatsu", "SPI",
3102 NULL, NULL, NULL, NULL,
3103 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
3104 NULL, viprp1ptRomInfo, viprp1ptRomName, NULL, NULL, NULL, NULL, Spi_3buttonInputInfo, Spi_3buttonDIPInfo,
3105 Viprp1Init, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
3106 240, 320, 3, 4
3107 };
3108
3109
3110 // Viper Phase 1 (Hong Kong)
3111
3112 static struct BurnRomInfo viprp1hkRomDesc[] = {
3113 { "seibu_1", 0x080000, 0x283ba7b7, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
3114 { "seibu_2", 0x080000, 0x2c4db249, 1 | BRF_PRG | BRF_ESS }, // 1
3115 { "seibu_3", 0x080000, 0x91989503, 1 | BRF_PRG | BRF_ESS }, // 2
3116 { "seibu_4", 0x080000, 0x12c9582d, 1 | BRF_PRG | BRF_ESS }, // 3
3117
3118 { "seibu_5", 0x020000, 0x80920fed, 1 | BRF_GRA }, // 4 Characters
3119 { "seibu_6", 0x010000, 0xe71a8722, 1 | BRF_GRA }, // 5
3120
3121 { "v_bg-11.415", 0x200000, 0x6fc96736, 2 | BRF_GRA }, // 6 Background Tiles
3122 { "v_bg-12.415", 0x100000, 0xd3c7281c, 2 | BRF_GRA }, // 7
3123 { "v_bg-21.410", 0x100000, 0xd65b4318, 2 | BRF_GRA }, // 8
3124 { "v_bg-22.416", 0x080000, 0x24a0a23a, 2 | BRF_GRA }, // 9
3125
3126 { "v_obj-1.322", 0x400000, 0x3be5b631, 3 | BRF_GRA }, // 10 Sprites
3127 { "v_obj-2.324", 0x400000, 0x924153b4, 3 | BRF_GRA }, // 11
3128 { "v_obj-3.323", 0x400000, 0xe9fb9062, 3 | BRF_GRA }, // 12
3129
3130 { "v_pcm.215", 0x100000, 0xe3111b60, 3 | BRF_PRG | BRF_ESS }, // 13 Sample Data (Mapped to i386)
3131
3132 { "flash0_blank_region22.u1053", 0x100000, 0x5fee8413, 0 | BRF_SND }, // 14 Intel Flash (Samples)
3133 };
3134
3135 STD_ROM_PICK(viprp1hk)
3136 STD_ROM_FN(viprp1hk)
3137
3138 struct BurnDriver BurnDrvViprp1hk = {
3139 "viprp1hk", "viprp1", NULL, NULL, "1995",
3140 "Viper Phase 1 (Hong Kong)\0", NULL, "Seibu Kaihatsu (Metrotainment license)", "SPI",
3141 NULL, NULL, NULL, NULL,
3142 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
3143 NULL, viprp1hkRomInfo, viprp1hkRomName, NULL, NULL, NULL, NULL, Spi_3buttonInputInfo, Spi_3buttonDIPInfo,
3144 Viprp1Init, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
3145 240, 320, 3, 4
3146 };
3147
3148
3149 // Viper Phase 1 (Japan)
3150
3151 static struct BurnRomInfo viprp1ojRomDesc[] = {
3152 { "v_1-o.211", 0x080000, 0x4430be64, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
3153 { "v_2-o.212", 0x080000, 0xffbd88f7, 1 | BRF_PRG | BRF_ESS }, // 1
3154 { "v_3-o.210", 0x080000, 0x6146db39, 1 | BRF_PRG | BRF_ESS }, // 2
3155 { "v_4-o.29", 0x080000, 0xdc8dd2b6, 1 | BRF_PRG | BRF_ESS }, // 3
3156
3157 { "v_5-o.413", 0x020000, 0x6d863acc, 1 | BRF_GRA }, // 4 Characters
3158 { "v_6-o.48", 0x010000, 0xfe7cb8f7, 1 | BRF_GRA }, // 5
3159
3160 { "v_bg-11.415", 0x200000, 0x6fc96736, 2 | BRF_GRA }, // 6 Background Tiles
3161 { "v_bg-12.415", 0x100000, 0xd3c7281c, 2 | BRF_GRA }, // 7
3162 { "v_bg-21.410", 0x100000, 0xd65b4318, 2 | BRF_GRA }, // 8
3163 { "v_bg-22.416", 0x080000, 0x24a0a23a, 2 | BRF_GRA }, // 9
3164
3165 { "v_obj-1.322", 0x400000, 0x3be5b631, 3 | BRF_GRA }, // 10 Sprites
3166 { "v_obj-2.324", 0x400000, 0x924153b4, 3 | BRF_GRA }, // 11
3167 { "v_obj-3.323", 0x400000, 0xe9fb9062, 3 | BRF_GRA }, // 12
3168
3169 { "v_pcm.215", 0x100000, 0xe3111b60, 3 | BRF_PRG | BRF_ESS }, // 13 Sample Data (Mapped to i386)
3170
3171 { "flash0_blank_region01.u1053", 0x100000, 0x7ae7ab76, 0 | BRF_SND }, // 14 Intel Flash (Samples)
3172 };
3173
3174 STD_ROM_PICK(viprp1oj)
3175 STD_ROM_FN(viprp1oj)
3176
3177 struct BurnDriver BurnDrvViprp1oj = {
3178 "viprp1oj", "viprp1", NULL, NULL, "1995",
3179 "Viper Phase 1 (Japan)\0", NULL, "Seibu Kaihatsu", "SPI",
3180 NULL, NULL, NULL, NULL,
3181 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
3182 NULL, viprp1ojRomInfo, viprp1ojRomName, NULL, NULL, NULL, NULL, Spi_3buttonInputInfo, Spi_3buttonDIPInfo,
3183 Viprp1Init, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
3184 240, 320, 3, 4
3185 };
3186
3187
3188 // Viper Phase 1 (Germany)
3189
3190 static struct BurnRomInfo viprp1otRomDesc[] = {
3191 { "ov1.bin", 0x080000, 0xcbad0e28, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
3192 { "ov2.bin", 0x080000, 0x0e2bbcb5, 1 | BRF_PRG | BRF_ESS }, // 1
3193 { "ov3.bin", 0x080000, 0x0e86686b, 1 | BRF_PRG | BRF_ESS }, // 2
3194 { "ov4.bin", 0x080000, 0x9d7dd325, 1 | BRF_PRG | BRF_ESS }, // 3
3195
3196 { "v_5-o.413", 0x020000, 0x6d863acc, 1 | BRF_GRA }, // 4 Characters
3197 { "v_6-o.48", 0x010000, 0xfe7cb8f7, 1 | BRF_GRA }, // 5
3198
3199 { "v_bg-11.415", 0x200000, 0x6fc96736, 2 | BRF_GRA }, // 6 Background Tiles
3200 { "v_bg-12.415", 0x100000, 0xd3c7281c, 2 | BRF_GRA }, // 7
3201 { "v_bg-21.410", 0x100000, 0xd65b4318, 2 | BRF_GRA }, // 8
3202 { "v_bg-22.416", 0x080000, 0x24a0a23a, 2 | BRF_GRA }, // 9
3203
3204 { "v_obj-1.322", 0x400000, 0x3be5b631, 3 | BRF_GRA }, // 10 Sprites
3205 { "v_obj-2.324", 0x400000, 0x924153b4, 3 | BRF_GRA }, // 11
3206 { "v_obj-3.323", 0x400000, 0xe9fb9062, 3 | BRF_GRA }, // 12
3207
3208 { "v_pcm.215", 0x100000, 0xe3111b60, 3 | BRF_PRG | BRF_ESS }, // 13 Sample Data (Mapped to i386)
3209
3210 { "flash0_blank_region80.u1053", 0x100000, 0xe2adaff5, 0 | BRF_SND }, // 14 Intel Flash (Samples)
3211 };
3212
3213 STD_ROM_PICK(viprp1ot)
3214 STD_ROM_FN(viprp1ot)
3215
3216 struct BurnDriver BurnDrvViprp1ot = {
3217 "viprp1ot", "viprp1", NULL, NULL, "1995",
3218 "Viper Phase 1 (Germany)\0", NULL, "Seibu Kaihatsu (Tuning license)", "SPI",
3219 NULL, NULL, NULL, NULL,
3220 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
3221 NULL, viprp1otRomInfo, viprp1otRomName, NULL, NULL, NULL, NULL, Spi_3buttonInputInfo, Spi_3buttonDIPInfo,
3222 Viprp1Init, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
3223 240, 320, 3, 4
3224 };
3225
3226
3227 // Raiden Fighters (Germany)
3228
3229 static struct BurnRomInfo rdftRomDesc[] = {
3230 { "raiden-fi_prg0_121196.u0211", 0x080000, 0xadcb5dbc, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
3231 { "raiden-fi_prg1_121196.u0212", 0x080000, 0x60c5b92e, 1 | BRF_PRG | BRF_ESS }, // 1
3232 { "raiden-fi_prg2_121196.u0210", 0x080000, 0x44b86db5, 1 | BRF_PRG | BRF_ESS }, // 2
3233 { "raiden-fi_prg3_121196.u029", 0x080000, 0xe70727ce, 1 | BRF_PRG | BRF_ESS }, // 3
3234
3235 { "seibu_6.u0424", 0x010000, 0x6ac64968, 1 | BRF_GRA }, // 4 Characters
3236 { "seibu_5.u0423", 0x010000, 0x8f8d4e14, 1 | BRF_GRA }, // 5
3237 { "seibu_7.u048", 0x010000, 0x4d87e1ea, 1 | BRF_GRA }, // 6
3238
3239 { "gun_dogs_bg1-d.u0415", 0x200000, 0x6a68054c, 2 | BRF_GRA }, // 7 Background Tiles
3240 { "gun_dogs_bg1-p.u0410", 0x100000, 0x3400794a, 2 | BRF_GRA }, // 8
3241 { "gun_dogs_bg2-d.u0424", 0x200000, 0x61cd2991, 2 | BRF_GRA }, // 9
3242 { "gun_dogs_bg2-p.u049", 0x100000, 0x502d5799, 2 | BRF_GRA }, // 10
3243
3244 { "gun_dogs_obj-1.u0322", 0x400000, 0x59d86c99, 3 | BRF_GRA }, // 11 Sprites
3245 { "gun_dogs_obj-2.u0324", 0x400000, 0x1ceb0b6f, 3 | BRF_GRA }, // 12
3246 { "gun_dogs_obj-3.u0323", 0x400000, 0x36e93234, 3 | BRF_GRA }, // 13
3247
3248 { "gun_dogs_pcm.u0217", 0x200000, 0x31253ad7, 3 | BRF_PRG | BRF_ESS }, // 14 Sample Data (Mapped to i386)
3249 { "seibu_8.u0216", 0x080000, 0xf88cb6e4, 3 | BRF_PRG | BRF_ESS }, // 15
3250
3251 { "flash0_blank_region80.u1053", 0x100000, 0xe2adaff5, 0 | BRF_SND }, // 16 Intel Flash (Samples)
3252 };
3253
3254 STD_ROM_PICK(rdft)
STD_ROM_FN(rdft)3255 STD_ROM_FN(rdft)
3256
3257 // hack - build flash roms from sample data to allow for instant loading rather than wait for flash to populate for 999 seconds.
3258 static void rdft_build_flash()
3259 {
3260 INT32 i, j;
3261 char *pRomName;
3262 struct BurnRomInfo ri;
3263
3264 for (i = 0; !BurnDrvGetRomName(&pRomName, i, 0); i++) {
3265 BurnDrvGetRomInfo(&ri, i);
3266 if ((ri.nType & 7) == 3 && (ri.nType & BRF_PRG)) break;
3267 }
3268
3269 BurnLoadRomExt(DrvSndROM[0] + 0x0a00000, i+0, 1, LD_GROUP(1));
3270
3271 BurnDrvGetRomInfo(&ri, i+1); // check for second rom, newer set does not have this
3272
3273 if ((ri.nType & 7) == 3 && (ri.nType & BRF_PRG)) // has second rom, copy it in
3274 {
3275 UINT8 *tmp = (UINT8*)BurnMalloc(ri.nLen);
3276
3277 BurnLoadRomExt(tmp, i+1, 1, LD_GROUP(1));
3278
3279 j = 0x1fffff;
3280 while (DrvSndROM[0][0xa00000 + j - 1] == 0xff) j--;
3281
3282 memcpy (DrvSndROM[0] + 0x0a00000 + j, tmp, 0x200000 - j);
3283
3284 BurnFree(tmp);
3285 }
3286
3287 DrvSndROM[0][0xa00000] = DrvMainROM[0x1ffffc]; // region
3288 DrvSndROM[0][0xa00001] = 0x4a; // checksums?
3289 DrvSndROM[0][0xa00002] = 0x4a;
3290 DrvSndROM[0][0xa00003] = 0x36;
3291 }
3292
RdftInit()3293 static INT32 RdftInit()
3294 {
3295 return CommonInit(DECRYPT_SEI252, rdft_build_flash, 0x00298d0, 0x203f06);
3296 }
3297
3298 struct BurnDriver BurnDrvRdft = {
3299 "rdft", NULL, NULL, NULL, "1996",
3300 "Raiden Fighters (Germany)\0", NULL, "Seibu Kaihatsu (Tuning license)", "SPI",
3301 NULL, NULL, NULL, NULL,
3302 BDF_GAME_WORKING | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
3303 NULL, rdftRomInfo, rdftRomName, NULL, NULL, NULL, NULL, Spi_3buttonInputInfo, Spi_3buttonDIPInfo,
3304 RdftInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
3305 240, 320, 3, 4
3306 };
3307
3308
3309 // Raiden Fighters (US, earlier)
3310
3311 static struct BurnRomInfo rdftuRomDesc[] = {
3312 { "rdftu_gd_1.211", 0x080000, 0x47810c48, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
3313 { "rdftu_gd_2.212", 0x080000, 0x13911750, 1 | BRF_PRG | BRF_ESS }, // 1
3314 { "rdftu_gd_3.210", 0x080000, 0x10761b03, 1 | BRF_PRG | BRF_ESS }, // 2
3315 { "rdftu_gd_4.29", 0x080000, 0xe5a3f01d, 1 | BRF_PRG | BRF_ESS }, // 3
3316
3317 { "seibu_6.u0424", 0x010000, 0x6ac64968, 1 | BRF_GRA }, // 4 Characters
3318 { "seibu_5.u0423", 0x010000, 0x8f8d4e14, 1 | BRF_GRA }, // 5
3319 { "seibu_7.u048", 0x010000, 0x4d87e1ea, 1 | BRF_GRA }, // 6
3320
3321 { "gun_dogs_bg1-d.u0415", 0x200000, 0x6a68054c, 2 | BRF_GRA }, // 7 Background Tiles
3322 { "gun_dogs_bg1-p.u0410", 0x100000, 0x3400794a, 2 | BRF_GRA }, // 8
3323 { "gun_dogs_bg2-d.u0424", 0x200000, 0x61cd2991, 2 | BRF_GRA }, // 9
3324 { "gun_dogs_bg2-p.u049", 0x100000, 0x502d5799, 2 | BRF_GRA }, // 10
3325
3326 { "gun_dogs_obj-1.u0322", 0x400000, 0x59d86c99, 3 | BRF_GRA }, // 11 Sprites
3327 { "gun_dogs_obj-2.u0324", 0x400000, 0x1ceb0b6f, 3 | BRF_GRA }, // 12
3328 { "gun_dogs_obj-3.u0323", 0x400000, 0x36e93234, 3 | BRF_GRA }, // 13
3329
3330 { "gun_dogs_pcm.u0217", 0x200000, 0x31253ad7, 3 | BRF_PRG | BRF_ESS }, // 14 Sample Data (Mapped to i386)
3331 { "seibu_8.u0216", 0x080000, 0xf88cb6e4, 3 | BRF_PRG | BRF_ESS }, // 15
3332
3333 { "flash0_blank_region10.u1053", 0x100000, 0x4319d998, 0 | BRF_SND }, // 16 Intel Flash (Samples)
3334 };
3335
3336 STD_ROM_PICK(rdftu)
STD_ROM_FN(rdftu)3337 STD_ROM_FN(rdftu)
3338
3339 static INT32 RdftuInit()
3340 {
3341 return CommonInit(DECRYPT_SEI252, rdft_build_flash, 0x00298d0, 0x203f3a);
3342 }
3343
3344 struct BurnDriver BurnDrvRdftu = {
3345 "rdftu", "rdft", NULL, NULL, "1996",
3346 "Raiden Fighters (US, earlier)\0", NULL, "Seibu Kaihatsu (Fabtek license)", "SPI",
3347 NULL, NULL, NULL, NULL,
3348 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
3349 NULL, rdftuRomInfo, rdftuRomName, NULL, NULL, NULL, NULL, Spi_3buttonInputInfo, Spi_3buttonDIPInfo,
3350 RdftuInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
3351 240, 320, 3, 4
3352 };
3353
3354
3355 // Raiden Fighters (Japan, earlier)
3356
3357 static struct BurnRomInfo rdftjRomDesc[] = {
3358 { "gd_1.211", 0x080000, 0xf6b2cbdc, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
3359 { "gd_2.212", 0x080000, 0x1982f812, 1 | BRF_PRG | BRF_ESS }, // 1
3360 { "gd_3.210", 0x080000, 0xb0f59f44, 1 | BRF_PRG | BRF_ESS }, // 2
3361 { "gd_4.29", 0x080000, 0xcd8705bd, 1 | BRF_PRG | BRF_ESS }, // 3
3362
3363 { "seibu_6.u0424", 0x010000, 0x6ac64968, 1 | BRF_GRA }, // 4 Characters
3364 { "seibu_5.u0423", 0x010000, 0x8f8d4e14, 1 | BRF_GRA }, // 5
3365 { "seibu_7.u048", 0x010000, 0x4d87e1ea, 1 | BRF_GRA }, // 6
3366
3367 { "gun_dogs_bg1-d.u0415", 0x200000, 0x6a68054c, 2 | BRF_GRA }, // 7 Background Tiles
3368 { "gun_dogs_bg1-p.u0410", 0x100000, 0x3400794a, 2 | BRF_GRA }, // 8
3369 { "gun_dogs_bg2-d.u0424", 0x200000, 0x61cd2991, 2 | BRF_GRA }, // 9
3370 { "gun_dogs_bg2-p.u049", 0x100000, 0x502d5799, 2 | BRF_GRA }, // 10
3371
3372 { "gun_dogs_obj-1.u0322", 0x400000, 0x59d86c99, 3 | BRF_GRA }, // 11 Sprites
3373 { "gun_dogs_obj-2.u0324", 0x400000, 0x1ceb0b6f, 3 | BRF_GRA }, // 12
3374 { "gun_dogs_obj-3.u0323", 0x400000, 0x36e93234, 3 | BRF_GRA }, // 13
3375
3376 { "gun_dogs_pcm.u0217", 0x200000, 0x31253ad7, 3 | BRF_PRG | BRF_ESS }, // 14 Sample Data (Mapped to i386)
3377 { "seibu_8.u0216", 0x080000, 0xf88cb6e4, 3 | BRF_PRG | BRF_ESS }, // 15
3378
3379 { "flash0_blank_region01.u1053", 0x100000, 0x7ae7ab76, 0 | BRF_SND }, // 16 Intel Flash (Samples)
3380 };
3381
3382 STD_ROM_PICK(rdftj)
STD_ROM_FN(rdftj)3383 STD_ROM_FN(rdftj)
3384
3385 static INT32 RdftjInit()
3386 {
3387 return CommonInit(DECRYPT_SEI252, rdft_build_flash, 0x00298d0, 0x203f0a);
3388 }
3389
3390 struct BurnDriver BurnDrvRdftj = {
3391 "rdftj", "rdft", NULL, NULL, "1996",
3392 "Raiden Fighters (Japan, earlier)\0", NULL, "Seibu Kaihatsu", "SPI",
3393 NULL, NULL, NULL, NULL,
3394 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
3395 NULL, rdftjRomInfo, rdftjRomName, NULL, NULL, NULL, NULL, Spi_3buttonInputInfo, Spi_3buttonDIPInfo,
3396 RdftjInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
3397 240, 320, 3, 4
3398 };
3399
3400
3401 // Raiden Fighters (Japan, earliest)
3402
3403 static struct BurnRomInfo rdftjaRomDesc[] = {
3404 { "rf1.bin", 0x080000, 0x46861b75, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
3405 { "rf2.bin", 0x080000, 0x6388ed11, 1 | BRF_PRG | BRF_ESS }, // 1
3406 { "rf3.bin", 0x080000, 0xbeafcd24, 1 | BRF_PRG | BRF_ESS }, // 2
3407 { "rf4.bin", 0x080000, 0x5236f45f, 1 | BRF_PRG | BRF_ESS }, // 3
3408
3409 { "seibu_6.u0424", 0x010000, 0x6ac64968, 1 | BRF_GRA }, // 4 Characters
3410 { "seibu_5.u0423", 0x010000, 0x8f8d4e14, 1 | BRF_GRA }, // 5
3411 { "seibu_7.u048", 0x010000, 0x4d87e1ea, 1 | BRF_GRA }, // 6
3412
3413 { "gun_dogs_bg1-d.u0415", 0x200000, 0x6a68054c, 2 | BRF_GRA }, // 7 Background Tiles
3414 { "gun_dogs_bg1-p.u0410", 0x100000, 0x3400794a, 2 | BRF_GRA }, // 8
3415 { "gun_dogs_bg2-d.u0424", 0x200000, 0x61cd2991, 2 | BRF_GRA }, // 9
3416 { "gun_dogs_bg2-p.u049", 0x100000, 0x502d5799, 2 | BRF_GRA }, // 10
3417
3418 { "gun_dogs_obj-1.u0322", 0x400000, 0x59d86c99, 3 | BRF_GRA }, // 11 Sprites
3419 { "gun_dogs_obj-2.u0324", 0x400000, 0x1ceb0b6f, 3 | BRF_GRA }, // 12
3420 { "gun_dogs_obj-3.u0323", 0x400000, 0x36e93234, 3 | BRF_GRA }, // 13
3421
3422 { "gun_dogs_pcm.u0217", 0x200000, 0x31253ad7, 3 | BRF_PRG | BRF_ESS }, // 14 Sample Data (Mapped to i386)
3423 { "seibu_8.u0216", 0x080000, 0xf88cb6e4, 3 | BRF_PRG | BRF_ESS }, // 15
3424
3425 { "flash0_blank_region01.u1053", 0x100000, 0x7ae7ab76, 0 | BRF_SND }, // 16 Intel Flash (Samples)
3426 };
3427
3428 STD_ROM_PICK(rdftja)
STD_ROM_FN(rdftja)3429 STD_ROM_FN(rdftja)
3430
3431 static INT32 RdftjaInit()
3432 {
3433 return CommonInit(DECRYPT_SEI252, rdft_build_flash, 0x00298d0, 0x203f45);
3434 }
3435
3436 struct BurnDriver BurnDrvRdftja = {
3437 "rdftja", "rdft", NULL, NULL, "1996",
3438 "Raiden Fighters (Japan, earliest)\0", NULL, "Seibu Kaihatsu", "SPI",
3439 NULL, NULL, NULL, NULL,
3440 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
3441 NULL, rdftjaRomInfo, rdftjaRomName, NULL, NULL, NULL, NULL, Spi_3buttonInputInfo, Spi_3buttonDIPInfo,
3442 RdftjaInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
3443 240, 320, 3, 4
3444 };
3445
3446
3447 // Raiden Fighters (Australia)
3448
3449 static struct BurnRomInfo rdftauRomDesc[] = {
3450 { "1.u0211", 0x080000, 0x6339c60d, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
3451 { "2.u0212", 0x080000, 0xa88bda02, 1 | BRF_PRG | BRF_ESS }, // 1
3452 { "3.u0210", 0x080000, 0xa73e337e, 1 | BRF_PRG | BRF_ESS }, // 2
3453 { "4.u029", 0x080000, 0x8cc628f0, 1 | BRF_PRG | BRF_ESS }, // 3
3454
3455 { "seibu_6.u0424", 0x010000, 0x6ac64968, 1 | BRF_GRA }, // 4 Characters
3456 { "seibu_5.u0423", 0x010000, 0x8f8d4e14, 1 | BRF_GRA }, // 5
3457 { "seibu_7.u048", 0x010000, 0x4d87e1ea, 1 | BRF_GRA }, // 6
3458
3459 { "gun_dogs_bg1-d.u0415", 0x200000, 0x6a68054c, 2 | BRF_GRA }, // 7 Background Tiles
3460 { "gun_dogs_bg1-p.u0410", 0x100000, 0x3400794a, 2 | BRF_GRA }, // 8
3461 { "gun_dogs_bg2-d.u0424", 0x200000, 0x61cd2991, 2 | BRF_GRA }, // 9
3462 { "gun_dogs_bg2-p.u049", 0x100000, 0x502d5799, 2 | BRF_GRA }, // 10
3463
3464 { "gun_dogs_obj-1.u0322", 0x400000, 0x59d86c99, 3 | BRF_GRA }, // 11 Sprites
3465 { "gun_dogs_obj-2.u0324", 0x400000, 0x1ceb0b6f, 3 | BRF_GRA }, // 12
3466 { "gun_dogs_obj-3.u0323", 0x400000, 0x36e93234, 3 | BRF_GRA }, // 13
3467
3468 { "gun_dogs_pcm.u0217", 0x200000, 0x31253ad7, 3 | BRF_PRG | BRF_ESS }, // 14 Sample Data (Mapped to i386)
3469 { "seibu_8.u0216", 0x080000, 0xf88cb6e4, 3 | BRF_PRG | BRF_ESS }, // 15
3470
3471 { "flash0_blank_region9e.u1053", 0x100000, 0x7ad6f17e, 0 | BRF_SND }, // 16 Intel Flash (Samples)
3472 };
3473
3474 STD_ROM_PICK(rdftau)
STD_ROM_FN(rdftau)3475 STD_ROM_FN(rdftau)
3476
3477 static INT32 RdftauInit()
3478 {
3479 return CommonInit(DECRYPT_SEI252, rdft_build_flash, 0x00298d0, 0x203f16);
3480 }
3481
3482 struct BurnDriver BurnDrvRdftau = {
3483 "rdftau", "rdft", NULL, NULL, "1996",
3484 "Raiden Fighters (Australia)\0", NULL, "Seibu Kaihatsu", "SPI",
3485 NULL, NULL, NULL, NULL,
3486 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
3487 NULL, rdftauRomInfo, rdftauRomName, NULL, NULL, NULL, NULL, Spi_3buttonInputInfo, Spi_3buttonDIPInfo,
3488 RdftauInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
3489 240, 320, 3, 4
3490 };
3491
3492
3493 // Raiden Fighters (Evaluation Software For Show, Germany)
3494
3495 static struct BurnRomInfo rdftaugeRomDesc[] = {
3496 { "seibu.1.u0211", 0x080000, 0x3e79da3c, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
3497 { "seibu.2.u0212", 0x080000, 0xa6fbf98c, 1 | BRF_PRG | BRF_ESS }, // 1
3498 { "seibu.3.u0210", 0x080000, 0xad31cc17, 1 | BRF_PRG | BRF_ESS }, // 2
3499 { "seibu.4.u029", 0x080000, 0x756d99ae, 1 | BRF_PRG | BRF_ESS }, // 3
3500
3501 { "seibu_6.u0424", 0x010000, 0x6ac64968, 1 | BRF_GRA }, // 4 Characters
3502 { "seibu_5.u0423", 0x010000, 0x8f8d4e14, 1 | BRF_GRA }, // 5
3503 { "seibu_7.u048", 0x010000, 0x4d87e1ea, 1 | BRF_GRA }, // 6
3504
3505 { "gun_dogs_bg1-d.u0415", 0x200000, 0x6a68054c, 2 | BRF_GRA }, // 7 Background Tiles
3506 { "gun_dogs_bg1-p.u0410", 0x100000, 0x3400794a, 2 | BRF_GRA }, // 8
3507 { "gun_dogs_bg2-d.u0416", 0x200000, 0x61cd2991, 2 | BRF_GRA }, // 9
3508 { "gun_dogs_bg2-p.u049", 0x100000, 0x502d5799, 2 | BRF_GRA }, // 10
3509
3510 { "gun_dogs_obj-1.u0322", 0x400000, 0x59d86c99, 3 | BRF_GRA }, // 11 Sprites
3511 { "gun_dogs_obj-2.u0324", 0x400000, 0x1ceb0b6f, 3 | BRF_GRA }, // 12
3512 { "gun_dogs_obj-3.u0323", 0x400000, 0x36e93234, 3 | BRF_GRA }, // 13
3513
3514 { "gun_dogs_pcm.u0217", 0x200000, 0x31253ad7, 3 | BRF_PRG | BRF_ESS }, // 14 Sample Data (Mapped to i386)
3515 { "seibu_8.u0216", 0x080000, 0xf88cb6e4, 3 | BRF_PRG | BRF_ESS }, // 15
3516
3517 { "flash0_blank_region9e.u1053", 0x100000, 0x7ad6f17e, 0 | BRF_SND }, // 16 Intel Flash (Samples)
3518 };
3519
3520 STD_ROM_PICK(rdftauge)
STD_ROM_FN(rdftauge)3521 STD_ROM_FN(rdftauge)
3522
3523 static INT32 RdftaugeInit()
3524 {
3525 return CommonInit(DECRYPT_SEI252, rdft_build_flash, 0x00298d0, 0x203f6e);
3526 }
3527
3528 struct BurnDriver BurnDrvRdftauge = {
3529 "rdftauge", "rdft", NULL, NULL, "1996",
3530 "Raiden Fighters (Evaluation Software For Show, Germany)\0", NULL, "Seibu Kaihatsu (Tuning license)", "SPI",
3531 NULL, NULL, NULL, NULL,
3532 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
3533 NULL, rdftaugeRomInfo, rdftaugeRomName, NULL, NULL, NULL, NULL, Spi_3buttonInputInfo, Spi_3buttonDIPInfo,
3534 RdftaugeInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
3535 240, 320, 3, 4
3536 };
3537
3538
3539 // Raiden Fighters (Austria)
3540
3541 static struct BurnRomInfo rdftaRomDesc[] = {
3542 { "seibu_1.u0211", 0x080000, 0xc3bb2e58, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
3543 { "seibu_2.u0212", 0x080000, 0x58ccb10c, 1 | BRF_PRG | BRF_ESS }, // 1
3544 { "seibu_3.u0210", 0x080000, 0x47fc3c96, 1 | BRF_PRG | BRF_ESS }, // 2
3545 { "seibu_4.u029", 0x080000, 0x271bdd4b, 1 | BRF_PRG | BRF_ESS }, // 3
3546
3547 { "seibu_6.u0424", 0x010000, 0x6ac64968, 1 | BRF_GRA }, // 4 Characters
3548 { "seibu_5.u0423", 0x010000, 0x8f8d4e14, 1 | BRF_GRA }, // 5
3549 { "seibu_7.u048", 0x010000, 0x4d87e1ea, 1 | BRF_GRA }, // 6
3550
3551 { "gun_dogs_bg1-d.u0415", 0x200000, 0x6a68054c, 2 | BRF_GRA }, // 7 Background Tiles
3552 { "gun_dogs_bg1-p.u0410", 0x100000, 0x3400794a, 2 | BRF_GRA }, // 8
3553 { "gun_dogs_bg2-d.u0424", 0x200000, 0x61cd2991, 2 | BRF_GRA }, // 9
3554 { "gun_dogs_bg2-p.u049", 0x100000, 0x502d5799, 2 | BRF_GRA }, // 10
3555
3556 { "gun_dogs_obj-1.u0322", 0x400000, 0x59d86c99, 3 | BRF_GRA }, // 11 Sprites
3557 { "gun_dogs_obj-2.u0324", 0x400000, 0x1ceb0b6f, 3 | BRF_GRA }, // 12
3558 { "gun_dogs_obj-3.u0323", 0x400000, 0x36e93234, 3 | BRF_GRA }, // 13
3559
3560 { "gun_dogs_pcm.u0217", 0x200000, 0x31253ad7, 3 | BRF_PRG | BRF_ESS }, // 14 Sample Data (Mapped to i386)
3561 { "seibu_8.u0216", 0x080000, 0xf88cb6e4, 3 | BRF_PRG | BRF_ESS }, // 15
3562
3563 { "flash0_blank_region82.u1053", 0x100000, 0x4f463a87, 0 | BRF_SND }, // 16 Intel Flash (Samples)
3564 };
3565
3566 STD_ROM_PICK(rdfta)
STD_ROM_FN(rdfta)3567 STD_ROM_FN(rdfta)
3568
3569 static INT32 RdftaInit()
3570 {
3571 return CommonInit(DECRYPT_SEI252, rdft_build_flash, 0x00298d0, 0x203f46);
3572 }
3573
3574 struct BurnDriver BurnDrvRdfta = {
3575 "rdfta", "rdft", NULL, NULL, "1996",
3576 "Raiden Fighters (Austria)\0", NULL, "Seibu Kaihatsu", "SPI",
3577 NULL, NULL, NULL, NULL,
3578 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
3579 NULL, rdftaRomInfo, rdftaRomName, NULL, NULL, NULL, NULL, Spi_3buttonInputInfo, Spi_3buttonDIPInfo,
3580 RdftaInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
3581 240, 320, 3, 4
3582 };
3583
3584
3585 // Raiden Fighters (Italy)
3586
3587 static struct BurnRomInfo rdftitRomDesc[] = {
3588 { "seibu_1.u0211", 0x080000, 0xde0c3e3c, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
3589 { "seibu_2.u0212", 0x080000, 0x58ccb10c, 1 | BRF_PRG | BRF_ESS }, // 1
3590 { "seibu_3.u0210", 0x080000, 0x47fc3c96, 1 | BRF_PRG | BRF_ESS }, // 2
3591 { "seibu_4.u029", 0x080000, 0x271bdd4b, 1 | BRF_PRG | BRF_ESS }, // 3
3592
3593 { "seibu_6.u0424", 0x010000, 0x6ac64968, 1 | BRF_GRA }, // 4 Characters
3594 { "seibu_5.u0423", 0x010000, 0x8f8d4e14, 1 | BRF_GRA }, // 5
3595 { "seibu_7.u048", 0x010000, 0x4d87e1ea, 1 | BRF_GRA }, // 6
3596
3597 { "gun_dogs_bg1-d.u0415", 0x200000, 0x6a68054c, 2 | BRF_GRA }, // 7 Background Tiles
3598 { "gun_dogs_bg1-p.u0410", 0x100000, 0x3400794a, 2 | BRF_GRA }, // 8
3599 { "gun_dogs_bg2-d.u0424", 0x200000, 0x61cd2991, 2 | BRF_GRA }, // 9
3600 { "gun_dogs_bg2-p.u049", 0x100000, 0x502d5799, 2 | BRF_GRA }, // 10
3601
3602 { "gun_dogs_obj-1.u0322", 0x400000, 0x59d86c99, 3 | BRF_GRA }, // 11 Sprites
3603 { "gun_dogs_obj-2.u0324", 0x400000, 0x1ceb0b6f, 3 | BRF_GRA }, // 12
3604 { "gun_dogs_obj-3.u0323", 0x400000, 0x36e93234, 3 | BRF_GRA }, // 13
3605
3606 { "gun_dogs_pcm.u0217", 0x200000, 0x31253ad7, 3 | BRF_PRG | BRF_ESS }, // 14 Sample Data (Mapped to i386)
3607 { "seibu_8.u0216", 0x080000, 0xf88cb6e4, 3 | BRF_PRG | BRF_ESS }, // 15
3608
3609 { "flash0_blank_region92.u1053", 0x100000, 0x204d82d0, 0 | BRF_SND }, // 16 Intel Flash (Samples)
3610 };
3611
3612 STD_ROM_PICK(rdftit)
STD_ROM_FN(rdftit)3613 STD_ROM_FN(rdftit)
3614
3615 static INT32 RdftitInit()
3616 {
3617 return CommonInit(DECRYPT_SEI252, rdft_build_flash, 0x00298d0, 0x203f46);
3618 }
3619
3620 struct BurnDriver BurnDrvRdftit = {
3621 "rdftit", "rdft", NULL, NULL, "1996",
3622 "Raiden Fighters (Italy)\0", NULL, "Seibu Kaihatsu", "SPI",
3623 NULL, NULL, NULL, NULL,
3624 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
3625 NULL, rdftitRomInfo, rdftitRomName, NULL, NULL, NULL, NULL, Spi_3buttonInputInfo, Spi_3buttonDIPInfo,
3626 RdftitInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
3627 240, 320, 3, 4
3628 };
3629
3630
3631 // Raiden Fighters (Great Britain)
3632
3633 static struct BurnRomInfo rdftgbRomDesc[] = {
3634 { "seibu_1.u0211", 0x080000, 0x2403035f, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
3635 { "seibu_2.u0212", 0x080000, 0x58ccb10c, 1 | BRF_PRG | BRF_ESS }, // 1
3636 { "seibu_3.u0210", 0x080000, 0x47fc3c96, 1 | BRF_PRG | BRF_ESS }, // 2
3637 { "seibu_4.u029", 0x080000, 0x271bdd4b, 1 | BRF_PRG | BRF_ESS }, // 3
3638
3639 { "seibu_6.u0424", 0x010000, 0x6ac64968, 1 | BRF_GRA }, // 4 Characters
3640 { "seibu_5.u0423", 0x010000, 0x8f8d4e14, 1 | BRF_GRA }, // 5
3641 { "seibu_7.u048", 0x010000, 0x4d87e1ea, 1 | BRF_GRA }, // 6
3642
3643 { "gun_dogs_bg1-d.u0415", 0x200000, 0x6a68054c, 2 | BRF_GRA }, // 7 Background Tiles
3644 { "gun_dogs_bg1-p.u0410", 0x100000, 0x3400794a, 2 | BRF_GRA }, // 8
3645 { "gun_dogs_bg2-d.u0424", 0x200000, 0x61cd2991, 2 | BRF_GRA }, // 9
3646 { "gun_dogs_bg2-p.u049", 0x100000, 0x502d5799, 2 | BRF_GRA }, // 10
3647
3648 { "gun_dogs_obj-1.u0322", 0x400000, 0x59d86c99, 3 | BRF_GRA }, // 11 Sprites
3649 { "gun_dogs_obj-2.u0324", 0x400000, 0x1ceb0b6f, 3 | BRF_GRA }, // 12
3650 { "gun_dogs_obj-3.u0323", 0x400000, 0x36e93234, 3 | BRF_GRA }, // 13
3651
3652 { "gun_dogs_pcm.u0217", 0x200000, 0x31253ad7, 3 | BRF_PRG | BRF_ESS }, // 14 Sample Data (Mapped to i386)
3653 { "seibu_8.u0216", 0x080000, 0xf88cb6e4, 3 | BRF_PRG | BRF_ESS }, // 15
3654
3655 { "flash0_blank_region8c.u1053", 0x100000, 0xb836dc5b, 0 | BRF_SND }, // 16 Intel Flash (Samples)
3656 };
3657
3658 STD_ROM_PICK(rdftgb)
STD_ROM_FN(rdftgb)3659 STD_ROM_FN(rdftgb)
3660
3661 static INT32 RdftgbInit()
3662 {
3663 return CommonInit(DECRYPT_SEI252, rdft_build_flash, 0x00298d0, 0x203f46); // 0x203f69?
3664 }
3665
3666 struct BurnDriver BurnDrvRdftgb = {
3667 "rdftgb", "rdft", NULL, NULL, "1996",
3668 "Raiden Fighters (Great Britain)\0", NULL, "Seibu Kaihatsu", "SPI",
3669 NULL, NULL, NULL, NULL,
3670 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
3671 NULL, rdftgbRomInfo, rdftgbRomName, NULL, NULL, NULL, NULL, Spi_3buttonInputInfo, Spi_3buttonDIPInfo,
3672 RdftgbInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
3673 240, 320, 3, 4
3674 };
3675
3676
3677 // Raiden Fighters (Greece)
3678
3679 static struct BurnRomInfo rdftgrRomDesc[] = {
3680 { "seibu_1.u0211", 0x080000, 0xca0d6273, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
3681 { "seibu_2.u0212", 0x080000, 0x58ccb10c, 1 | BRF_PRG | BRF_ESS }, // 1
3682 { "seibu_3.u0210", 0x080000, 0x47fc3c96, 1 | BRF_PRG | BRF_ESS }, // 2
3683 { "seibu_4.u029", 0x080000, 0x271bdd4b, 1 | BRF_PRG | BRF_ESS }, // 3
3684
3685 { "seibu_6.u0424", 0x010000, 0x6ac64968, 1 | BRF_GRA }, // 4 Characters
3686 { "seibu_5.u0423", 0x010000, 0x8f8d4e14, 1 | BRF_GRA }, // 5
3687 { "seibu_7.u048", 0x010000, 0x4d87e1ea, 1 | BRF_GRA }, // 6
3688
3689 { "gun_dogs_bg1-d.u0415", 0x200000, 0x6a68054c, 2 | BRF_GRA }, // 7 Background Tiles
3690 { "gun_dogs_bg1-p.u0410", 0x100000, 0x3400794a, 2 | BRF_GRA }, // 8
3691 { "gun_dogs_bg2-d.u0424", 0x200000, 0x61cd2991, 2 | BRF_GRA }, // 9
3692 { "gun_dogs_bg2-p.u049", 0x100000, 0x502d5799, 2 | BRF_GRA }, // 10
3693
3694 { "gun_dogs_obj-1.u0322", 0x400000, 0x59d86c99, 3 | BRF_GRA }, // 11 Sprites
3695 { "gun_dogs_obj-2.u0324", 0x400000, 0x1ceb0b6f, 3 | BRF_GRA }, // 12
3696 { "gun_dogs_obj-3.u0323", 0x400000, 0x36e93234, 3 | BRF_GRA }, // 13
3697
3698 { "gun_dogs_pcm.u0217", 0x200000, 0x31253ad7, 3 | BRF_PRG | BRF_ESS }, // 14 Sample Data (Mapped to i386)
3699 { "seibu_8.u0216", 0x080000, 0xf88cb6e4, 3 | BRF_PRG | BRF_ESS }, // 15
3700
3701 { "flash0_blank_region8e.u1053", 0x100000, 0x15dd4929, 0 | BRF_SND }, // 16 Intel Flash (Samples)
3702 };
3703
3704 STD_ROM_PICK(rdftgr)
STD_ROM_FN(rdftgr)3705 STD_ROM_FN(rdftgr)
3706
3707 static INT32 RdftgrInit()
3708 {
3709 return CommonInit(DECRYPT_SEI252, rdft_build_flash, 0x00298d0, 0x203f46); // 0x203f69?
3710 }
3711
3712 struct BurnDriver BurnDrvRdftgr = {
3713 "rdftgr", "rdft", NULL, NULL, "1996",
3714 "Raiden Fighters (Greece)\0", NULL, "Seibu Kaihatsu", "SPI",
3715 NULL, NULL, NULL, NULL,
3716 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
3717 NULL, rdftgrRomInfo, rdftgrRomName, NULL, NULL, NULL, NULL, Spi_3buttonInputInfo, Spi_3buttonDIPInfo,
3718 RdftgrInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
3719 240, 320, 3, 4
3720 };
3721
3722
3723 // Raiden Fighters (Japan, newer)
3724
3725 static struct BurnRomInfo rdftjbRomDesc[] = {
3726 { "seibu_1.u0211", 0x080000, 0xb70afcc2, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
3727 { "raiden-f_prg2.u0212", 0x080000, 0x58ccb10c, 1 | BRF_PRG | BRF_ESS }, // 1
3728 { "raiden-f_prg34.u0219", 0x100000, 0x63f01d17, 1 | BRF_PRG | BRF_ESS }, // 2
3729
3730 { "raiden-f_fix.u0425", 0x020000, 0x2be2936b, 1 | BRF_GRA }, // 3 Characters
3731 { "seibu_7.u048", 0x010000, 0x4d87e1ea, 1 | BRF_GRA }, // 4
3732
3733 { "gun_dogs_bg1-d.u0415", 0x200000, 0x6a68054c, 2 | BRF_GRA }, // 5 Background Tiles
3734 { "gun_dogs_bg1-p.u0410", 0x100000, 0x3400794a, 2 | BRF_GRA }, // 6
3735 { "gun_dogs_bg2-d.u0424", 0x200000, 0x61cd2991, 2 | BRF_GRA }, // 7
3736 { "gun_dogs_bg2-p.u049", 0x100000, 0x502d5799, 2 | BRF_GRA }, // 8
3737
3738 { "gun_dogs_obj-1.u0322", 0x400000, 0x59d86c99, 3 | BRF_GRA }, // 9 Sprites
3739 { "gun_dogs_obj-2.u0324", 0x400000, 0x1ceb0b6f, 3 | BRF_GRA }, // 10
3740 { "gun_dogs_obj-3.u0323", 0x400000, 0x36e93234, 3 | BRF_GRA }, // 11
3741
3742 { "raiden-f_pcm2.u0217", 0x200000, 0x3f8d4a48, 3 | BRF_PRG | BRF_ESS }, // 12 Sample Data (Mapped to i386)
3743
3744 { "flash0_blank_region01.u1053", 0x100000, 0x7ae7ab76, 0 | BRF_SND }, // 13 Intel Flash (Samples)
3745 };
3746
3747 STD_ROM_PICK(rdftjb)
STD_ROM_FN(rdftjb)3748 STD_ROM_FN(rdftjb)
3749
3750 static INT32 RdftjbInit()
3751 {
3752 return CommonInit(DECRYPT_SEI252, rdft_build_flash, 0x298d0, 0x203f46); // 0x203f69?
3753 }
3754
3755 struct BurnDriver BurnDrvRdftjb = {
3756 "rdftjb", "rdft", NULL, NULL, "1996",
3757 "Raiden Fighters (Japan, newer)\0", NULL, "Seibu Kaihatsu", "SPI",
3758 NULL, NULL, NULL, NULL,
3759 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
3760 NULL, rdftjbRomInfo, rdftjbRomName, NULL, NULL, NULL, NULL, Spi_3buttonInputInfo, Spi_3buttonDIPInfo,
3761 RdftjbInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
3762 240, 320, 3, 4
3763 };
3764
3765
3766 // Raiden Fighters (US, newer)
3767
3768 static struct BurnRomInfo rdftuaRomDesc[] = {
3769 { "seibu_1.u0211", 0x080000, 0xddbadc30, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
3770 { "raiden-f_prg2.u0212", 0x080000, 0x58ccb10c, 1 | BRF_PRG | BRF_ESS }, // 1
3771 { "raiden-f_prg34.u0219", 0x100000, 0x63f01d17, 1 | BRF_PRG | BRF_ESS }, // 2
3772
3773 { "raiden-f_fix.u0425", 0x020000, 0x2be2936b, 1 | BRF_GRA }, // 3 Characters
3774 { "seibu_7.u048", 0x010000, 0x4d87e1ea, 1 | BRF_GRA }, // 4
3775
3776 { "gun_dogs_bg1-d.u0415", 0x200000, 0x6a68054c, 2 | BRF_GRA }, // 5 Background Tiles
3777 { "gun_dogs_bg1-p.u0410", 0x100000, 0x3400794a, 2 | BRF_GRA }, // 6
3778 { "gun_dogs_bg2-d.u0424", 0x200000, 0x61cd2991, 2 | BRF_GRA }, // 7
3779 { "gun_dogs_bg2-p.u049", 0x100000, 0x502d5799, 2 | BRF_GRA }, // 8
3780
3781 { "gun_dogs_obj-1.u0322", 0x400000, 0x59d86c99, 3 | BRF_GRA }, // 9 Sprites
3782 { "gun_dogs_obj-2.u0324", 0x400000, 0x1ceb0b6f, 3 | BRF_GRA }, // 10
3783 { "gun_dogs_obj-3.u0323", 0x400000, 0x36e93234, 3 | BRF_GRA }, // 11
3784
3785 { "raiden-f_pcm2.u0217", 0x200000, 0x3f8d4a48, 3 | BRF_PRG | BRF_ESS }, // 12 Sample Data (Mapped to i386)
3786
3787 { "flash0_blank_region10.u1053", 0x100000, 0x4319d998, 0 | BRF_SND }, // 13 Intel Flash (Samples)
3788 };
3789
3790 STD_ROM_PICK(rdftua)
STD_ROM_FN(rdftua)3791 STD_ROM_FN(rdftua)
3792
3793 static INT32 RdftuaInit()
3794 {
3795 return CommonInit(DECRYPT_SEI252, rdft_build_flash, 0x298d0, 0x203f46); // 0x203f69?
3796 }
3797
3798 struct BurnDriver BurnDrvRdftua = {
3799 "rdftua", "rdft", NULL, NULL, "1996",
3800 "Raiden Fighters (US, newer)\0", NULL, "Seibu Kaihatsu (Fabtek license)", "SPI",
3801 NULL, NULL, NULL, NULL,
3802 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
3803 NULL, rdftuaRomInfo, rdftuaRomName, NULL, NULL, NULL, NULL, Spi_3buttonInputInfo, Spi_3buttonDIPInfo,
3804 RdftuaInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
3805 240, 320, 3, 4
3806 };
3807
3808
3809 // Raiden Fighters (Korea)
3810
3811 static struct BurnRomInfo rdftadiRomDesc[] = {
3812 { "seibu_1.u0211", 0x080000, 0xfc0e2885, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
3813 { "raiden-f_prg2.u0212", 0x080000, 0x58ccb10c, 1 | BRF_PRG | BRF_ESS }, // 1
3814 { "raiden-f_prg34.u0219", 0x100000, 0x63f01d17, 1 | BRF_PRG | BRF_ESS }, // 2
3815
3816 { "raiden-f_fix.u0425", 0x020000, 0x2be2936b, 1 | BRF_GRA }, // 3 Characters
3817 { "seibu_7.u048", 0x010000, 0x4d87e1ea, 1 | BRF_GRA }, // 4
3818
3819 { "gun_dogs_bg1-d.u0415", 0x200000, 0x6a68054c, 2 | BRF_GRA }, // 5 Background Tiles
3820 { "gun_dogs_bg1-p.u0410", 0x100000, 0x3400794a, 2 | BRF_GRA }, // 6
3821 { "gun_dogs_bg2-d.u0424", 0x200000, 0x61cd2991, 2 | BRF_GRA }, // 7
3822 { "gun_dogs_bg2-p.u049", 0x100000, 0x502d5799, 2 | BRF_GRA }, // 8
3823
3824 { "gun_dogs_obj-1.u0322", 0x400000, 0x59d86c99, 3 | BRF_GRA }, // 9 Sprites
3825 { "gun_dogs_obj-2.u0324", 0x400000, 0x1ceb0b6f, 3 | BRF_GRA }, // 10
3826 { "gun_dogs_obj-3.u0323", 0x400000, 0x36e93234, 3 | BRF_GRA }, // 11
3827
3828 { "raiden-f_pcm2.u0217", 0x200000, 0x3f8d4a48, 3 | BRF_PRG | BRF_ESS }, // 12 Sample Data (Mapped to i386)
3829
3830 { "flash0_blank_region24.u1053", 0x100000, 0x72a33dc4, 0 | BRF_SND }, // 13 Intel Flash (Samples)
3831 };
3832
3833 STD_ROM_PICK(rdftadi)
STD_ROM_FN(rdftadi)3834 STD_ROM_FN(rdftadi)
3835
3836 static INT32 RdftadiInit()
3837 {
3838 return CommonInit(DECRYPT_SEI252, rdft_build_flash, 0x298d0, 0x203f46); // 0x203f69?
3839 }
3840
3841 struct BurnDriver BurnDrvRdftadi = {
3842 "rdftadi", "rdft", NULL, NULL, "1996",
3843 "Raiden Fighters (Korea)\0", NULL, "Seibu Kaihatsu (Dream Island license)", "SPI",
3844 NULL, NULL, NULL, NULL,
3845 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
3846 NULL, rdftadiRomInfo, rdftadiRomName, NULL, NULL, NULL, NULL, Spi_3buttonInputInfo, Spi_3buttonDIPInfo,
3847 RdftadiInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
3848 240, 320, 3, 4
3849 };
3850
3851
3852 // Raiden Fighters (Hong Kong)
3853
3854 static struct BurnRomInfo rdftamRomDesc[] = {
3855 { "seibu_1.u0211", 0x080000, 0x156d8db0, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
3856 { "raiden-f_prg2.u0212", 0x080000, 0x58ccb10c, 1 | BRF_PRG | BRF_ESS }, // 1
3857 { "raiden-f_prg34.u0219", 0x100000, 0x63f01d17, 1 | BRF_PRG | BRF_ESS }, // 2
3858
3859 { "raiden-f_fix.u0425", 0x020000, 0x2be2936b, 1 | BRF_GRA }, // 3 Characters
3860 { "seibu_7.u048", 0x010000, 0x4d87e1ea, 1 | BRF_GRA }, // 4
3861
3862 { "gun_dogs_bg1-d.u0415", 0x200000, 0x6a68054c, 2 | BRF_GRA }, // 5 Background Tiles
3863 { "gun_dogs_bg1-p.u0410", 0x100000, 0x3400794a, 2 | BRF_GRA }, // 6
3864 { "gun_dogs_bg2-d.u0424", 0x200000, 0x61cd2991, 2 | BRF_GRA }, // 7
3865 { "gun_dogs_bg2-p.u049", 0x100000, 0x502d5799, 2 | BRF_GRA }, // 8
3866
3867 { "gun_dogs_obj-1.u0322", 0x400000, 0x59d86c99, 3 | BRF_GRA }, // 9 Sprites
3868 { "gun_dogs_obj-2.u0324", 0x400000, 0x1ceb0b6f, 3 | BRF_GRA }, // 10
3869 { "gun_dogs_obj-3.u0323", 0x400000, 0x36e93234, 3 | BRF_GRA }, // 11
3870
3871 { "raiden-f_pcm2.u0217", 0x200000, 0x3f8d4a48, 3 | BRF_PRG | BRF_ESS }, // 12 Sample Data (Mapped to i386)
3872
3873 { "flash0_blank_region22.u1053", 0x100000, 0x5fee8413, 0 | BRF_SND }, // 13 Intel Flash (Samples)
3874 };
3875
3876 STD_ROM_PICK(rdftam)
STD_ROM_FN(rdftam)3877 STD_ROM_FN(rdftam)
3878
3879 static INT32 RdftamInit()
3880 {
3881 return CommonInit(DECRYPT_SEI252, rdft_build_flash, 0x298d0, 0x203f46);
3882 }
3883
3884 struct BurnDriver BurnDrvRdftam = {
3885 "rdftam", "rdft", NULL, NULL, "1996",
3886 "Raiden Fighters (Hong Kong)\0", NULL, "Seibu Kaihatsu (Metrotainment license)", "SPI",
3887 NULL, NULL, NULL, NULL,
3888 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
3889 NULL, rdftamRomInfo, rdftamRomName, NULL, NULL, NULL, NULL, Spi_3buttonInputInfo, Spi_3buttonDIPInfo,
3890 RdftamInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
3891 240, 320, 3, 4
3892 };
3893
3894
3895 // Raiden Fighters 2 - Operation Hell Dive (Germany)
3896
3897 static struct BurnRomInfo rdft2RomDesc[] = {
3898 { "prg0.tun", 0x080000, 0x3cb3fdca, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
3899 { "prg1.bin", 0x080000, 0xcab55d88, 1 | BRF_PRG | BRF_ESS }, // 1
3900 { "prg2.bin", 0x080000, 0x83758b0e, 1 | BRF_PRG | BRF_ESS }, // 2
3901 { "prg3.bin", 0x080000, 0x084fb5e4, 1 | BRF_PRG | BRF_ESS }, // 3
3902
3903 { "fix0.u0524", 0x010000, 0x6fdf4cf6, 1 | BRF_GRA }, // 4 Characters
3904 { "fix1.u0518", 0x010000, 0x69b7899b, 1 | BRF_GRA }, // 5
3905 { "fixp.u0514", 0x010000, 0x99a5fece, 1 | BRF_GRA }, // 6
3906
3907 { "bg-1d.u0535", 0x400000, 0x6143f576, 2 | BRF_GRA }, // 7 Background Tiles
3908 { "bg-1p.u0537", 0x200000, 0x55e64ef7, 2 | BRF_GRA }, // 8
3909 { "bg-2d.u0536", 0x400000, 0xc607a444, 2 | BRF_GRA }, // 9
3910 { "bg-2p.u0538", 0x200000, 0xf0830248, 2 | BRF_GRA }, // 10
3911
3912 { "obj3.u0434", 0x400000, 0xe08f42dc, 3 | BRF_GRA }, // 11 Sprites
3913 { "obj3b.u0433", 0x200000, 0x1b6a523c, 3 | BRF_GRA }, // 12
3914 { "obj2.u0431", 0x400000, 0x7aeadd8e, 3 | BRF_GRA }, // 13
3915 { "obj2b.u0432", 0x200000, 0x5d790a5d, 3 | BRF_GRA }, // 14
3916 { "obj1.u0429", 0x400000, 0xc2c50f02, 3 | BRF_GRA }, // 15
3917 { "obj1b.u0430", 0x200000, 0x5259321f, 3 | BRF_GRA }, // 16
3918
3919 { "pcm.u0217", 0x200000, 0x2edc30b5, 3 | BRF_PRG | BRF_ESS }, // 17 Sample Data (Mapped to i386)
3920 { "sound1.u0222", 0x080000, 0xb7bd3703, 3 | BRF_PRG | BRF_ESS }, // 18
3921
3922 { "flash0_blank_region80.u1053", 0x100000, 0xe2adaff5, 0 | BRF_SND }, // 19 Intel Flash (Samples)
3923 };
3924
3925 STD_ROM_PICK(rdft2)
3926 STD_ROM_FN(rdft2)
3927
3928 static const UINT8 Rdft2DefaultNVRAM[32] = {
3929 0x65, 0x4A, 0x4A, 0x37, 0x20, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x01, 0x0B, 0x00, 0x00, 0x00,
3930 0x01, 0x03, 0x04, 0x02, 0x00, 0x00, 0x5B, 0x69, 0x00, 0x00, 0x01, 0x01, 0x00, 0x01, 0x34, 0x02
3931 };
3932
Rdft2Init()3933 static INT32 Rdft2Init()
3934 {
3935 DefaultNVRAM = Rdft2DefaultNVRAM;
3936
3937 return CommonInit(DECRYPT_RISE10, NULL, 0x00282ac, 0x0204372);
3938 }
3939
3940 struct BurnDriver BurnDrvRdft2 = {
3941 "rdft2", NULL, NULL, NULL, "1997",
3942 "Raiden Fighters 2 - Operation Hell Dive (Germany)\0", NULL, "Seibu Kaihatsu (Tuning license)", "SPI",
3943 NULL, NULL, NULL, NULL,
3944 BDF_GAME_WORKING | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
3945 NULL, rdft2RomInfo, rdft2RomName, NULL, NULL, NULL, NULL, Spi_2buttonInputInfo, Spi_2buttonDIPInfo,
3946 Rdft2Init, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
3947 240, 320, 3, 4
3948 };
3949
3950
3951 // Raiden Fighters 2 - Operation Hell Dive (US)
3952
3953 static struct BurnRomInfo rdft2uRomDesc[] = {
3954 { "1.bin", 0x080000, 0xb7d6c866, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
3955 { "2.bin", 0x080000, 0xff7747c5, 1 | BRF_PRG | BRF_ESS }, // 1
3956 { "3.bin", 0x080000, 0x86e3d1a8, 1 | BRF_PRG | BRF_ESS }, // 2
3957 { "4.bin", 0x080000, 0x2e409a76, 1 | BRF_PRG | BRF_ESS }, // 3
3958
3959 { "fix0.u0524", 0x010000, 0x6fdf4cf6, 1 | BRF_GRA }, // 4 Characters
3960 { "fix1.u0518", 0x010000, 0x69b7899b, 1 | BRF_GRA }, // 5
3961 { "fixp.u0514", 0x010000, 0x99a5fece, 1 | BRF_GRA }, // 6
3962
3963 { "bg-1d.u0535", 0x400000, 0x6143f576, 2 | BRF_GRA }, // 7 Background Tiles
3964 { "bg-1p.u0537", 0x200000, 0x55e64ef7, 2 | BRF_GRA }, // 8
3965 { "bg-2d.u0536", 0x400000, 0xc607a444, 2 | BRF_GRA }, // 9
3966 { "bg-2p.u0538", 0x200000, 0xf0830248, 2 | BRF_GRA }, // 10
3967
3968 { "obj3.u0434", 0x400000, 0xe08f42dc, 3 | BRF_GRA }, // 11 Sprites
3969 { "obj3b.u0433", 0x200000, 0x1b6a523c, 3 | BRF_GRA }, // 12
3970 { "obj2.u0431", 0x400000, 0x7aeadd8e, 3 | BRF_GRA }, // 13
3971 { "obj2b.u0432", 0x200000, 0x5d790a5d, 3 | BRF_GRA }, // 14
3972 { "obj1.u0429", 0x400000, 0xc2c50f02, 3 | BRF_GRA }, // 15
3973 { "obj1b.u0430", 0x200000, 0x5259321f, 3 | BRF_GRA }, // 16
3974
3975 { "pcm.u0217", 0x200000, 0x2edc30b5, 3 | BRF_PRG | BRF_ESS }, // 17 Sample Data (Mapped to i386)
3976 { "sound1.u0222", 0x080000, 0xb7bd3703, 3 | BRF_PRG | BRF_ESS }, // 18
3977
3978 { "flash0_blank_region10.u1053", 0x100000, 0x4319d998, 0 | BRF_SND }, // 19 Intel Flash (Samples)
3979 };
3980
3981 STD_ROM_PICK(rdft2u)
STD_ROM_FN(rdft2u)3982 STD_ROM_FN(rdft2u)
3983
3984 static INT32 Rdft2uInit()
3985 {
3986 DefaultNVRAM = Rdft2DefaultNVRAM;
3987
3988 return CommonInit(DECRYPT_RISE10, NULL, 0x00282ac, 0x2044b6); // or 2044d9?
3989 }
3990
3991 struct BurnDriver BurnDrvRdft2u = {
3992 "rdft2u", "rdft2", NULL, NULL, "1997",
3993 "Raiden Fighters 2 - Operation Hell Dive (US)\0", NULL, "Seibu Kaihatsu (Fabtek license)", "SPI",
3994 NULL, NULL, NULL, NULL,
3995 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
3996 NULL, rdft2uRomInfo, rdft2uRomName, NULL, NULL, NULL, NULL, Spi_2buttonInputInfo, Spi_2buttonDIPInfo,
3997 Rdft2uInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
3998 240, 320, 3, 4
3999 };
4000
4001
4002 // Raiden Fighters 2 - Operation Hell Dive (Japan set 1)
4003
4004 static struct BurnRomInfo rdft2jRomDesc[] = {
4005 { "prg0.sei", 0x080000, 0xa60c4e7c, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
4006 { "prg1.bin", 0x080000, 0xcab55d88, 1 | BRF_PRG | BRF_ESS }, // 1
4007 { "prg2.bin", 0x080000, 0x83758b0e, 1 | BRF_PRG | BRF_ESS }, // 2
4008 { "prg3.bin", 0x080000, 0x084fb5e4, 1 | BRF_PRG | BRF_ESS }, // 3
4009
4010 { "fix0.u0524", 0x010000, 0x6fdf4cf6, 1 | BRF_GRA }, // 4 Characters
4011 { "fix1.u0518", 0x010000, 0x69b7899b, 1 | BRF_GRA }, // 5
4012 { "fixp.u0514", 0x010000, 0x99a5fece, 1 | BRF_GRA }, // 6
4013
4014 { "bg-1d.u0535", 0x400000, 0x6143f576, 2 | BRF_GRA }, // 7 Background Tiles
4015 { "bg-1p.u0537", 0x200000, 0x55e64ef7, 2 | BRF_GRA }, // 8
4016 { "bg-2d.u0536", 0x400000, 0xc607a444, 2 | BRF_GRA }, // 9
4017 { "bg-2p.u0538", 0x200000, 0xf0830248, 2 | BRF_GRA }, // 10
4018
4019 { "obj3.u0434", 0x400000, 0xe08f42dc, 3 | BRF_GRA }, // 11 Sprites
4020 { "obj3b.u0433", 0x200000, 0x1b6a523c, 3 | BRF_GRA }, // 12
4021 { "obj2.u0431", 0x400000, 0x7aeadd8e, 3 | BRF_GRA }, // 13
4022 { "obj2b.u0432", 0x200000, 0x5d790a5d, 3 | BRF_GRA }, // 14
4023 { "obj1.u0429", 0x400000, 0xc2c50f02, 3 | BRF_GRA }, // 15
4024 { "obj1b.u0430", 0x200000, 0x5259321f, 3 | BRF_GRA }, // 16
4025
4026 { "pcm.u0217", 0x200000, 0x2edc30b5, 3 | BRF_PRG | BRF_ESS }, // 17 Sample Data (Mapped to i386)
4027 { "sound1.u0222", 0x080000, 0xb7bd3703, 3 | BRF_PRG | BRF_ESS }, // 18
4028
4029 { "flash0_blank_region01.u1053", 0x100000, 0x7ae7ab76, 0 | BRF_SND }, // 19 Intel Flash (Samples)
4030 };
4031
4032 STD_ROM_PICK(rdft2j)
4033 STD_ROM_FN(rdft2j)
4034
4035 struct BurnDriver BurnDrvRdft2j = {
4036 "rdft2j", "rdft2", NULL, NULL, "1997",
4037 "Raiden Fighters 2 - Operation Hell Dive (Japan set 1)\0", NULL, "Seibu Kaihatsu", "SPI",
4038 NULL, NULL, NULL, NULL,
4039 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
4040 NULL, rdft2jRomInfo, rdft2jRomName, NULL, NULL, NULL, NULL, Spi_2buttonInputInfo, Spi_2buttonDIPInfo,
4041 Rdft2Init, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
4042 240, 320, 3, 4
4043 };
4044
4045
4046 // Raiden Fighters 2 - Operation Hell Dive (Japan set 2)
4047
4048 static struct BurnRomInfo rdft2jaRomDesc[] = {
4049 { "rf2.1", 0x080000, 0x391d5057, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
4050 { "rf2_2.bin", 0x080000, 0xec73a767, 1 | BRF_PRG | BRF_ESS }, // 1
4051 { "rf2_3.bin", 0x080000, 0xe66243b2, 1 | BRF_PRG | BRF_ESS }, // 2
4052 { "rf2_4.bin", 0x080000, 0x92b7b73e, 1 | BRF_PRG | BRF_ESS }, // 3
4053
4054 { "rf2_5.bin", 0x010000, 0x377cac2f, 1 | BRF_GRA }, // 4 Characters
4055 { "rf2_6.bin", 0x010000, 0x42bd5372, 1 | BRF_GRA }, // 5
4056 { "rf2_7.bin", 0x010000, 0x1efaac7e, 1 | BRF_GRA }, // 6
4057
4058 { "bg-1d.u0535", 0x400000, 0x6143f576, 2 | BRF_GRA }, // 7 Background Tiles
4059 { "bg-1p.u0537", 0x200000, 0x55e64ef7, 2 | BRF_GRA }, // 8
4060 { "bg-2d.u0536", 0x400000, 0xc607a444, 2 | BRF_GRA }, // 9
4061 { "bg-2p.u0538", 0x200000, 0xf0830248, 2 | BRF_GRA }, // 10
4062
4063 { "obj3.u0434", 0x400000, 0xe08f42dc, 3 | BRF_GRA }, // 11 Sprites
4064 { "obj3b.u0433", 0x200000, 0x1b6a523c, 3 | BRF_GRA }, // 12
4065 { "obj2.u0431", 0x400000, 0x7aeadd8e, 3 | BRF_GRA }, // 13
4066 { "obj2b.u0432", 0x200000, 0x5d790a5d, 3 | BRF_GRA }, // 14
4067 { "obj1.u0429", 0x400000, 0xc2c50f02, 3 | BRF_GRA }, // 15
4068 { "obj1b.u0430", 0x200000, 0x5259321f, 3 | BRF_GRA }, // 16
4069
4070 { "pcm.u0217", 0x200000, 0x2edc30b5, 3 | BRF_PRG | BRF_ESS }, // 17 Sample Data (Mapped to i386)
4071 { "sound1.u0222", 0x080000, 0xb7bd3703, 3 | BRF_PRG | BRF_ESS }, // 18
4072
4073 { "flash0_blank_region01.u1053", 0x100000, 0x7ae7ab76, 0 | BRF_SND }, // 19 Intel Flash (Samples)
4074 };
4075
4076 STD_ROM_PICK(rdft2ja)
4077 STD_ROM_FN(rdft2ja)
4078
4079 struct BurnDriver BurnDrvRdft2ja = {
4080 "rdft2ja", "rdft2", NULL, NULL, "1997",
4081 "Raiden Fighters 2 - Operation Hell Dive (Japan set 2)\0", NULL, "Seibu Kaihatsu", "SPI",
4082 NULL, NULL, NULL, NULL,
4083 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
4084 NULL, rdft2jaRomInfo, rdft2jaRomName, NULL, NULL, NULL, NULL, Spi_2buttonInputInfo, Spi_2buttonDIPInfo,
4085 Rdft2Init, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
4086 240, 320, 3, 4
4087 };
4088
4089
4090 // Raiden Fighters 2 - Operation Hell Dive (Japan set 3)
4091
4092 static struct BurnRomInfo rdft2jbRomDesc[] = {
4093 { "prg0.rom", 0x080000, 0xfc42cab8, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
4094 { "prg1.rom", 0x080000, 0xa0f09dc5, 1 | BRF_PRG | BRF_ESS }, // 1
4095 { "prg2.rom", 0x080000, 0x368580e0, 1 | BRF_PRG | BRF_ESS }, // 2
4096 { "prg3.rom", 0x080000, 0x7ad45c01, 1 | BRF_PRG | BRF_ESS }, // 3
4097
4098 { "rf2_5.bin", 0x010000, 0x377cac2f, 1 | BRF_GRA }, // 4 Characters
4099 { "rf2_6.bin", 0x010000, 0x42bd5372, 1 | BRF_GRA }, // 5
4100 { "rf2_7.bin", 0x010000, 0x1efaac7e, 1 | BRF_GRA }, // 6
4101
4102 { "bg-1d.u0535", 0x400000, 0x6143f576, 2 | BRF_GRA }, // 7 Background Tiles
4103 { "bg-1p.u0537", 0x200000, 0x55e64ef7, 2 | BRF_GRA }, // 8
4104 { "bg-2d.u0536", 0x400000, 0xc607a444, 2 | BRF_GRA }, // 9
4105 { "bg-2p.u0538", 0x200000, 0xf0830248, 2 | BRF_GRA }, // 10
4106
4107 { "obj3.u0434", 0x400000, 0xe08f42dc, 3 | BRF_GRA }, // 11 Sprites
4108 { "obj3b.u0433", 0x200000, 0x1b6a523c, 3 | BRF_GRA }, // 12
4109 { "obj2.u0431", 0x400000, 0x7aeadd8e, 3 | BRF_GRA }, // 13
4110 { "obj2b.u0432", 0x200000, 0x5d790a5d, 3 | BRF_GRA }, // 14
4111 { "obj1.u0429", 0x400000, 0xc2c50f02, 3 | BRF_GRA }, // 15
4112 { "obj1b.u0430", 0x200000, 0x5259321f, 3 | BRF_GRA }, // 16
4113
4114 { "pcm.u0217", 0x200000, 0x2edc30b5, 3 | BRF_PRG | BRF_ESS }, // 17 Sample Data (Mapped to i386)
4115 { "sound1.u0222", 0x080000, 0xb7bd3703, 3 | BRF_PRG | BRF_ESS }, // 18
4116
4117 { "flash0_blank_region01.u1053", 0x100000, 0x7ae7ab76, 0 | BRF_SND }, // 19 Intel Flash (Samples)
4118 };
4119
4120 STD_ROM_PICK(rdft2jb)
4121 STD_ROM_FN(rdft2jb)
4122
4123 struct BurnDriver BurnDrvRdft2jb = {
4124 "rdft2jb", "rdft2", NULL, NULL, "1997",
4125 "Raiden Fighters 2 - Operation Hell Dive (Japan set 3)\0", NULL, "Seibu Kaihatsu", "SPI",
4126 NULL, NULL, NULL, NULL,
4127 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
4128 NULL, rdft2jbRomInfo, rdft2jbRomName, NULL, NULL, NULL, NULL, Spi_2buttonInputInfo, Spi_2buttonDIPInfo,
4129 Rdft2Init, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
4130 240, 320, 3, 4
4131 };
4132
4133
4134 // Raiden Fighters 2 - Operation Hell Dive (Japan set 4)
4135
4136 static struct BurnRomInfo rdft2jcRomDesc[] = {
4137 { "seibu_1.u0211", 0x080000, 0x36b6407c, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
4138 { "seibu_2.u0212", 0x080000, 0x65ee556e, 1 | BRF_PRG | BRF_ESS }, // 1
4139 { "seibu_3.u0221", 0x080000, 0xd2458358, 1 | BRF_PRG | BRF_ESS }, // 2
4140 { "seibu_4.u0220", 0x080000, 0x5c4412f9, 1 | BRF_PRG | BRF_ESS }, // 3
4141
4142 { "fix0.u0524", 0x010000, 0x6fdf4cf6, 1 | BRF_GRA }, // 4 Characters
4143 { "fix1.u0518", 0x010000, 0x69b7899b, 1 | BRF_GRA }, // 5
4144 { "fixp.u0514", 0x010000, 0x99a5fece, 1 | BRF_GRA }, // 6
4145
4146 { "bg-1d.u0535", 0x400000, 0x6143f576, 2 | BRF_GRA }, // 7 Background Tiles
4147 { "bg-1p.u0537", 0x200000, 0x55e64ef7, 2 | BRF_GRA }, // 8
4148 { "bg-2d.u0536", 0x400000, 0xc607a444, 2 | BRF_GRA }, // 9
4149 { "bg-2p.u0538", 0x200000, 0xf0830248, 2 | BRF_GRA }, // 10
4150
4151 { "obj3.u0434", 0x400000, 0xe08f42dc, 3 | BRF_GRA }, // 11 Sprites
4152 { "obj3b.u0433", 0x200000, 0x1b6a523c, 3 | BRF_GRA }, // 12
4153 { "obj2.u0431", 0x400000, 0x7aeadd8e, 3 | BRF_GRA }, // 13
4154 { "obj2b.u0432", 0x200000, 0x5d790a5d, 3 | BRF_GRA }, // 14
4155 { "obj1.u0429", 0x400000, 0xc2c50f02, 3 | BRF_GRA }, // 15
4156 { "obj1b.u0430", 0x200000, 0x5259321f, 3 | BRF_GRA }, // 16
4157
4158 { "pcm.u0217", 0x200000, 0x2edc30b5, 3 | BRF_PRG | BRF_ESS }, // 17 Sample Data (Mapped to i386)
4159 { "sound1.u0222", 0x080000, 0xb7bd3703, 3 | BRF_PRG | BRF_ESS }, // 18
4160
4161 { "flash0_blank_region01.u1053", 0x100000, 0x7ae7ab76, 0 | BRF_SND }, // 19 Intel Flash (Samples)
4162 };
4163
4164 STD_ROM_PICK(rdft2jc)
4165 STD_ROM_FN(rdft2jc)
4166
4167 struct BurnDriver BurnDrvRdft2jc = {
4168 "rdft2jc", "rdft2", NULL, NULL, "1997",
4169 "Raiden Fighters 2 - Operation Hell Dive (Japan set 4)\0", NULL, "Seibu Kaihatsu", "SPI",
4170 NULL, NULL, NULL, NULL,
4171 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
4172 NULL, rdft2jcRomInfo, rdft2jcRomName, NULL, NULL, NULL, NULL, Spi_2buttonInputInfo, Spi_2buttonDIPInfo,
4173 Rdft2Init, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
4174 240, 320, 3, 4
4175 };
4176
4177
4178 // Raiden Fighters 2 - Operation Hell Dive (Italy)
4179
4180 static struct BurnRomInfo rdft2itRomDesc[] = {
4181 { "seibu1.bin", 0x080000, 0x501b92a9, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
4182 { "seibu2.bin", 0x080000, 0xec73a767, 1 | BRF_PRG | BRF_ESS }, // 1
4183 { "seibu3.bin", 0x080000, 0xe66243b2, 1 | BRF_PRG | BRF_ESS }, // 2
4184 { "seibu4.bin", 0x080000, 0x92b7b73e, 1 | BRF_PRG | BRF_ESS }, // 3
4185
4186 { "seibu5.bin", 0x010000, 0x377cac2f, 1 | BRF_GRA }, // 4 Characters
4187 { "seibu6.bin", 0x010000, 0x42bd5372, 1 | BRF_GRA }, // 5
4188 { "seibu7.bin", 0x010000, 0x1efaac7e, 1 | BRF_GRA }, // 6
4189
4190 { "bg-1d.u0535", 0x400000, 0x6143f576, 2 | BRF_GRA }, // 7 Background Tiles
4191 { "bg-1p.u0537", 0x200000, 0x55e64ef7, 2 | BRF_GRA }, // 8
4192 { "bg-2d.u0536", 0x400000, 0xc607a444, 2 | BRF_GRA }, // 9
4193 { "bg-2p.u0538", 0x200000, 0xf0830248, 2 | BRF_GRA }, // 10
4194
4195 { "obj3.u0434", 0x400000, 0xe08f42dc, 3 | BRF_GRA }, // 11 Sprites
4196 { "obj3b.u0433", 0x200000, 0x1b6a523c, 3 | BRF_GRA }, // 12
4197 { "obj2.u0431", 0x400000, 0x7aeadd8e, 3 | BRF_GRA }, // 13
4198 { "obj2b.u0432", 0x200000, 0x5d790a5d, 3 | BRF_GRA }, // 14
4199 { "obj1.u0429", 0x400000, 0xc2c50f02, 3 | BRF_GRA }, // 15
4200 { "obj1b.u0430", 0x200000, 0x5259321f, 3 | BRF_GRA }, // 16
4201
4202 { "pcm.u0217", 0x200000, 0x2edc30b5, 3 | BRF_PRG | BRF_ESS }, // 17 Sample Data (Mapped to i386)
4203 { "seibu8.bin", 0x080000, 0xb7bd3703, 3 | BRF_PRG | BRF_ESS }, // 18
4204
4205 { "flash0_blank_region92.u1053", 0x100000, 0x204d82d0, 0 | BRF_SND }, // 19 Intel Flash (Samples)
4206 };
4207
4208 STD_ROM_PICK(rdft2it)
4209 STD_ROM_FN(rdft2it)
4210
4211 struct BurnDriver BurnDrvRdft2it = {
4212 "rdft2it", "rdft2", NULL, NULL, "1997",
4213 "Raiden Fighters 2 - Operation Hell Dive (Italy)\0", NULL, "Seibu Kaihatsu", "SPI",
4214 NULL, NULL, NULL, NULL,
4215 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
4216 NULL, rdft2itRomInfo, rdft2itRomName, NULL, NULL, NULL, NULL, Spi_2buttonInputInfo, Spi_2buttonDIPInfo,
4217 Rdft2Init, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
4218 240, 320, 3, 4
4219 };
4220
4221
4222 // Raiden Fighters 2 - Operation Hell Dive (Hong Kong)
4223
4224 static struct BurnRomInfo rdft2aRomDesc[] = {
4225 { "seibu__1.u0211", 0x080000, 0x046b3f0e, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
4226 { "seibu__2.u0212", 0x080000, 0xcab55d88, 1 | BRF_PRG | BRF_ESS }, // 1
4227 { "seibu__3.u0221", 0x080000, 0x83758b0e, 1 | BRF_PRG | BRF_ESS }, // 2
4228 { "seibu__4.u0220", 0x080000, 0x084fb5e4, 1 | BRF_PRG | BRF_ESS }, // 3
4229
4230 { "seibu__5.u0524", 0x010000, 0x6fdf4cf6, 1 | BRF_GRA }, // 4 Characters
4231 { "seibu__6.u0518", 0x010000, 0x69b7899b, 1 | BRF_GRA }, // 5
4232 { "seibu__7.u0514", 0x010000, 0x99a5fece, 1 | BRF_GRA }, // 6
4233
4234 { "raiden-f2bg-1d.u0535", 0x400000, 0x6143f576, 2 | BRF_GRA }, // 7 Background Tiles
4235 { "raiden-f2__bg-1p.u0537", 0x200000, 0x55e64ef7, 2 | BRF_GRA }, // 8
4236 { "raiden-f2bg-2d.u0536", 0x400000, 0xc607a444, 2 | BRF_GRA }, // 9
4237 { "raiden-f2__bg-2p.u0538", 0x200000, 0xf0830248, 2 | BRF_GRA }, // 10
4238
4239 { "raiden-f2obj-3.u0434", 0x400000, 0xe08f42dc, 3 | BRF_GRA }, // 11 Sprites
4240 { "raiden-f2obj-6.u0433", 0x200000, 0x1b6a523c, 3 | BRF_GRA }, // 12
4241 { "raiden-f2obj-2.u0431", 0x400000, 0x7aeadd8e, 3 | BRF_GRA }, // 13
4242 { "raiden-f2obj-5.u0432", 0x200000, 0x5d790a5d, 3 | BRF_GRA }, // 14
4243 { "raiden-f2obj-1.u0429", 0x400000, 0xc2c50f02, 3 | BRF_GRA }, // 15
4244 { "raiden-f2obj-4.u0430", 0x200000, 0x5259321f, 3 | BRF_GRA }, // 16
4245
4246 { "raiden-f2__pcm.u0217", 0x200000, 0x2edc30b5, 3 | BRF_PRG | BRF_ESS }, // 17 Sample Data (Mapped to i386)
4247 { "seibu__8.u0222", 0x080000, 0xb7bd3703, 3 | BRF_PRG | BRF_ESS }, // 18
4248
4249 { "flash0_blank_region22.u1053", 0x100000, 0x5fee8413, 0 | BRF_SND }, // 19 Intel Flash (Samples)
4250 };
4251
4252 STD_ROM_PICK(rdft2a)
STD_ROM_FN(rdft2a)4253 STD_ROM_FN(rdft2a)
4254
4255 static INT32 Rdft2aInit()
4256 {
4257 DefaultNVRAM = Rdft2DefaultNVRAM;
4258
4259 return CommonInit(DECRYPT_RISE10, NULL, 0x00282ac, 0x204366);
4260 }
4261
4262 struct BurnDriver BurnDrvRdft2a = {
4263 "rdft2a", "rdft2", NULL, NULL, "1997",
4264 "Raiden Fighters 2 - Operation Hell Dive (Hong Kong)\0", NULL, "Seibu Kaihatsu (Metrotainment license)", "SPI",
4265 NULL, NULL, NULL, NULL,
4266 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
4267 NULL, rdft2aRomInfo, rdft2aRomName, NULL, NULL, NULL, NULL, Spi_2buttonInputInfo, Spi_2buttonDIPInfo,
4268 Rdft2aInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
4269 240, 320, 3, 4
4270 };
4271
4272
4273 // Raiden Fighters 2 - Operation Hell Dive (Korea)
4274
4275 static struct BurnRomInfo rdft2aaRomDesc[] = {
4276 { "rf2_1.bin", 0x080000, 0x72198410, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
4277 { "rf2_2.bin", 0x080000, 0xec73a767, 1 | BRF_PRG | BRF_ESS }, // 1
4278 { "rf2_3.bin", 0x080000, 0xe66243b2, 1 | BRF_PRG | BRF_ESS }, // 2
4279 { "rf2_4.bin", 0x080000, 0x92b7b73e, 1 | BRF_PRG | BRF_ESS }, // 3
4280
4281 { "rf2_5.bin", 0x010000, 0x377cac2f, 1 | BRF_GRA }, // 4 Characters
4282 { "rf2_6.bin", 0x010000, 0x42bd5372, 1 | BRF_GRA }, // 5
4283 { "rf2_7.bin", 0x010000, 0x1efaac7e, 1 | BRF_GRA }, // 6
4284
4285 { "bg-1d.u0535", 0x400000, 0x6143f576, 2 | BRF_GRA }, // 7 Background Tiles
4286 { "bg-1p.u0537", 0x200000, 0x55e64ef7, 2 | BRF_GRA }, // 8
4287 { "bg-2d.u0536", 0x400000, 0xc607a444, 2 | BRF_GRA }, // 9
4288 { "bg-2p.u0538", 0x200000, 0xf0830248, 2 | BRF_GRA }, // 10
4289
4290 { "obj3.u0434", 0x400000, 0xe08f42dc, 3 | BRF_GRA }, // 11 Sprites
4291 { "obj3b.u0433", 0x200000, 0x1b6a523c, 3 | BRF_GRA }, // 12
4292 { "obj2.u0431", 0x400000, 0x7aeadd8e, 3 | BRF_GRA }, // 13
4293 { "obj2b.u0432", 0x200000, 0x5d790a5d, 3 | BRF_GRA }, // 14
4294 { "obj1.u0429", 0x400000, 0xc2c50f02, 3 | BRF_GRA }, // 15
4295 { "obj1b.u0430", 0x200000, 0x5259321f, 3 | BRF_GRA }, // 16
4296
4297 { "pcm.u0217", 0x200000, 0x2edc30b5, 3 | BRF_PRG | BRF_ESS }, // 17 Sample Data (Mapped to i386)
4298 { "sound1.u0222", 0x080000, 0xb7bd3703, 3 | BRF_PRG | BRF_ESS }, // 18
4299
4300 { "flash0_blank_region24.u1053", 0x100000, 0x72a33dc4, 0 | BRF_SND }, // 19 Intel Flash (Samples)
4301 };
4302
4303 STD_ROM_PICK(rdft2aa)
4304 STD_ROM_FN(rdft2aa)
4305
4306 struct BurnDriver BurnDrvRdft2aa = {
4307 "rdft2aa", "rdft2", NULL, NULL, "1997",
4308 "Raiden Fighters 2 - Operation Hell Dive (Korea)\0", NULL, "Seibu Kaihatsu (Dream Island license)", "SPI",
4309 NULL, NULL, NULL, NULL,
4310 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
4311 NULL, rdft2aaRomInfo, rdft2aaRomName, NULL, NULL, NULL, NULL, Spi_2buttonInputInfo, Spi_2buttonDIPInfo,
4312 Rdft2Init, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
4313 240, 320, 3, 4
4314 };
4315
4316
4317 // Raiden Fighters 2 - Operation Hell Dive (Taiwan)
4318
4319 static struct BurnRomInfo rdft2tRomDesc[] = {
4320 { "prg0", 0x080000, 0x7e8c3acc, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
4321 { "prg1", 0x080000, 0x22cb5b68, 1 | BRF_PRG | BRF_ESS }, // 1
4322 { "prg2", 0x080000, 0x3eca68dd, 1 | BRF_PRG | BRF_ESS }, // 2
4323 { "prg3", 0x080000, 0x4124daa4, 1 | BRF_PRG | BRF_ESS }, // 3
4324
4325 { "rf2_5.bin", 0x010000, 0x377cac2f, 1 | BRF_GRA }, // 4 Characters
4326 { "rf2_6.bin", 0x010000, 0x42bd5372, 1 | BRF_GRA }, // 5
4327 { "rf2_7.bin", 0x010000, 0x1efaac7e, 1 | BRF_GRA }, // 6
4328
4329 { "bg-1d.u0535", 0x400000, 0x6143f576, 2 | BRF_GRA }, // 7 Background Tiles
4330 { "bg-1p.u0537", 0x200000, 0x55e64ef7, 2 | BRF_GRA }, // 8
4331 { "bg-2d.u0536", 0x400000, 0xc607a444, 2 | BRF_GRA }, // 9
4332 { "bg-2p.u0538", 0x200000, 0xf0830248, 2 | BRF_GRA }, // 10
4333
4334 { "obj3.u0434", 0x400000, 0xe08f42dc, 3 | BRF_GRA }, // 11 Sprites
4335 { "obj3b.u0433", 0x200000, 0x1b6a523c, 3 | BRF_GRA }, // 12
4336 { "obj2.u0431", 0x400000, 0x7aeadd8e, 3 | BRF_GRA }, // 13
4337 { "obj2b.u0432", 0x200000, 0x5d790a5d, 3 | BRF_GRA }, // 14
4338 { "obj1.u0429", 0x400000, 0xc2c50f02, 3 | BRF_GRA }, // 15
4339 { "obj1b.u0430", 0x200000, 0x5259321f, 3 | BRF_GRA }, // 16
4340
4341 { "pcm.u0217", 0x200000, 0x2edc30b5, 3 | BRF_PRG | BRF_ESS }, // 17 Sample Data (Mapped to i386)
4342 { "sound1.u0222", 0x080000, 0xb7bd3703, 3 | BRF_PRG | BRF_ESS }, // 18
4343
4344 { "flash0_blank_region20.u1053", 0x100000, 0xf2051161, 0 | BRF_SND }, // 19 Intel Flash (Samples)
4345 };
4346
4347 STD_ROM_PICK(rdft2t)
4348 STD_ROM_FN(rdft2t)
4349
4350 struct BurnDriver BurnDrvRdft2t = {
4351 "rdft2t", "rdft2", NULL, NULL, "1997",
4352 "Raiden Fighters 2 - Operation Hell Dive (Taiwan)\0", NULL, "Seibu Kaihatsu", "SPI",
4353 NULL, NULL, NULL, NULL,
4354 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
4355 NULL, rdft2tRomInfo, rdft2tRomName, NULL, NULL, NULL, NULL, Spi_2buttonInputInfo, Spi_2buttonDIPInfo,
4356 Rdft2Init, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
4357 240, 320, 3, 4
4358 };
4359
4360
4361 // Raiden Fighters 2 - Operation Hell Dive (Switzerland)
4362
4363 static struct BurnRomInfo rdft2sRomDesc[] = {
4364 { "seibu__1.u0211", 0x080000, 0x28b2a185, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
4365 { "seibu__2.u0212", 0x080000, 0xcab55d88, 1 | BRF_PRG | BRF_ESS }, // 1
4366 { "seibu__3.u0221", 0x080000, 0x83758b0e, 1 | BRF_PRG | BRF_ESS }, // 2
4367 { "seibu__4.u0220", 0x080000, 0x084fb5e4, 1 | BRF_PRG | BRF_ESS }, // 3
4368
4369 { "seibu__5.u0524", 0x010000, 0x6fdf4cf6, 1 | BRF_GRA }, // 4 Characters
4370 { "seibu__6.u0518", 0x010000, 0x69b7899b, 1 | BRF_GRA }, // 5
4371 { "seibu__7.u0514", 0x010000, 0x99a5fece, 1 | BRF_GRA }, // 6
4372
4373 { "raiden-f2bg-1d.u0535", 0x400000, 0x6143f576, 2 | BRF_GRA }, // 7 Background Tiles
4374 { "raiden-f2__bg-1p.u0537", 0x200000, 0x55e64ef7, 2 | BRF_GRA }, // 8
4375 { "raiden-f2bg-2d.u0536", 0x400000, 0xc607a444, 2 | BRF_GRA }, // 9
4376 { "raiden-f2__bg-2p.u0538", 0x200000, 0xf0830248, 2 | BRF_GRA }, // 10
4377
4378 { "raiden-f2obj-3.u0434", 0x400000, 0xe08f42dc, 3 | BRF_GRA }, // 11 Sprites
4379 { "raiden-f2obj-6.u0433", 0x200000, 0x1b6a523c, 3 | BRF_GRA }, // 12
4380 { "raiden-f2obj-2.u0431", 0x400000, 0x7aeadd8e, 3 | BRF_GRA }, // 13
4381 { "raiden-f2obj-5.u0432", 0x200000, 0x5d790a5d, 3 | BRF_GRA }, // 14
4382 { "raiden-f2obj-1.u0429", 0x400000, 0xc2c50f02, 3 | BRF_GRA }, // 15
4383 { "raiden-f2obj-4.u0430", 0x200000, 0x5259321f, 3 | BRF_GRA }, // 16
4384
4385 { "raiden-f2__pcm.u0217", 0x200000, 0x2edc30b5, 3 | BRF_PRG | BRF_ESS }, // 17 Sample Data (Mapped to i386)
4386 { "seibu__8.u0222", 0x080000, 0xb7bd3703, 3 | BRF_PRG | BRF_ESS }, // 18
4387
4388 { "flash0_blank_region9c.u1053", 0x100000, 0xd73d640c, 0 | BRF_SND }, // 19 Intel Flash (Samples)
4389 };
4390
4391 STD_ROM_PICK(rdft2s)
4392 STD_ROM_FN(rdft2s)
4393
4394 struct BurnDriver BurnDrvRdft2s = {
4395 "rdft2s", "rdft2", NULL, NULL, "1997",
4396 "Raiden Fighters 2 - Operation Hell Dive (Switzerland)\0", NULL, "Seibu Kaihatsu", "SPI",
4397 NULL, NULL, NULL, NULL,
4398 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
4399 NULL, rdft2sRomInfo, rdft2sRomName, NULL, NULL, NULL, NULL, Spi_2buttonInputInfo, Spi_2buttonDIPInfo,
4400 Rdft2Init, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
4401 240, 320, 3, 4
4402 };
4403
4404
4405 // Raiden Fighters Jet (Germany)
4406
4407 static struct BurnRomInfo rfjetRomDesc[] = {
4408 { "prg0.u0211", 0x080000, 0xe5a3b304, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
4409 { "prg1.u0212", 0x080000, 0x395e6da7, 1 | BRF_PRG | BRF_ESS }, // 1
4410 { "prg2.u0221", 0x080000, 0x82f7a57e, 1 | BRF_PRG | BRF_ESS }, // 2
4411 { "prg3.u0220", 0x080000, 0xcbdf100d, 1 | BRF_PRG | BRF_ESS }, // 3
4412
4413 { "fix0.u0524", 0x010000, 0x8bc080be, 1 | BRF_GRA }, // 4 Characters
4414 { "fix1.u0518", 0x010000, 0xbded85e7, 1 | BRF_GRA }, // 5
4415 { "fixp.u0514", 0x010000, 0x015d0748, 1 | BRF_GRA }, // 6
4416
4417 { "bg-1d.u0543", 0x400000, 0xedfd96da, 2 | BRF_GRA }, // 7 Background Tiles
4418 { "bg-1p.u0544", 0x200000, 0xa4cc4631, 2 | BRF_GRA }, // 8
4419 { "bg-2d.u0545", 0x200000, 0x731fbb59, 2 | BRF_GRA }, // 9
4420 { "bg-2p.u0546", 0x100000, 0x03652c25, 2 | BRF_GRA }, // 10
4421
4422 { "obj-1.u0442", 0x800000, 0x58a59896, 3 | BRF_GRA }, // 11 Sprites
4423 { "obj-2.u0443", 0x800000, 0xa121d1e3, 3 | BRF_GRA }, // 12
4424 { "obj-3.u0444", 0x800000, 0xbc2c0c63, 3 | BRF_GRA }, // 13
4425
4426 { "pcm-d.u0227", 0x200000, 0x8ee3ff45, 3 | BRF_PRG | BRF_ESS }, // 14 Sample Data (Mapped to i386)
4427 { "sound1.u0222", 0x080000, 0xd4fc3da1, 3 | BRF_PRG | BRF_ESS }, // 15
4428
4429 { "flash0_blank_region80.u1053", 0x100000, 0xe2adaff5, 0 | BRF_SND }, // 16 Intel Flash (Samples)
4430 };
4431
4432 STD_ROM_PICK(rfjet)
STD_ROM_FN(rfjet)4433 STD_ROM_FN(rfjet)
4434
4435 static INT32 RfjetInit()
4436 {
4437 return CommonInit(DECRYPT_RISE11, NULL, 0x2894c, 0x206082);
4438 }
4439
4440 struct BurnDriver BurnDrvRfjet = {
4441 "rfjet", NULL, NULL, NULL, "1998",
4442 "Raiden Fighters Jet (Germany)\0", NULL, "Seibu Kaihatsu (Tuning license)", "SPI",
4443 NULL, NULL, NULL, NULL,
4444 BDF_GAME_WORKING | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
4445 NULL, rfjetRomInfo, rfjetRomName, NULL, NULL, NULL, NULL, Spi_2buttonInputInfo, Spi_2buttonDIPInfo,
4446 RfjetInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
4447 240, 320, 3, 4
4448 };
4449
4450
4451 // Raiden Fighters Jet (Japan)
4452
4453 static struct BurnRomInfo rfjetjRomDesc[] = {
4454 { "prg0.bin", 0x080000, 0xd82fb71f, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
4455 { "prg1.bin", 0x080000, 0x7e21c669, 1 | BRF_PRG | BRF_ESS }, // 1
4456 { "prg2.bin", 0x080000, 0x2f402d55, 1 | BRF_PRG | BRF_ESS }, // 2
4457 { "prg3.bin", 0x080000, 0xd619e2ad, 1 | BRF_PRG | BRF_ESS }, // 3
4458
4459 { "fix0.u0524", 0x010000, 0x8bc080be, 1 | BRF_GRA }, // 4 Characters
4460 { "fix1.u0518", 0x010000, 0xbded85e7, 1 | BRF_GRA }, // 5
4461 { "fixp.u0514", 0x010000, 0x015d0748, 1 | BRF_GRA }, // 6
4462
4463 { "bg-1d.u0543", 0x400000, 0xedfd96da, 2 | BRF_GRA }, // 7 Background Tiles
4464 { "bg-1p.u0544", 0x200000, 0xa4cc4631, 2 | BRF_GRA }, // 8
4465 { "bg-2d.u0545", 0x200000, 0x731fbb59, 2 | BRF_GRA }, // 9
4466 { "bg-2p.u0546", 0x100000, 0x03652c25, 2 | BRF_GRA }, // 10
4467
4468 { "obj-1.u0442", 0x800000, 0x58a59896, 3 | BRF_GRA }, // 11 Sprites
4469 { "obj-2.u0443", 0x800000, 0xa121d1e3, 3 | BRF_GRA }, // 12
4470 { "obj-3.u0444", 0x800000, 0xbc2c0c63, 3 | BRF_GRA }, // 13
4471
4472 { "pcm-d.u0227", 0x200000, 0x8ee3ff45, 3 | BRF_PRG | BRF_ESS }, // 14 Sample Data (Mapped to i386)
4473 { "sound1.u0222", 0x080000, 0xd4fc3da1, 3 | BRF_PRG | BRF_ESS }, // 15
4474
4475 { "flash0_blank_region01.u1053", 0x100000, 0x7ae7ab76, 0 | BRF_SND }, // 16 Intel Flash (Samples)
4476 };
4477
4478 STD_ROM_PICK(rfjetj)
STD_ROM_FN(rfjetj)4479 STD_ROM_FN(rfjetj)
4480
4481 static INT32 RfjetjInit()
4482 {
4483 return CommonInit(DECRYPT_RISE11, NULL, 0x2894c, 0x205f2e);
4484 }
4485
4486 struct BurnDriver BurnDrvRfjetj = {
4487 "rfjetj", "rfjet", NULL, NULL, "1998",
4488 "Raiden Fighters Jet (Japan)\0", NULL, "Seibu Kaihatsu", "SPI",
4489 NULL, NULL, NULL, NULL,
4490 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
4491 NULL, rfjetjRomInfo, rfjetjRomName, NULL, NULL, NULL, NULL, Spi_2buttonInputInfo, Spi_2buttonDIPInfo,
4492 RfjetjInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
4493 240, 320, 3, 4
4494 };
4495
4496
4497 // Raiden Fighters Jet (US)
4498
4499 static struct BurnRomInfo rfjetuRomDesc[] = {
4500 { "prg0u.u0211", 0x080000, 0x15ac2040, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
4501 { "prg1.u0212", 0x080000, 0x395e6da7, 1 | BRF_PRG | BRF_ESS }, // 1
4502 { "prg2.u0221", 0x080000, 0x82f7a57e, 1 | BRF_PRG | BRF_ESS }, // 2
4503 { "prg3.u0220", 0x080000, 0xcbdf100d, 1 | BRF_PRG | BRF_ESS }, // 3
4504
4505 { "fix0.u0524", 0x010000, 0x8bc080be, 1 | BRF_GRA }, // 4 Characters
4506 { "fix1.u0518", 0x010000, 0xbded85e7, 1 | BRF_GRA }, // 5
4507 { "fixp.u0514", 0x010000, 0x015d0748, 1 | BRF_GRA }, // 6
4508
4509 { "bg-1d.u0543", 0x400000, 0xedfd96da, 2 | BRF_GRA }, // 7 Background Tiles
4510 { "bg-1p.u0544", 0x200000, 0xa4cc4631, 2 | BRF_GRA }, // 8
4511 { "bg-2d.u0545", 0x200000, 0x731fbb59, 2 | BRF_GRA }, // 9
4512 { "bg-2p.u0546", 0x100000, 0x03652c25, 2 | BRF_GRA }, // 10
4513
4514 { "obj-1.u0442", 0x800000, 0x58a59896, 3 | BRF_GRA }, // 11 Sprites
4515 { "obj-2.u0443", 0x800000, 0xa121d1e3, 3 | BRF_GRA }, // 12
4516 { "obj-3.u0444", 0x800000, 0xbc2c0c63, 3 | BRF_GRA }, // 13
4517
4518 { "pcm-d.u0227", 0x200000, 0x8ee3ff45, 3 | BRF_PRG | BRF_ESS }, // 14 Sample Data (Mapped to i386)
4519 { "sound1.u0222", 0x080000, 0xd4fc3da1, 3 | BRF_PRG | BRF_ESS }, // 15
4520
4521 { "flash0_blank_region10.u1053", 0x100000, 0x4319d998, 0 | BRF_SND }, // 16 Intel Flash (Samples)
4522 };
4523
4524 STD_ROM_PICK(rfjetu)
STD_ROM_FN(rfjetu)4525 STD_ROM_FN(rfjetu)
4526
4527 static INT32 RfjetuInit()
4528 {
4529 return CommonInit(DECRYPT_RISE11, NULL, 0x2894c, 0x206082);
4530 }
4531
4532 struct BurnDriver BurnDrvRfjetu = {
4533 "rfjetu", "rfjet", NULL, NULL, "1998",
4534 "Raiden Fighters Jet (US)\0", NULL, "Seibu Kaihatsu (Fabtek license)", "SPI",
4535 NULL, NULL, NULL, NULL,
4536 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
4537 NULL, rfjetuRomInfo, rfjetuRomName, NULL, NULL, NULL, NULL, Spi_2buttonInputInfo, Spi_2buttonDIPInfo,
4538 RfjetuInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
4539 240, 320, 3, 4
4540 };
4541
4542
4543 // Raiden Fighters Jet (Korea)
4544
4545 static struct BurnRomInfo rfjetaRomDesc[] = {
4546 { "prg0a.u0211", 0x080000, 0x3418d4f5, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
4547 { "prg1.u0212", 0x080000, 0x395e6da7, 1 | BRF_PRG | BRF_ESS }, // 1
4548 { "prg2.u0221", 0x080000, 0x82f7a57e, 1 | BRF_PRG | BRF_ESS }, // 2
4549 { "prg3.u0220", 0x080000, 0xcbdf100d, 1 | BRF_PRG | BRF_ESS }, // 3
4550
4551 { "fix0.u0524", 0x010000, 0x8bc080be, 1 | BRF_GRA }, // 4 Characters
4552 { "fix1.u0518", 0x010000, 0xbded85e7, 1 | BRF_GRA }, // 5
4553 { "fixp.u0514", 0x010000, 0x015d0748, 1 | BRF_GRA }, // 6
4554
4555 { "bg-1d.u0543", 0x400000, 0xedfd96da, 2 | BRF_GRA }, // 7 Background Tiles
4556 { "bg-1p.u0544", 0x200000, 0xa4cc4631, 2 | BRF_GRA }, // 8
4557 { "bg-2d.u0545", 0x200000, 0x731fbb59, 2 | BRF_GRA }, // 9
4558 { "bg-2p.u0546", 0x100000, 0x03652c25, 2 | BRF_GRA }, // 10
4559
4560 { "obj-1.u0442", 0x800000, 0x58a59896, 3 | BRF_GRA }, // 11 Sprites
4561 { "obj-2.u0443", 0x800000, 0xa121d1e3, 3 | BRF_GRA }, // 12
4562 { "obj-3.u0444", 0x800000, 0xbc2c0c63, 3 | BRF_GRA }, // 13
4563
4564 { "pcm-d.u0227", 0x200000, 0x8ee3ff45, 3 | BRF_PRG | BRF_ESS }, // 14 Sample Data (Mapped to i386)
4565 { "sound1.u0222", 0x080000, 0xd4fc3da1, 3 | BRF_PRG | BRF_ESS }, // 15
4566
4567 { "flash0_blank_region24.u1053", 0x100000, 0x72a33dc4, 0 | BRF_SND }, // 16 Intel Flash (Samples)
4568 };
4569
4570 STD_ROM_PICK(rfjeta)
STD_ROM_FN(rfjeta)4571 STD_ROM_FN(rfjeta)
4572
4573 static INT32 RfjetaInit()
4574 {
4575 return CommonInit(DECRYPT_RISE11, NULL, 0x2894c, 0x206082);
4576 }
4577
4578 struct BurnDriver BurnDrvRfjeta = {
4579 "rfjeta", "rfjet", NULL, NULL, "1998",
4580 "Raiden Fighters Jet (Korea)\0", NULL, "Seibu Kaihatsu (Dream Island license)", "SPI",
4581 NULL, NULL, NULL, NULL,
4582 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
4583 NULL, rfjetaRomInfo, rfjetaRomName, NULL, NULL, NULL, NULL, Spi_2buttonInputInfo, Spi_2buttonDIPInfo,
4584 RfjetaInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
4585 240, 320, 3, 4
4586 };
4587
4588
4589 // Raiden Fighters Jet (Taiwan)
4590
4591 static struct BurnRomInfo rfjettRomDesc[] = {
4592 { "prg0.u0211", 0x080000, 0xa4734579, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
4593 { "prg1.u0212", 0x080000, 0x5e4ad3a4, 1 | BRF_PRG | BRF_ESS }, // 1
4594 { "prg2.u0221", 0x080000, 0x21c9942e, 1 | BRF_PRG | BRF_ESS }, // 2
4595 { "prg3.u0220", 0x080000, 0xea3657f4, 1 | BRF_PRG | BRF_ESS }, // 3
4596
4597 { "fix0.u0524", 0x010000, 0x8bc080be, 1 | BRF_GRA }, // 4 Characters
4598 { "fix1.u0518", 0x010000, 0xbded85e7, 1 | BRF_GRA }, // 5
4599 { "fixp.u0514", 0x010000, 0x015d0748, 1 | BRF_GRA }, // 6
4600
4601 { "bg-1d.u0543", 0x400000, 0xedfd96da, 2 | BRF_GRA }, // 7 Background Tiles
4602 { "bg-1p.u0544", 0x200000, 0xa4cc4631, 2 | BRF_GRA }, // 8
4603 { "bg-2d.u0545", 0x200000, 0x731fbb59, 2 | BRF_GRA }, // 9
4604 { "bg-2p.u0546", 0x100000, 0x03652c25, 2 | BRF_GRA }, // 10
4605
4606 { "obj-1.u0442", 0x800000, 0x58a59896, 3 | BRF_GRA }, // 11 Sprites
4607 { "obj-2.u0443", 0x800000, 0xa121d1e3, 3 | BRF_GRA }, // 12
4608 { "obj-3.u0444", 0x800000, 0xbc2c0c63, 3 | BRF_GRA }, // 13
4609
4610 { "pcm-d.u0227", 0x200000, 0x8ee3ff45, 3 | BRF_PRG | BRF_ESS }, // 14 Sample Data (Mapped to i386)
4611 { "sound1.u0222", 0x080000, 0xd4fc3da1, 3 | BRF_PRG | BRF_ESS }, // 15
4612
4613 { "flash0_blank_region20.u1053", 0x100000, 0xf2051161, 0 | BRF_SND }, // 16 Intel Flash (Samples)
4614 };
4615
4616 STD_ROM_PICK(rfjett)
STD_ROM_FN(rfjett)4617 STD_ROM_FN(rfjett)
4618
4619 static INT32 RfjettInit()
4620 {
4621 return CommonInit(DECRYPT_RISE11, NULL, 0x2894c, 0x206082);
4622 }
4623
4624 struct BurnDriver BurnDrvRfjett = {
4625 "rfjett", "rfjet", NULL, NULL, "1998",
4626 "Raiden Fighters Jet (Taiwan)\0", NULL, "Seibu Kaihatsu", "SPI",
4627 NULL, NULL, NULL, NULL,
4628 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
4629 NULL, rfjettRomInfo, rfjettRomName, NULL, NULL, NULL, NULL, Spi_2buttonInputInfo, Spi_2buttonDIPInfo,
4630 RfjettInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
4631 240, 320, 3, 4
4632 };
4633
4634
4635 // Raiden Fighters (Taiwan, single board)
4636
4637 static struct BurnRomInfo rdftsRomDesc[] = {
4638 { "seibu_1.u0259", 0x080000, 0xe278dddd, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
4639 { "raiden-f_prg2.u0258", 0x080000, 0x58ccb10c, 1 | BRF_PRG | BRF_ESS }, // 1
4640 { "raiden-f_prg34.u0262", 0x100000, 0x63f01d17, 1 | BRF_PRG | BRF_ESS }, // 2
4641
4642 { "seibu_zprg.u1139", 0x020000, 0xc1fda3e8, 2 | BRF_PRG | BRF_ESS }, // 3 Z80 Code
4643
4644 { "raiden-f_fix.u0535", 0x020000, 0x2be2936b, 1 | BRF_GRA }, // 4 Characters
4645 { "seibu_fix2.u0528", 0x010000, 0x4d87e1ea, 1 | BRF_GRA }, // 5
4646
4647 { "gun_dogs_bg1-d.u0526", 0x200000, 0x6a68054c, 2 | BRF_GRA }, // 6 Background Tiles
4648 { "gun_dogs_bg1-p.u0531", 0x100000, 0x3400794a, 2 | BRF_GRA }, // 7
4649 { "gun_dogs_bg2-d.u0534", 0x200000, 0x61cd2991, 2 | BRF_GRA }, // 8
4650 { "gun_dogs_bg2-p.u0530", 0x100000, 0x502d5799, 2 | BRF_GRA }, // 9
4651
4652 { "gun_dogs_obj-1.u0322", 0x400000, 0x59d86c99, 3 | BRF_GRA }, // 10 Sprites
4653 { "gun_dogs_obj-2.u0324", 0x400000, 0x1ceb0b6f, 3 | BRF_GRA }, // 11
4654 { "gun_dogs_obj-3.u0323", 0x400000, 0x36e93234, 3 | BRF_GRA }, // 12
4655
4656 { "raiden-f_pcm2.u0975", 0x200000, 0x3f8d4a48, 1 | BRF_SND }, // 13 YMF271 Samples
4657 };
4658
4659 STD_ROM_PICK(rdfts)
STD_ROM_FN(rdfts)4660 STD_ROM_FN(rdfts)
4661
4662 static INT32 RdftsInit()
4663 {
4664 return CommonInit(DECRYPT_SEI252, NULL, 0x298d0, 0x203f46); // 0x203f69?
4665 }
4666
4667 struct BurnDriver BurnDrvRdfts = {
4668 "rdfts", "rdft", NULL, NULL, "1996",
4669 "Raiden Fighters (Taiwan, single board)\0", NULL, "Seibu Kaihatsu (Explorer System Corp. license)", "SPI",
4670 NULL, NULL, NULL, NULL,
4671 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
4672 NULL, rdftsRomInfo, rdftsRomName, NULL, NULL, NULL, NULL, Spi_3buttonInputInfo, NULL,
4673 RdftsInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
4674 240, 320, 3, 4
4675 };
4676
4677
4678 // Raiden Fighters 2 - Operation Hell Dive (US, single board)
4679
4680 static struct BurnRomInfo rdft2usRomDesc[] = {
4681 { "prg0.u0259", 0x080000, 0xff3eeec1, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
4682 { "prg1.u0258", 0x080000, 0xe2cf77d6, 1 | BRF_PRG | BRF_ESS }, // 1
4683 { "prg2.u0265", 0x080000, 0xcae87e1f, 1 | BRF_PRG | BRF_ESS }, // 2
4684 { "prg3.u0264", 0x080000, 0x83f4fb5f, 1 | BRF_PRG | BRF_ESS }, // 3
4685
4686 { "zprg.u091", 0x020000, 0xcc543c4f, 2 | BRF_PRG | BRF_ESS }, // 4 Z80 Code
4687
4688 { "fix0.u0524", 0x010000, 0x6fdf4cf6, 1 | BRF_GRA }, // 5 Characters
4689 { "fix1.u0518", 0x010000, 0x69b7899b, 1 | BRF_GRA }, // 6
4690 { "fixp.u0514", 0x010000, 0x99a5fece, 1 | BRF_GRA }, // 7
4691
4692 { "bg-1d.u0535", 0x400000, 0x6143f576, 2 | BRF_GRA }, // 8 Background Tiles
4693 { "bg-1p.u0537", 0x200000, 0x55e64ef7, 2 | BRF_GRA }, // 9
4694 { "bg-2d.u0536", 0x400000, 0xc607a444, 2 | BRF_GRA }, // 10
4695 { "bg-2p.u0538", 0x200000, 0xf0830248, 2 | BRF_GRA }, // 11
4696
4697 { "obj3.u075", 0x400000, 0xe08f42dc, 3 | BRF_GRA }, // 12 Sprites
4698 { "obj3b.u078", 0x200000, 0x1b6a523c, 3 | BRF_GRA }, // 13
4699 { "obj2.u074", 0x400000, 0x7aeadd8e, 3 | BRF_GRA }, // 14
4700 { "obj2b.u077", 0x200000, 0x5d790a5d, 3 | BRF_GRA }, // 15
4701 { "obj1.u073", 0x400000, 0xc2c50f02, 3 | BRF_GRA }, // 16
4702 { "obj1b.u076", 0x200000, 0x5259321f, 3 | BRF_GRA }, // 17
4703
4704 { "pcm.u0103", 0x200000, 0x2edc30b5, 1 | BRF_SND }, // 18 YMF271 Samples
4705 { "sound1.u0107", 0x080000, 0x20384b0e, 1 | BRF_SND }, // 19
4706 };
4707
4708 STD_ROM_PICK(rdft2us)
STD_ROM_FN(rdft2us)4709 STD_ROM_FN(rdft2us)
4710
4711 static void rdft2us_callback()
4712 {
4713 static const UINT8 EEPROMData[32] = {
4714 0x4A, 0x68, 0x37, 0x4A, 0x01, 0x20, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x00, 0x09, 0x00, 0x00,
4715 0x03, 0x01, 0x03, 0x01, 0x00, 0x00, 0x07, 0x05, 0x7F, 0xFF, 0x00, 0x00, 0x01, 0x03, 0x02, 0xFA
4716 };
4717
4718 memcpy (DefaultEEPROM, EEPROMData, 32);
4719
4720 EEPROMInit(&seibuspi_eeprom);
4721 has_eeprom = 1;
4722 }
4723
Rdft2usInit()4724 static INT32 Rdft2usInit()
4725 {
4726 return CommonInit(DECRYPT_RISE10, rdft2us_callback, 0x282ac, 0x20420e);
4727 }
4728
4729 struct BurnDriver BurnDrvRdft2us = {
4730 "rdft2us", "rdft2", NULL, NULL, "1997",
4731 "Raiden Fighters 2 - Operation Hell Dive (US, single board)\0", NULL, "Seibu Kaihatsu (Fabtek license)", "SPI",
4732 NULL, NULL, NULL, NULL,
4733 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
4734 NULL, rdft2usRomInfo, rdft2usRomName, NULL, NULL, NULL, NULL, Spi_2buttonInputInfo, NULL,
4735 Rdft2usInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
4736 240, 320, 3, 4
4737 };
4738
4739
4740 // Raiden Fighters Jet (US, single board)
4741
4742 static struct BurnRomInfo rfjetsRomDesc[] = {
4743 { "rfj-06.u0259", 0x080000, 0xc835aa7a, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
4744 { "rfj-07.u0258", 0x080000, 0x3b6ca1ca, 1 | BRF_PRG | BRF_ESS }, // 1
4745 { "rfj-08.u0265", 0x080000, 0x1f5dd06c, 1 | BRF_PRG | BRF_ESS }, // 2
4746 { "rfj-09.u0264", 0x080000, 0xcc71c402, 1 | BRF_PRG | BRF_ESS }, // 3
4747
4748 { "rfj-05.u091", 0x040000, 0xa55e8799, 2 | BRF_PRG | BRF_ESS }, // 4 Z80 Code
4749
4750 { "rfj-01.u0524", 0x010000, 0x8bc080be, 1 | BRF_GRA }, // 5 Characters
4751 { "rfj-02.u0518", 0x010000, 0xbded85e7, 1 | BRF_GRA }, // 6
4752 { "rfj-03.u0514", 0x010000, 0x015d0748, 1 | BRF_GRA }, // 7
4753
4754 { "bg-1d.u0535", 0x400000, 0xedfd96da, 2 | BRF_GRA }, // 8 Background Tiles
4755 { "bg-1p.u0537", 0x200000, 0xa4cc4631, 2 | BRF_GRA }, // 9
4756 { "bg-2d.u0536", 0x200000, 0x731fbb59, 2 | BRF_GRA }, // 10
4757 { "bg-2p.u0545", 0x100000, 0x03652c25, 2 | BRF_GRA }, // 11
4758
4759 { "obj-1.u073", 0x800000, 0x58a59896, 3 | BRF_GRA }, // 12 Sprites
4760 { "obj-2.u074", 0x800000, 0xa121d1e3, 3 | BRF_GRA }, // 13
4761 { "obj-3.u075", 0x800000, 0xbc2c0c63, 3 | BRF_GRA }, // 14
4762
4763 { "pcm-d.u0103", 0x200000, 0x8ee3ff45, 1 | BRF_SND }, // 15 YMF271 Samples
4764 { "rfj-04.u0107", 0x080000, 0xc050da03, 1 | BRF_SND }, // 16
4765
4766 { "st93c46.bin", 0x000080, 0x8fe8063b, 7 | BRF_PRG | BRF_ESS }, // 17 Default EEPROM
4767 };
4768
4769 STD_ROM_PICK(rfjets)
STD_ROM_FN(rfjets)4770 STD_ROM_FN(rfjets)
4771
4772 static INT32 RfjetsInit()
4773 {
4774 has_eeprom = 1;
4775 EEPROMInit(&seibuspi_eeprom);
4776
4777 return RfjetInit();
4778 }
4779
4780 struct BurnDriver BurnDrvRfjets = {
4781 "rfjets", "rfjet", NULL, NULL, "1999",
4782 "Raiden Fighters Jet (US, single board)\0", NULL, "Seibu Kaihatsu", "SPI",
4783 NULL, NULL, NULL, NULL,
4784 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
4785 NULL, rfjetsRomInfo, rfjetsRomName, NULL, NULL, NULL, NULL, Spi_2buttonInputInfo, NULL,
4786 RfjetsInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
4787 240, 320, 3, 4
4788 };
4789
4790
4791 // Raiden Fighters Jet (US, single board, test version?)
4792
4793 static struct BurnRomInfo rfjetsaRomDesc[] = {
4794 { "rfj-06.u0259", 0x080000, 0xb0c8d47e, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
4795 { "rfj-07.u0258", 0x080000, 0x17189b39, 1 | BRF_PRG | BRF_ESS }, // 1
4796 { "rfj-08.u0265", 0x080000, 0xab6d724b, 1 | BRF_PRG | BRF_ESS }, // 2
4797 { "rfj-09.u0264", 0x080000, 0xb119a67c, 1 | BRF_PRG | BRF_ESS }, // 3
4798
4799 { "rfj-05.u091", 0x040000, 0xa55e8799, 2 | BRF_PRG | BRF_ESS }, // 4 Z80 Code
4800
4801 { "rfj-01.u0524", 0x010000, 0x8bc080be, 1 | BRF_GRA }, // 5 Characters
4802 { "rfj-02.u0518", 0x010000, 0xbded85e7, 1 | BRF_GRA }, // 6
4803 { "rfj-03.u0514", 0x010000, 0x015d0748, 1 | BRF_GRA }, // 7
4804
4805 { "bg-1d.u0535", 0x400000, 0xedfd96da, 2 | BRF_GRA }, // 8 Background Tiles
4806 { "bg-1p.u0537", 0x200000, 0xa4cc4631, 2 | BRF_GRA }, // 9
4807 { "bg-2d.u0536", 0x200000, 0x731fbb59, 2 | BRF_GRA }, // 10
4808 { "bg-2p.u0545", 0x100000, 0x03652c25, 2 | BRF_GRA }, // 11
4809
4810 { "obj-1.u073", 0x800000, 0x58a59896, 3 | BRF_GRA }, // 12 Sprites
4811 { "obj-2.u074", 0x800000, 0xa121d1e3, 3 | BRF_GRA }, // 13
4812 { "obj-3.u075", 0x800000, 0xbc2c0c63, 3 | BRF_GRA }, // 14
4813
4814 { "pcm-d.u0103", 0x200000, 0x8ee3ff45, 1 | BRF_SND }, // 15 YMF271 Samples
4815 { "rfj-04.u0107", 0x080000, 0xc050da03, 1 | BRF_SND }, // 16
4816 };
4817
4818 STD_ROM_PICK(rfjetsa)
4819 STD_ROM_FN(rfjetsa)
4820
4821 struct BurnDriver BurnDrvRfjetsa = {
4822 "rfjetsa", "rfjet", NULL, NULL, "1999",
4823 "Raiden Fighters Jet (US, single board, test version?)\0", NULL, "Seibu Kaihatsu", "SPI",
4824 NULL, NULL, NULL, NULL,
4825 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
4826 NULL, rfjetsaRomInfo, rfjetsaRomName, NULL, NULL, NULL, NULL, Spi_2buttonInputInfo, NULL,
4827 RfjetsInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
4828 240, 320, 3, 4
4829 };
4830
4831
4832 // Raiden Fighters 2 - Operation Hell Dive 2000 (China, SYS386I)
4833
4834 static struct BurnRomInfo rdft22kcRomDesc[] = {
4835 { "prg0-1.267", 0x100000, 0x0d7d6eb8, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
4836 { "prg2-3.266", 0x100000, 0xead53e69, 1 | BRF_PRG | BRF_ESS }, // 1
4837
4838 { "fix0.524", 0x010000, 0xed11d043, 1 | BRF_GRA }, // 2 Characters
4839 { "fix1.518", 0x010000, 0x7036d70a, 1 | BRF_GRA }, // 3
4840 { "fix2.514", 0x010000, 0x29b465da, 1 | BRF_GRA }, // 4
4841
4842 { "bg-1d.535", 0x400000, 0x6143f576, 2 | BRF_GRA }, // 5 Background Tiles
4843 { "bg-1p.544", 0x200000, 0x55e64ef7, 2 | BRF_GRA }, // 6
4844 { "bg-2d.536", 0x400000, 0xc607a444, 2 | BRF_GRA }, // 7
4845 { "bg-2p.545", 0x200000, 0xf0830248, 2 | BRF_GRA }, // 8
4846
4847 { "obj3.075", 0x400000, 0xe08f42dc, 3 | BRF_GRA }, // 9 Sprites
4848 { "obj6.078", 0x200000, 0x1b6a523c, 3 | BRF_GRA }, // 10
4849 { "obj2.074", 0x400000, 0x7aeadd8e, 3 | BRF_GRA }, // 11
4850 { "obj5.077", 0x200000, 0x5d790a5d, 3 | BRF_GRA }, // 12
4851 { "obj1.073", 0x400000, 0xc2c50f02, 3 | BRF_GRA }, // 13
4852 { "obj4.076", 0x200000, 0x5259321f, 3 | BRF_GRA }, // 14
4853
4854 { "pcm0.1022", 0x080000, 0xfd599b35, 4 | BRF_SND }, // 15 MSM6295 #0 Samples
4855
4856 { "pcm1.1023", 0x080000, 0x8b716356, 5 | BRF_SND }, // 16 MSM6295 #1 Samples
4857 };
4858
4859 STD_ROM_PICK(rdft22kc)
STD_ROM_FN(rdft22kc)4860 STD_ROM_FN(rdft22kc)
4861
4862 static void Rdft22kc_callback()
4863 {
4864 static const UINT8 EEPROMData[32] = {
4865 0x4A, 0xDC, 0x37, 0x4A, 0x01, 0x20, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x00, 0x63, 0x00, 0x00,
4866 0x03, 0x01, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x03, 0x04, 0x3D
4867 };
4868
4869 memcpy (DefaultEEPROM, EEPROMData, 32);
4870 }
4871
Rdft22kcInit()4872 static INT32 Rdft22kcInit()
4873 {
4874 return Sys368iCommonInit(DECRYPT_RISE10, Rdft22kc_callback, 0x00282ac, 0x0203926);
4875 }
4876
4877 struct BurnDriver BurnDrvRdft22kc = {
4878 "rdft22kc", "rdft2", NULL, NULL, "2000",
4879 "Raiden Fighters 2 - Operation Hell Dive 2000 (China, SYS386I)\0", NULL, "Seibu Kaihatsu", "SYS386I",
4880 NULL, NULL, NULL, NULL,
4881 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
4882 NULL, rdft22kcRomInfo, rdft22kcRomName, NULL, NULL, NULL, NULL, Sys386iInputInfo, NULL,
4883 Rdft22kcInit, DrvExit, Sys386Frame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
4884 240, 320, 3, 4
4885 };
4886
4887
4888 // Raiden Fighters Jet 2000 (China, SYS386I)
4889
4890 static struct BurnRomInfo rfjet2kcRomDesc[] = {
4891 { "prg01.u267", 0x100000, 0x36019fa8, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
4892 { "prg23.u266", 0x100000, 0x65695dde, 1 | BRF_PRG | BRF_ESS }, // 1
4893
4894 { "rfj-01.524", 0x010000, 0xe9d53007, 1 | BRF_GRA }, // 2 Characters
4895 { "rfj-02.518", 0x010000, 0xdd3eabd3, 1 | BRF_GRA }, // 3
4896 { "rfj-03.514", 0x010000, 0x0daa8aac, 1 | BRF_GRA }, // 4
4897
4898 { "bg-1d.u0535", 0x400000, 0xedfd96da, 2 | BRF_GRA }, // 5 Background Tiles
4899 { "bg-1p.u0537", 0x200000, 0xa4cc4631, 2 | BRF_GRA }, // 6
4900 { "bg-2d.u0536", 0x200000, 0x731fbb59, 2 | BRF_GRA }, // 7
4901 { "bg-2p.u0547", 0x100000, 0x03652c25, 2 | BRF_GRA }, // 8
4902
4903 { "obj-1.u073", 0x800000, 0x58a59896, 3 | BRF_GRA }, // 9 Sprites
4904 { "obj-2.u074", 0x800000, 0xa121d1e3, 3 | BRF_GRA }, // 10
4905 { "obj-3.u0749", 0x800000, 0xbc2c0c63, 3 | BRF_GRA }, // 11
4906
4907 { "rfj-05.u1022", 0x080000, 0xfd599b35, 4 | BRF_SND }, // 12 MSM6295 #0 Samples
4908
4909 { "rfj-04.u1023", 0x080000, 0x1d10cd08, 5 | BRF_SND }, // 13 MSM6295 #1 Samples
4910 };
4911
4912 STD_ROM_PICK(rfjet2kc)
STD_ROM_FN(rfjet2kc)4913 STD_ROM_FN(rfjet2kc)
4914
4915 static INT32 Rfjet2kcInit()
4916 {
4917 return Sys368iCommonInit(DECRYPT_RISE11, NULL, 0x2894c, 0x205c9e); // or 0x205cc1
4918 }
4919
4920 struct BurnDriver BurnDrvRfjet2kc = {
4921 "rfjet2kc", "rfjet", NULL, NULL, "2000",
4922 "Raiden Fighters Jet 2000 (China, SYS386I)\0", NULL, "Seibu Kaihatsu", "SYS386I",
4923 NULL, NULL, NULL, NULL,
4924 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_MISC_POST90S, GBF_VERSHOOT, 0,
4925 NULL, rfjet2kcRomInfo, rfjet2kcRomName, NULL, NULL, NULL, NULL, Sys386iInputInfo, NULL,
4926 Rfjet2kcInit, DrvExit, Sys386Frame, DrvDraw, DrvScan, &DrvRecalc, 0x1800,
4927 240, 320, 3, 4
4928 };
4929
4930
4931 // E-Jan Sakurasou (Japan, SYS386F V2.0)
4932
4933 static struct BurnRomInfo ejsakuraRomDesc[] = {
4934 { "prg0.211", 0x040000, 0x199f2f08, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
4935 { "prg1.212", 0x040000, 0x2cb636e6, 1 | BRF_PRG | BRF_ESS }, // 1
4936 { "prg2.221", 0x040000, 0x98a7b615, 1 | BRF_PRG | BRF_ESS }, // 2
4937 { "prg3.220", 0x040000, 0x9c3c037a, 1 | BRF_PRG | BRF_ESS }, // 3
4938
4939 { "chr4.445", 0x400000, 0x40c6c238, 3 | BRF_GRA }, // 4 Sprites
4940 { "chr3.444", 0x400000, 0x8e5d1de5, 3 | BRF_GRA }, // 5
4941 { "chr2.443", 0x400000, 0x638dc9ae, 3 | BRF_GRA }, // 6
4942 { "chr1.442", 0x400000, 0x177e3139, 3 | BRF_GRA }, // 7
4943
4944 { "sound1.83", 0x800000, 0x98783cfc, 1 | BRF_SND }, // 8 YMZ280b Samples
4945 { "sound2.84", 0x800000, 0xff37e769, 1 | BRF_SND }, // 9
4946 };
4947
4948 STD_ROM_PICK(ejsakura)
4949 STD_ROM_FN(ejsakura)
4950
4951 struct BurnDriver BurnDrvEjsakura = {
4952 "ejsakura", NULL, NULL, NULL, "1999",
4953 "E-Jan Sakurasou (Japan, SYS386F V2.0)\0", NULL, "Seibu Kaihatsu", "SYS386F",
4954 NULL, NULL, NULL, NULL,
4955 BDF_GAME_WORKING, 1, HARDWARE_MISC_POST90S, GBF_MAHJONG, 0,
4956 NULL, ejsakuraRomInfo, ejsakuraRomName, NULL, NULL, NULL, NULL, EjsakuraInputInfo, NULL,
4957 Sys386fInit, DrvExit, Sys386fFrame, Sys386fDraw, DrvScan, &DrvRecalc, 0x2000,
4958 320, 240, 4, 3
4959 };
4960
4961
4962 // E-Jan Sakurasou (Japan, SYS386F V1.2)
4963
4964 static struct BurnRomInfo ejsakura12RomDesc[] = {
4965 { "prg0v1.2.u0211", 0x040000, 0xc734fde6, 1 | BRF_PRG | BRF_ESS }, // 0 i386 Code
4966 { "prg1v1.2.u0212", 0x040000, 0xfb7a9e38, 1 | BRF_PRG | BRF_ESS }, // 1
4967 { "prg2v1.2.u0221", 0x040000, 0xe13098ad, 1 | BRF_PRG | BRF_ESS }, // 2
4968 { "prg3v1.2.u0220", 0x040000, 0x29b5460f, 1 | BRF_PRG | BRF_ESS }, // 3
4969
4970 { "chr4.445", 0x400000, 0x40c6c238, 3 | BRF_GRA }, // 4 Sprites
4971 { "chr3.444", 0x400000, 0x8e5d1de5, 3 | BRF_GRA }, // 5
4972 { "chr2.443", 0x400000, 0x638dc9ae, 3 | BRF_GRA }, // 6
4973 { "chr1.442", 0x400000, 0x177e3139, 3 | BRF_GRA }, // 7
4974
4975 { "sound1.83", 0x800000, 0x98783cfc, 1 | BRF_SND }, // 8 YMZ280b Samples
4976 { "sound2.84", 0x800000, 0xff37e769, 1 | BRF_SND }, // 9
4977 };
4978
4979 STD_ROM_PICK(ejsakura12)
4980 STD_ROM_FN(ejsakura12)
4981
4982 struct BurnDriver BurnDrvEjsakura12 = {
4983 "ejsakura12", "ejsakura", NULL, NULL, "1999",
4984 "E-Jan Sakurasou (Japan, SYS386F V1.2)\0", NULL, "Seibu Kaihatsu", "SYS386F",
4985 NULL, NULL, NULL, NULL,
4986 BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_MISC_POST90S, GBF_MAHJONG, 0,
4987 NULL, ejsakura12RomInfo, ejsakura12RomName, NULL, NULL, NULL, NULL, EjsakuraInputInfo, NULL,
4988 Sys386fInit, DrvExit, Sys386fFrame, Sys386fDraw, DrvScan, &DrvRecalc, 0x2000,
4989 320, 240, 4, 3
4990 };
4991