← Back to branch summary

~ubuntu-branches/debian/sid/mame/sid

« back to all changes in this revision

Viewing changes to src/mame/drivers/blitz68k.c

  • Committer: Package Import Robot
  • Author(s): Jordi Mallach, Emmanuel Kasper, Jordi Mallach
  • Date: 2012-06-05 20:02:23 UTC
  • mfrom: (0.3.1) (0.1.4)
  • Revision ID: package-import@ubuntu.com-20120605200223-gnlpogjrg6oqe9md
Tags: 0.146-1
[ Emmanuel Kasper ]
* New upstream release
* Drop patch to fix man pages section and patches to link with flac 
  and jpeg system lib: all this has been pushed upstream by Cesare Falco
* Add DM-Upload-Allowed: yes field.

[ Jordi Mallach ]
* Create a "gnu" TARGETOS stanza that defines NO_AFFINITY_NP.
* Stop setting TARGETOS to "unix" in d/rules. It should be autodetected,
  and set to the appropriate value.
* mame_manpage_section.patch: Change mame's manpage section to 6 (games),
  in the TH declaration.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/mame/drivers/blitz68k.c
43
43
public:
44
44
        blitz68k_state(const machine_config &mconfig, device_type type, const char *tag)
45
45
                : driver_device(mconfig, type, tag),
46
 
                  m_nvram(*this, "nvram") { }
 
46
                  m_nvram(*this, "nvram"),
 
47
                  m_frame_buffer(*this, "frame_buffer"),
 
48
                  m_blit_romaddr(*this, "blit_romaddr"),
 
49
                  m_blit_attr1_ram(*this, "blit_attr1_ram"),
 
50
                  m_blit_dst_ram_loword(*this, "blitram_loword"),
 
51
                  m_blit_attr2_ram(*this, "blit_attr2_ram"),
 
52
                  m_blit_dst_ram_hiword(*this, "blitram_hiword"),
 
53
                  m_blit_vregs(*this, "blit_vregs"),
 
54
                  m_blit_transpen(*this, "blit_transpen"),
 
55
                  m_leds0(*this, "leds0"),
 
56
                  m_leds1(*this, "leds1"),
 
57
                  m_leds2(*this, "leds2") { }
47
58
 
48
59
        optional_shared_ptr<UINT16>     m_nvram;
49
60
        UINT8 *m_blit_buffer;
50
 
        UINT16 *m_frame_buffer;
51
 
        UINT16 *m_blit_romaddr;
52
 
        UINT16 *m_blit_attr1_ram;
53
 
        UINT16 *m_blit_dst_ram_loword;
54
 
        UINT16 *m_blit_attr2_ram;
55
 
        UINT16 *m_blit_dst_ram_hiword;
56
 
        UINT16 *m_blit_vregs;
57
 
        UINT16 *m_blit_transpen;
58
 
        UINT16 *m_leds[3];
 
61
        optional_shared_ptr<UINT16> m_frame_buffer;
 
62
        optional_shared_ptr<UINT16> m_blit_romaddr;
 
63
        optional_shared_ptr<UINT16> m_blit_attr1_ram;
 
64
        optional_shared_ptr<UINT16> m_blit_dst_ram_loword;
 
65
        optional_shared_ptr<UINT16> m_blit_attr2_ram;
 
66
        optional_shared_ptr<UINT16> m_blit_dst_ram_hiword;
 
67
        optional_shared_ptr<UINT16> m_blit_vregs;
 
68
        optional_shared_ptr<UINT16> m_blit_transpen;
 
69
        optional_shared_ptr<UINT16> m_leds0;
 
70
        optional_shared_ptr<UINT16> m_leds1;
 
71
        optional_shared_ptr<UINT16> m_leds2;
 
72
        DECLARE_WRITE16_MEMBER(blit_copy_w);
 
73
        DECLARE_READ8_MEMBER(blit_status_r);
 
74
        DECLARE_WRITE8_MEMBER(blit_x_w);
 
75
        DECLARE_WRITE8_MEMBER(blit_y_w);
 
76
        DECLARE_WRITE8_MEMBER(blit_xy_w);
 
77
        DECLARE_WRITE8_MEMBER(blit_w_w);
 
78
        DECLARE_WRITE8_MEMBER(blit_h_w);
 
79
        DECLARE_WRITE8_MEMBER(blit_wh_w);
 
80
        DECLARE_WRITE8_MEMBER(blit_addr0_w);
 
81
        DECLARE_WRITE8_MEMBER(blit_addr1_w);
 
82
        DECLARE_WRITE8_MEMBER(blit_addr01_w);
 
83
        DECLARE_WRITE8_MEMBER(blit_addr2_w);
 
84
        DECLARE_WRITE8_MEMBER(blit_pens_w);
 
85
        DECLARE_WRITE8_MEMBER(blit_pen0_w);
 
86
        DECLARE_WRITE8_MEMBER(blit_pen1_w);
 
87
        DECLARE_WRITE8_MEMBER(blit_pen2_w);
 
88
        DECLARE_WRITE8_MEMBER(blit_pen3_w);
 
89
        DECLARE_WRITE8_MEMBER(blit_flag0_w);
 
90
        DECLARE_WRITE8_MEMBER(blit_flag1_w);
 
91
        DECLARE_WRITE8_MEMBER(blit_flipx_w);
 
92
        DECLARE_WRITE8_MEMBER(blit_flipy_w);
 
93
        DECLARE_WRITE8_MEMBER(blit_solid_w);
 
94
        DECLARE_WRITE8_MEMBER(blit_trans_w);
 
95
        DECLARE_WRITE8_MEMBER(blit_flag6_w);
 
96
        DECLARE_WRITE8_MEMBER(blit_flag7_w);
 
97
        DECLARE_WRITE8_MEMBER(blit_flags_w);
 
98
        DECLARE_WRITE8_MEMBER(blit_draw_w);
 
99
        DECLARE_WRITE8_MEMBER(blit_hwyxa_draw_w);
 
100
        DECLARE_READ16_MEMBER(blitter_status_r);
 
101
        DECLARE_WRITE16_MEMBER(lamps_w);
 
102
        DECLARE_READ16_MEMBER(test_r);
 
103
        DECLARE_WRITE16_MEMBER(irq_callback_w);
 
104
        DECLARE_WRITE16_MEMBER(sound_write_w);
 
105
        DECLARE_READ8_MEMBER(bankrob_mcu1_r);
 
106
        DECLARE_READ8_MEMBER(bankrob_mcu2_r);
 
107
        DECLARE_READ8_MEMBER(bankrob_mcu_status_read_r);
 
108
        DECLARE_READ8_MEMBER(bankrob_mcu_status_write_r);
 
109
        DECLARE_WRITE8_MEMBER(bankrob_mcu1_w);
 
110
        DECLARE_WRITE8_MEMBER(bankrob_mcu2_w);
 
111
        DECLARE_READ8_MEMBER(bankroba_mcu1_r);
 
112
        DECLARE_READ8_MEMBER(bankroba_mcu2_r);
 
113
        DECLARE_READ8_MEMBER(bankroba_mcu1_status_write_r);
 
114
        DECLARE_READ8_MEMBER(bankroba_mcu2_status_write_r);
 
115
        DECLARE_WRITE8_MEMBER(bankroba_mcu1_w);
 
116
        DECLARE_WRITE8_MEMBER(bankroba_mcu2_w);
 
117
        DECLARE_WRITE16_MEMBER(cjffruit_leds1_w);
 
118
        DECLARE_WRITE16_MEMBER(cjffruit_leds2_w);
 
119
        DECLARE_WRITE16_MEMBER(cjffruit_leds3_w);
 
120
        DECLARE_READ8_MEMBER(crtc_r);
 
121
        DECLARE_WRITE8_MEMBER(crtc_w);
 
122
        DECLARE_READ16_MEMBER(cjffruit_mcu_r);
 
123
        DECLARE_WRITE16_MEMBER(cjffruit_mcu_w);
 
124
        DECLARE_READ16_MEMBER(deucesw2_mcu_r);
 
125
        DECLARE_WRITE16_MEMBER(deucesw2_mcu_w);
 
126
        DECLARE_WRITE16_MEMBER(deucesw2_leds1_w);
 
127
        DECLARE_WRITE16_MEMBER(deucesw2_leds2_w);
 
128
        DECLARE_WRITE16_MEMBER(deucesw2_leds3_w);
 
129
        DECLARE_READ8_MEMBER(dualgame_mcu1_r);
 
130
        DECLARE_READ8_MEMBER(dualgame_mcu2_r);
 
131
        DECLARE_READ8_MEMBER(dualgame_mcu_status_read_r);
 
132
        DECLARE_READ8_MEMBER(dualgame_mcu_status_write_r);
 
133
        DECLARE_WRITE8_MEMBER(dualgame_mcu1_w);
 
134
        DECLARE_WRITE8_MEMBER(dualgame_mcu2_w);
 
135
        DECLARE_READ16_MEMBER(hermit_mcu_r);
 
136
        DECLARE_WRITE16_MEMBER(hermit_mcu_w);
 
137
        DECLARE_WRITE16_MEMBER(hermit_leds1_w);
 
138
        DECLARE_WRITE16_MEMBER(hermit_leds2_w);
 
139
        DECLARE_READ16_MEMBER(hermit_track_r);
 
140
        DECLARE_READ8_MEMBER(maxidbl_mcu1_r);
 
141
        DECLARE_READ8_MEMBER(maxidbl_mcu2_r);
 
142
        DECLARE_READ8_MEMBER(maxidbl_mcu_status_read_r);
 
143
        DECLARE_READ8_MEMBER(maxidbl_mcu_status_write_r);
 
144
        DECLARE_WRITE8_MEMBER(maxidbl_mcu1_w);
 
145
        DECLARE_WRITE8_MEMBER(maxidbl_mcu2_w);
 
146
        void show_leds123();
 
147
        void show_leds12();
59
148
};
60
149
 
61
150
/*************************************************************************************************************
151
240
*************************************************************************************************************/
152
241
 
153
242
 
154
 
static WRITE16_HANDLER( blit_copy_w )
 
243
WRITE16_MEMBER(blitz68k_state::blit_copy_w)
155
244
{
156
 
        blitz68k_state *state = space->machine().driver_data<blitz68k_state>();
157
 
        UINT8 *blit_rom = space->machine().region("blitter")->base();
 
245
        UINT8 *blit_rom = memregion("blitter")->base();
158
246
        UINT32 blit_dst_xpos;
159
247
        UINT32 blit_dst_ypos;
160
248
        int x,y,x_size,y_size;
161
249
        UINT32 src;
162
250
 
163
 
        logerror("blit copy %04x %04x %04x %04x %04x\n", state->m_blit_romaddr[0], state->m_blit_attr1_ram[0], state->m_blit_dst_ram_loword[0], state->m_blit_attr2_ram[0], state->m_blit_dst_ram_hiword[0] );
164
 
        logerror("blit vregs %04x %04x %04x %04x\n",state->m_blit_vregs[0/2],state->m_blit_vregs[2/2],state->m_blit_vregs[4/2],state->m_blit_vregs[6/2]);
165
 
        logerror("blit transpen %04x %04x %04x %04x %04x %04x %04x %04x\n",state->m_blit_transpen[0/2],state->m_blit_transpen[2/2],state->m_blit_transpen[4/2],state->m_blit_transpen[6/2],
166
 
                                                                       state->m_blit_transpen[8/2],state->m_blit_transpen[10/2],state->m_blit_transpen[12/2],state->m_blit_transpen[14/2]);
167
 
 
168
 
        blit_dst_xpos = (state->m_blit_dst_ram_loword[0] & 0x00ff)*2;
169
 
        blit_dst_ypos = ((state->m_blit_dst_ram_loword[0] & 0xff00)>>8);
170
 
 
171
 
        y_size = (0x100-((state->m_blit_attr2_ram[0] & 0xff00)>>8));
172
 
        x_size = (state->m_blit_attr2_ram[0] & 0x00ff)*2;
 
251
        logerror("blit copy %04x %04x %04x %04x %04x\n", m_blit_romaddr[0], m_blit_attr1_ram[0], m_blit_dst_ram_loword[0], m_blit_attr2_ram[0], m_blit_dst_ram_hiword[0] );
 
252
        logerror("blit vregs %04x %04x %04x %04x\n",m_blit_vregs[0/2],m_blit_vregs[2/2],m_blit_vregs[4/2],m_blit_vregs[6/2]);
 
253
        logerror("blit transpen %04x %04x %04x %04x %04x %04x %04x %04x\n",m_blit_transpen[0/2],m_blit_transpen[2/2],m_blit_transpen[4/2],m_blit_transpen[6/2],
 
254
                                                                       m_blit_transpen[8/2],m_blit_transpen[10/2],m_blit_transpen[12/2],m_blit_transpen[14/2]);
 
255
 
 
256
        blit_dst_xpos = (m_blit_dst_ram_loword[0] & 0x00ff)*2;
 
257
        blit_dst_ypos = ((m_blit_dst_ram_loword[0] & 0xff00)>>8);
 
258
 
 
259
        y_size = (0x100-((m_blit_attr2_ram[0] & 0xff00)>>8));
 
260
        x_size = (m_blit_attr2_ram[0] & 0x00ff)*2;
173
261
 
174
262
        /* rounding around for 0 size */
175
263
        if(x_size == 0) { x_size = 0x200; }
177
265
        /* TODO: used by steaser "Game Over" msg on attract mode*/
178
266
//  if(y_size == 1) { y_size = 32; }
179
267
 
180
 
        src = state->m_blit_romaddr[0] | (state->m_blit_attr1_ram[0] & 0x1f00)<<8;
181
 
//  src|= (state->m_blit_transpen[0xc/2] & 0x0100)<<12;
 
268
        src = m_blit_romaddr[0] | (m_blit_attr1_ram[0] & 0x1f00)<<8;
 
269
//  src|= (m_blit_transpen[0xc/2] & 0x0100)<<12;
182
270
 
183
271
        for(y=0;y<y_size;y++)
184
272
        {
186
274
                {
187
275
                        int drawx = (blit_dst_xpos+x)&0x1ff;
188
276
                        int drawy = (blit_dst_ypos+y)&0x0ff;
189
 
                        if(state->m_blit_transpen[0x8/2] & 0x100)
190
 
                                state->m_blit_buffer[drawy*512+drawx] = ((state->m_blit_vregs[0] & 0xf00)>>8);
 
277
                        if(m_blit_transpen[0x8/2] & 0x100)
 
278
                                m_blit_buffer[drawy*512+drawx] = ((m_blit_vregs[0] & 0xf00)>>8);
191
279
                        else
192
280
                        {
193
281
                                UINT8 pen_helper;
194
282
 
195
283
                                pen_helper = blit_rom[src] & 0xff;
196
 
                                if(state->m_blit_transpen[0xa/2] & 0x100) //pen is opaque register
 
284
                                if(m_blit_transpen[0xa/2] & 0x100) //pen is opaque register
197
285
                                {
198
286
                                        if(pen_helper)
199
 
                                                state->m_blit_buffer[drawy*512+drawx] = ((pen_helper & 0xff) <= 3) ? ((state->m_blit_vregs[pen_helper] & 0xf00)>>8) : blit_rom[src];
 
287
                                                m_blit_buffer[drawy*512+drawx] = ((pen_helper & 0xff) <= 3) ? ((m_blit_vregs[pen_helper] & 0xf00)>>8) : blit_rom[src];
200
288
                                }
201
289
                                else
202
 
                                        state->m_blit_buffer[drawy*512+drawx] = ((pen_helper & 0xff) <= 3) ? ((state->m_blit_vregs[pen_helper] & 0xf00)>>8) : blit_rom[src];
 
290
                                        m_blit_buffer[drawy*512+drawx] = ((pen_helper & 0xff) <= 3) ? ((m_blit_vregs[pen_helper] & 0xf00)>>8) : blit_rom[src];
203
291
                        }
204
292
 
205
293
                        src++;
214
302
 
215
303
*************************************************************************************************************/
216
304
 
217
 
static READ8_HANDLER( blit_status_r )
 
305
READ8_MEMBER(blitz68k_state::blit_status_r)
218
306
{
219
307
        return 0;       // bit 0 = blitter busy
220
308
}
221
309
 
222
 
static WRITE8_HANDLER( blit_x_w )
 
310
WRITE8_MEMBER(blitz68k_state::blit_x_w)
223
311
{
224
312
        blit.x = data;
225
313
}
226
 
static WRITE8_HANDLER( blit_y_w )
 
314
WRITE8_MEMBER(blitz68k_state::blit_y_w)
227
315
{
228
316
        blit.y = data;
229
317
}
230
 
static WRITE8_HANDLER( blit_xy_w )
 
318
WRITE8_MEMBER(blitz68k_state::blit_xy_w)
231
319
{
232
320
        if (offset)
233
321
                blit_x_w(space, offset, data);
236
324
}
237
325
 
238
326
 
239
 
static WRITE8_HANDLER( blit_w_w )
 
327
WRITE8_MEMBER(blitz68k_state::blit_w_w)
240
328
{
241
329
        blit.w = data;
242
330
}
243
 
static WRITE8_HANDLER( blit_h_w )
 
331
WRITE8_MEMBER(blitz68k_state::blit_h_w)
244
332
{
245
333
        blit.h = data;
246
334
}
247
 
static WRITE8_HANDLER( blit_wh_w )
 
335
WRITE8_MEMBER(blitz68k_state::blit_wh_w)
248
336
{
249
337
        if (offset)
250
338
                blit_w_w(space, offset, data-1);
253
341
}
254
342
 
255
343
 
256
 
static WRITE8_HANDLER( blit_addr0_w )
 
344
WRITE8_MEMBER(blitz68k_state::blit_addr0_w)
257
345
{
258
346
        blit.addr[0] = data;
259
347
}
260
 
static WRITE8_HANDLER( blit_addr1_w )
 
348
WRITE8_MEMBER(blitz68k_state::blit_addr1_w)
261
349
{
262
350
        blit.addr[1] = data;
263
351
}
264
 
static WRITE8_HANDLER( blit_addr01_w )
 
352
WRITE8_MEMBER(blitz68k_state::blit_addr01_w)
265
353
{
266
354
        if (offset)
267
355
                blit_addr0_w(space, offset, data);
268
356
        else
269
357
                blit_addr1_w(space, offset, data);
270
358
}
271
 
static WRITE8_HANDLER( blit_addr2_w )
 
359
WRITE8_MEMBER(blitz68k_state::blit_addr2_w)
272
360
{
273
361
        blit.addr[2] = data;
274
362
}
275
363
 
276
364
 
277
 
static WRITE8_HANDLER( blit_pens_w )
 
365
WRITE8_MEMBER(blitz68k_state::blit_pens_w)
278
366
{
279
367
        blit.pen[offset] = data;
280
368
}
281
 
static WRITE8_HANDLER( blit_pen0_w )
 
369
WRITE8_MEMBER(blitz68k_state::blit_pen0_w)
282
370
{
283
371
        blit.pen[0] = data;
284
372
}
285
 
static WRITE8_HANDLER( blit_pen1_w )
 
373
WRITE8_MEMBER(blitz68k_state::blit_pen1_w)
286
374
{
287
375
        blit.pen[1] = data;
288
376
}
289
 
static WRITE8_HANDLER( blit_pen2_w )
 
377
WRITE8_MEMBER(blitz68k_state::blit_pen2_w)
290
378
{
291
379
        blit.pen[2] = data;
292
380
}
293
 
static WRITE8_HANDLER( blit_pen3_w )
 
381
WRITE8_MEMBER(blitz68k_state::blit_pen3_w)
294
382
{
295
383
        blit.pen[3] = data;
296
384
}
297
385
 
298
386
 
299
 
static WRITE8_HANDLER( blit_flag0_w )
 
387
WRITE8_MEMBER(blitz68k_state::blit_flag0_w)
300
388
{
301
389
        blit.flag[0] = data;
302
390
}
303
 
static WRITE8_HANDLER( blit_flag1_w )
 
391
WRITE8_MEMBER(blitz68k_state::blit_flag1_w)
304
392
{
305
393
        blit.flag[1] = data;
306
394
}
307
 
static WRITE8_HANDLER( blit_flipx_w )
 
395
WRITE8_MEMBER(blitz68k_state::blit_flipx_w)
308
396
{
309
397
        blit.flipx = data;
310
398
}
311
 
static WRITE8_HANDLER( blit_flipy_w )
 
399
WRITE8_MEMBER(blitz68k_state::blit_flipy_w)
312
400
{
313
401
        blit.flipy = data;
314
402
}
315
 
static WRITE8_HANDLER( blit_solid_w )
 
403
WRITE8_MEMBER(blitz68k_state::blit_solid_w)
316
404
{
317
405
        blit.solid = data;
318
406
}
319
 
static WRITE8_HANDLER( blit_trans_w )
 
407
WRITE8_MEMBER(blitz68k_state::blit_trans_w)
320
408
{
321
409
        blit.trans = data;
322
410
}
323
 
static WRITE8_HANDLER( blit_flag6_w )
 
411
WRITE8_MEMBER(blitz68k_state::blit_flag6_w)
324
412
{
325
413
        blit.flag[6] = data;
326
414
}
327
 
static WRITE8_HANDLER( blit_flag7_w )
 
415
WRITE8_MEMBER(blitz68k_state::blit_flag7_w)
328
416
{
329
417
        blit.flag[7] = data;
330
418
}
331
419
 
332
 
static WRITE8_HANDLER( blit_flags_w )
 
420
WRITE8_MEMBER(blitz68k_state::blit_flags_w)
333
421
{
334
422
        switch(offset)
335
423
        {
340
428
        }
341
429
}
342
430
 
343
 
static WRITE8_HANDLER( blit_draw_w )
 
431
WRITE8_MEMBER(blitz68k_state::blit_draw_w)
344
432
{
345
 
        blitz68k_state *state = space->machine().driver_data<blitz68k_state>();
346
 
        UINT8 *blit_rom  = space->machine().region("blitter")->base();
347
 
        int blit_romsize = space->machine().region("blitter")->bytes();
 
433
        UINT8 *blit_rom  = memregion("blitter")->base();
 
434
        int blit_romsize = memregion("blitter")->bytes();
348
435
        UINT32 blit_dst_xpos;
349
436
        UINT32 blit_dst_ypos;
350
437
        int x, y, x_size, y_size;
351
438
        UINT32 src;
352
439
 
353
 
        logerror("%s: blit x=%02x y=%02x w=%02x h=%02x addr=%02x%02x%02x pens=%02x %02x %02x %02x flag=%02x %02x %02x %02x - %02x %02x %02x %02x\n", space->machine().describe_context(),
 
440
        logerror("%s: blit x=%02x y=%02x w=%02x h=%02x addr=%02x%02x%02x pens=%02x %02x %02x %02x flag=%02x %02x %02x %02x - %02x %02x %02x %02x\n", machine().describe_context(),
354
441
                                blit.x,  blit.y, blit.w, blit.h,
355
442
                                blit.addr[2], blit.addr[1], blit.addr[0],
356
443
                                blit.pen[0], blit.pen[1], blit.pen[2], blit.pen[3],
397
484
                                if (pen <= 3)
398
485
                                        pen = blit.pen[pen] & 0xf;
399
486
 
400
 
                                state->m_blit_buffer[drawy * 512 + drawx] = pen;
 
487
                                m_blit_buffer[drawy * 512 + drawx] = pen;
401
488
                        }
402
489
                }
403
490
        }
409
496
        blit.y = blit_dst_ypos;
410
497
}
411
498
 
412
 
static WRITE8_HANDLER( blit_hwyxa_draw_w )
 
499
WRITE8_MEMBER(blitz68k_state::blit_hwyxa_draw_w)
413
500
{
414
501
        switch (offset)
415
502
        {
428
515
    Outputs
429
516
*************************************************************************************************************/
430
517
 
431
 
static void show_leds123(blitz68k_state *state)
 
518
void blitz68k_state::show_leds123()
432
519
{
433
520
#ifdef MAME_DEBUG
434
 
        popmessage("led %02x %02x %02x", state->m_leds[0][0]>>8, state->m_leds[1][0]>>8, state->m_leds[2][0]>>8);
 
521
        popmessage("led %02x %02x %02x", m_leds0[0]>>8, m_leds1[0]>>8, m_leds2[0]>>8);
435
522
#endif
436
523
}
437
 
static void show_leds12(blitz68k_state *state)
 
524
void blitz68k_state::show_leds12()
438
525
{
439
526
#ifdef MAME_DEBUG
440
 
        popmessage("led %02x %02x", state->m_leds[0][0]>>8, state->m_leds[1][0]>>8);
 
527
        popmessage("led %02x %02x", m_leds0[0]>>8, m_leds1[0]>>8);
441
528
#endif
442
529
}
443
530
 
448
535
*************************************************************************************************************/
449
536
 
450
537
/*bit 0 is the blitter busy flag*/
451
 
static READ16_HANDLER( blitter_status_r )
 
538
READ16_MEMBER(blitz68k_state::blitter_status_r)
452
539
{
453
540
        return 0;
454
541
}
455
542
 
456
543
/*TODO*/
457
 
static WRITE16_HANDLER( lamps_w )
 
544
WRITE16_MEMBER(blitz68k_state::lamps_w)
458
545
{
459
546
//  popmessage("%02x",data);
460
547
}
461
548
 
462
 
static READ16_HANDLER( test_r )
 
549
READ16_MEMBER(blitz68k_state::test_r)
463
550
{
464
 
        return 0xffff;//space->machine().rand();
 
551
        return 0xffff;//machine().rand();
465
552
}
466
553
 
467
554
#if 0
468
 
static WRITE16_HANDLER( irq_callback_w )
 
555
WRITE16_MEMBER(blitz68k_state::irq_callback_w)
469
556
{
470
557
//  popmessage("%02x",data);
471
 
        cputag_set_input_line(space->machine(), "maincpu", 3, HOLD_LINE );
 
558
        cputag_set_input_line(machine(), "maincpu", 3, HOLD_LINE );
472
559
}
473
560
 
474
 
static WRITE16_HANDLER( sound_write_w )
 
561
WRITE16_MEMBER(blitz68k_state::sound_write_w)
475
562
{
476
563
        popmessage("%02x",data);
477
564
        dac_data_w(0, data & 0x0f);             /* Sound DAC? */
478
565
}
479
566
#endif
480
567
 
481
 
static ADDRESS_MAP_START( ilpag_map, AS_PROGRAM, 16 )
 
568
static ADDRESS_MAP_START( ilpag_map, AS_PROGRAM, 16, blitz68k_state )
482
569
        AM_RANGE(0x000000, 0x0fffff) AM_ROM
483
570
        AM_RANGE(0x100000, 0x1fffff) AM_ROM AM_REGION("blitter", 0)
484
571
        AM_RANGE(0x200000, 0x20ffff) AM_RAM AM_SHARE("nvram")
486
573
//  AM_RANGE(0x800000, 0x800001) AM_READ(test_r)
487
574
//  AM_RANGE(0x880000, 0x880001) AM_READ(test_r)
488
575
 
489
 
        AM_RANGE(0x900000, 0x900001) AM_DEVWRITE8_MODERN("ramdac",ramdac_device, index_w, 0xff00 )
490
 
        AM_RANGE(0x900002, 0x900003) AM_DEVWRITE8_MODERN("ramdac",ramdac_device, pal_w, 0xff00 )
491
 
        AM_RANGE(0x900004, 0x900005) AM_DEVWRITE8_MODERN("ramdac",ramdac_device, mask_w, 0xff00 )
492
 
        AM_RANGE(0x980000, 0x98000f) AM_RAM AM_BASE_MEMBER(blitz68k_state, m_blit_transpen) //video registers for the blitter write
493
 
        AM_RANGE(0x990000, 0x990007) AM_RAM AM_BASE_MEMBER(blitz68k_state, m_blit_vregs) //pens
494
 
        AM_RANGE(0x998000, 0x998001) AM_RAM AM_BASE_MEMBER(blitz68k_state, m_blit_romaddr)
495
 
        AM_RANGE(0x9a0000, 0x9a0001) AM_RAM AM_BASE_MEMBER(blitz68k_state, m_blit_attr1_ram)
496
 
        AM_RANGE(0x9a8000, 0x9a8001) AM_RAM AM_BASE_MEMBER(blitz68k_state, m_blit_dst_ram_loword)
497
 
        AM_RANGE(0x9b0000, 0x9b0001) AM_RAM AM_BASE_MEMBER(blitz68k_state, m_blit_attr2_ram)
498
 
        AM_RANGE(0x9b8000, 0x9b8001) AM_RAM_WRITE( blit_copy_w ) AM_BASE_MEMBER(blitz68k_state, m_blit_dst_ram_hiword)
 
576
        AM_RANGE(0x900000, 0x900001) AM_DEVWRITE8("ramdac",ramdac_device, index_w, 0xff00 )
 
577
        AM_RANGE(0x900002, 0x900003) AM_DEVWRITE8("ramdac",ramdac_device, pal_w, 0xff00 )
 
578
        AM_RANGE(0x900004, 0x900005) AM_DEVWRITE8("ramdac",ramdac_device, mask_w, 0xff00 )
 
579
        AM_RANGE(0x980000, 0x98000f) AM_RAM AM_SHARE("blit_transpen") //video registers for the blitter write
 
580
        AM_RANGE(0x990000, 0x990007) AM_RAM AM_SHARE("blit_vregs") //pens
 
581
        AM_RANGE(0x998000, 0x998001) AM_RAM AM_SHARE("blit_romaddr")
 
582
        AM_RANGE(0x9a0000, 0x9a0001) AM_RAM AM_SHARE("blit_attr1_ram")
 
583
        AM_RANGE(0x9a8000, 0x9a8001) AM_RAM AM_SHARE("blitram_loword")
 
584
        AM_RANGE(0x9b0000, 0x9b0001) AM_RAM AM_SHARE("blit_attr2_ram")
 
585
        AM_RANGE(0x9b8000, 0x9b8001) AM_RAM_WRITE(blit_copy_w ) AM_SHARE("blitram_hiword")
499
586
        AM_RANGE(0x9e0000, 0x9e0001) AM_READ(blitter_status_r)
500
587
 
501
588
        AM_RANGE(0xc00000, 0xc00001) AM_WRITE(lamps_w)
505
592
//  AM_RANGE(0xc00300, 0xc00301) AM_WRITE(irq_callback_w)
506
593
ADDRESS_MAP_END
507
594
 
508
 
static ADDRESS_MAP_START( steaser_map, AS_PROGRAM, 16 )
 
595
static ADDRESS_MAP_START( steaser_map, AS_PROGRAM, 16, blitz68k_state )
509
596
        AM_RANGE(0x000000, 0x03ffff) AM_ROM
510
597
        AM_RANGE(0x100000, 0x1fffff) AM_ROM AM_REGION("blitter", 0)
511
598
        AM_RANGE(0x200000, 0x20ffff) AM_RAM AM_SHARE("nvram")
515
602
        AM_RANGE(0x880000, 0x880001) AM_READ(test_r)
516
603
//  AM_RANGE(0x8c0000, 0x8c0001) AM_WRITE(sound_write_w)
517
604
 
518
 
        AM_RANGE(0x900000, 0x900001) AM_DEVWRITE8_MODERN("ramdac",ramdac_device, index_w, 0xff00 )
519
 
        AM_RANGE(0x900002, 0x900003) AM_DEVWRITE8_MODERN("ramdac",ramdac_device, pal_w, 0xff00 )
520
 
        AM_RANGE(0x900004, 0x900005) AM_DEVWRITE8_MODERN("ramdac",ramdac_device, mask_w, 0xff00 )
 
605
        AM_RANGE(0x900000, 0x900001) AM_DEVWRITE8("ramdac",ramdac_device, index_w, 0xff00 )
 
606
        AM_RANGE(0x900002, 0x900003) AM_DEVWRITE8("ramdac",ramdac_device, pal_w, 0xff00 )
 
607
        AM_RANGE(0x900004, 0x900005) AM_DEVWRITE8("ramdac",ramdac_device, mask_w, 0xff00 )
521
608
        AM_RANGE(0x940000, 0x940001) AM_WRITENOP //? Seems a dword write for some read, written consecutively
522
 
        AM_RANGE(0x980000, 0x98000f) AM_RAM AM_BASE_MEMBER(blitz68k_state, m_blit_transpen)//probably transparency pens
523
 
        AM_RANGE(0x990000, 0x990005) AM_RAM AM_BASE_MEMBER(blitz68k_state, m_blit_vregs)
524
 
        AM_RANGE(0x998000, 0x998001) AM_RAM AM_BASE_MEMBER(blitz68k_state, m_blit_romaddr)
525
 
        AM_RANGE(0x9a0000, 0x9a0001) AM_RAM AM_BASE_MEMBER(blitz68k_state, m_blit_attr1_ram)
526
 
        AM_RANGE(0x9a8000, 0x9a8001) AM_RAM AM_BASE_MEMBER(blitz68k_state, m_blit_dst_ram_loword)
527
 
        AM_RANGE(0x9b0000, 0x9b0001) AM_RAM AM_BASE_MEMBER(blitz68k_state, m_blit_attr2_ram)
528
 
        AM_RANGE(0x9b8000, 0x9b8001) AM_RAM_WRITE( blit_copy_w ) AM_BASE_MEMBER(blitz68k_state, m_blit_dst_ram_hiword)
 
609
        AM_RANGE(0x980000, 0x98000f) AM_RAM AM_SHARE("blit_transpen")//probably transparency pens
 
610
        AM_RANGE(0x990000, 0x990005) AM_RAM AM_SHARE("blit_vregs")
 
611
        AM_RANGE(0x998000, 0x998001) AM_RAM AM_SHARE("blit_romaddr")
 
612
        AM_RANGE(0x9a0000, 0x9a0001) AM_RAM AM_SHARE("blit_attr1_ram")
 
613
        AM_RANGE(0x9a8000, 0x9a8001) AM_RAM AM_SHARE("blitram_loword")
 
614
        AM_RANGE(0x9b0000, 0x9b0001) AM_RAM AM_SHARE("blit_attr2_ram")
 
615
        AM_RANGE(0x9b8000, 0x9b8001) AM_RAM_WRITE(blit_copy_w ) AM_SHARE("blitram_hiword")
529
616
        AM_RANGE(0x9c0002, 0x9c0003) AM_READNOP //pen control?
530
617
        AM_RANGE(0x9d0000, 0x9d0001) AM_READNOP //?
531
618
        AM_RANGE(0x9e0000, 0x9e0001) AM_READ(blitter_status_r)
543
630
*************************************************************************************************************/
544
631
 
545
632
// MCU simulation (to be done)
546
 
static READ8_HANDLER( bankrob_mcu1_r )
547
 
{
548
 
        UINT8 ret = 0;  // space->machine().rand() gives "interesting" results
549
 
        logerror("%s: mcu1 reads %02x\n", space->machine().describe_context(), ret);
550
 
        return ret;
551
 
}
552
 
static READ8_HANDLER( bankrob_mcu2_r )
553
 
{
554
 
        UINT8 ret = 0;  // space->machine().rand() gives "interesting" results
555
 
        logerror("%s: mcu2 reads %02x\n", space->machine().describe_context(), ret);
556
 
        return ret;
557
 
}
558
 
 
559
 
static READ8_HANDLER( bankrob_mcu_status_read_r )
560
 
{
561
 
        return 0x03;    // bit 0 = MCU1, bit 1 = MCU2. Active high.
562
 
}
563
 
 
564
 
static READ8_HANDLER( bankrob_mcu_status_write_r )
565
 
{
566
 
        return 0x03;    // bit 0 = MCU1, bit 1 = MCU2. Active high.
567
 
}
568
 
 
569
 
static WRITE8_HANDLER( bankrob_mcu1_w )
570
 
{
571
 
        logerror("%s: mcu1 written with %02x\n", space->machine().describe_context(), data);
572
 
}
573
 
static WRITE8_HANDLER( bankrob_mcu2_w )
574
 
{
575
 
        logerror("%s: mcu2 written with %02x\n", space->machine().describe_context(), data);
576
 
}
577
 
 
578
 
static ADDRESS_MAP_START( bankrob_map, AS_PROGRAM, 16 )
 
633
READ8_MEMBER(blitz68k_state::bankrob_mcu1_r)
 
634
{
 
635
        UINT8 ret = 0;  // machine().rand() gives "interesting" results
 
636
        logerror("%s: mcu1 reads %02x\n", machine().describe_context(), ret);
 
637
        return ret;
 
638
}
 
639
READ8_MEMBER(blitz68k_state::bankrob_mcu2_r)
 
640
{
 
641
        UINT8 ret = 0;  // machine().rand() gives "interesting" results
 
642
        logerror("%s: mcu2 reads %02x\n", machine().describe_context(), ret);
 
643
        return ret;
 
644
}
 
645
 
 
646
READ8_MEMBER(blitz68k_state::bankrob_mcu_status_read_r)
 
647
{
 
648
        return 0x03;    // bit 0 = MCU1, bit 1 = MCU2. Active high.
 
649
}
 
650
 
 
651
READ8_MEMBER(blitz68k_state::bankrob_mcu_status_write_r)
 
652
{
 
653
        return 0x03;    // bit 0 = MCU1, bit 1 = MCU2. Active high.
 
654
}
 
655
 
 
656
WRITE8_MEMBER(blitz68k_state::bankrob_mcu1_w)
 
657
{
 
658
        logerror("%s: mcu1 written with %02x\n", machine().describe_context(), data);
 
659
}
 
660
WRITE8_MEMBER(blitz68k_state::bankrob_mcu2_w)
 
661
{
 
662
        logerror("%s: mcu2 written with %02x\n", machine().describe_context(), data);
 
663
}
 
664
 
 
665
static ADDRESS_MAP_START( bankrob_map, AS_PROGRAM, 16, blitz68k_state )
579
666
        AM_RANGE(0x000000, 0x03ffff) AM_ROM
580
667
        AM_RANGE(0x100000, 0x10ffff) AM_RAM
581
668
 
582
 
        AM_RANGE(0x220000, 0x220001) AM_DEVREAD8_MODERN("ramdac",ramdac_device, index_r, 0xff00 )
583
 
        AM_RANGE(0x220002, 0x220003) AM_DEVREAD8_MODERN("ramdac",ramdac_device, pal_r, 0xff00 )
 
669
        AM_RANGE(0x220000, 0x220001) AM_DEVREAD8("ramdac",ramdac_device, index_r, 0xff00 )
 
670
        AM_RANGE(0x220002, 0x220003) AM_DEVREAD8("ramdac",ramdac_device, pal_r, 0xff00 )
584
671
 
585
672
        AM_RANGE(0x240000, 0x240001) AM_WRITE8(blit_addr0_w, 0xff00)
586
673
        AM_RANGE(0x240002, 0x240003) AM_WRITE8(blit_addr1_w, 0xff00)
612
699
        AM_RANGE(0x2e000c, 0x2e000d) AM_WRITE8(blit_flag6_w, 0xff00)
613
700
        AM_RANGE(0x2e000e, 0x2e000f) AM_WRITE8(blit_flag7_w, 0xff00)
614
701
 
615
 
        AM_RANGE(0x300000, 0x300001) AM_DEVWRITE8_MODERN("ramdac",ramdac_device, index_w, 0xff00 )
616
 
        AM_RANGE(0x300002, 0x300003) AM_DEVWRITE8_MODERN("ramdac",ramdac_device, pal_w, 0xff00 )
617
 
        AM_RANGE(0x300004, 0x300005) AM_DEVWRITE8_MODERN("ramdac",ramdac_device, mask_w, 0xff00 )
 
702
        AM_RANGE(0x300000, 0x300001) AM_DEVWRITE8("ramdac",ramdac_device, index_w, 0xff00 )
 
703
        AM_RANGE(0x300002, 0x300003) AM_DEVWRITE8("ramdac",ramdac_device, pal_w, 0xff00 )
 
704
        AM_RANGE(0x300004, 0x300005) AM_DEVWRITE8("ramdac",ramdac_device, mask_w, 0xff00 )
618
705
 
619
706
        AM_RANGE(0x400000, 0x400001) AM_READ8(bankrob_mcu_status_write_r, 0x00ff)
620
707
        AM_RANGE(0x400002, 0x400003) AM_READ8(bankrob_mcu_status_read_r,  0x00ff)
622
709
        AM_RANGE(0x400004, 0x400005) AM_READWRITE8(bankrob_mcu1_r, bankrob_mcu1_w, 0x00ff)
623
710
        AM_RANGE(0x400006, 0x400007) AM_READWRITE8(bankrob_mcu2_r, bankrob_mcu2_w, 0xff00)
624
711
 
625
 
        AM_RANGE(0x800000, 0x800001) AM_DEVREADWRITE8_MODERN("crtc", mc6845_device, status_r,   address_w,  0xff00)     // triggered by MCU?
626
 
        AM_RANGE(0x800002, 0x800003) AM_DEVREADWRITE8_MODERN("crtc", mc6845_device, register_r, register_w, 0xff00)
 
712
        AM_RANGE(0x800000, 0x800001) AM_DEVREADWRITE8("crtc", mc6845_device, status_r,   address_w,  0xff00)    // triggered by MCU?
 
713
        AM_RANGE(0x800002, 0x800003) AM_DEVREADWRITE8("crtc", mc6845_device, register_r, register_w, 0xff00)
627
714
ADDRESS_MAP_END
628
715
 
629
716
// bankroba:
630
717
 
631
718
// MCU simulation (to be done)
632
 
static READ8_HANDLER( bankroba_mcu1_r )
 
719
READ8_MEMBER(blitz68k_state::bankroba_mcu1_r)
633
720
{
634
 
        UINT8 ret = space->machine().rand();    // space->machine().rand() gives "interesting" results
635
 
        logerror("%s: mcu1 reads %02x\n", space->machine().describe_context(), ret);
 
721
        UINT8 ret = machine().rand();   // machine().rand() gives "interesting" results
 
722
        logerror("%s: mcu1 reads %02x\n", machine().describe_context(), ret);
636
723
        return ret;
637
724
}
638
 
static READ8_HANDLER( bankroba_mcu2_r )
 
725
READ8_MEMBER(blitz68k_state::bankroba_mcu2_r)
639
726
{
640
 
        UINT8 ret = space->machine().rand();    // space->machine().rand() gives "interesting" results
641
 
        logerror("%s: mcu2 reads %02x\n", space->machine().describe_context(), ret);
 
727
        UINT8 ret = machine().rand();   // machine().rand() gives "interesting" results
 
728
        logerror("%s: mcu2 reads %02x\n", machine().describe_context(), ret);
642
729
        return ret;
643
730
}
644
731
 
645
 
static READ8_HANDLER( bankroba_mcu1_status_write_r )
 
732
READ8_MEMBER(blitz68k_state::bankroba_mcu1_status_write_r)
646
733
{
647
734
        return 0x00;    // bit 0 = MCU1. Active low.
648
735
}
649
 
static READ8_HANDLER( bankroba_mcu2_status_write_r )
 
736
READ8_MEMBER(blitz68k_state::bankroba_mcu2_status_write_r)
650
737
{
651
738
        return 0x01;    // bit 0 = MCU2. Active high.
652
739
}
653
740
 
654
 
static WRITE8_HANDLER( bankroba_mcu1_w )
 
741
WRITE8_MEMBER(blitz68k_state::bankroba_mcu1_w)
655
742
{
656
 
        logerror("%s: mcu1 written with %02x\n", space->machine().describe_context(), data);
 
743
        logerror("%s: mcu1 written with %02x\n", machine().describe_context(), data);
657
744
}
658
 
static WRITE8_HANDLER( bankroba_mcu2_w )
 
745
WRITE8_MEMBER(blitz68k_state::bankroba_mcu2_w)
659
746
{
660
 
        logerror("%s: mcu2 written with %02x\n", space->machine().describe_context(), data);
 
747
        logerror("%s: mcu2 written with %02x\n", machine().describe_context(), data);
661
748
}
662
749
 
663
 
static ADDRESS_MAP_START( bankroba_map, AS_PROGRAM, 16 )
 
750
static ADDRESS_MAP_START( bankroba_map, AS_PROGRAM, 16, blitz68k_state )
664
751
        AM_RANGE(0x000000, 0x03ffff) AM_ROM
665
752
        AM_RANGE(0x200000, 0x20ffff) AM_RAM
666
753
 
667
 
        AM_RANGE(0x800000, 0x800001) AM_WRITE8(bankroba_mcu1_r, 0x00ff) // lev 4
 
754
        AM_RANGE(0x800000, 0x800001) AM_READ8(bankroba_mcu1_r, 0x00ff)  // lev 4
668
755
        AM_RANGE(0x840000, 0x840001) AM_WRITE8(bankroba_mcu1_w, 0x00ff)
669
756
 
670
 
        AM_RANGE(0x880000, 0x880001) AM_WRITE8(bankroba_mcu2_r, 0x00ff) // lev 3
 
757
        AM_RANGE(0x880000, 0x880001) AM_READ8(bankroba_mcu2_r, 0x00ff)  // lev 3
671
758
        AM_RANGE(0x8c0000, 0x8c0001) AM_WRITE8(bankroba_mcu2_w, 0x00ff)
672
759
 
673
 
        AM_RANGE(0x900000, 0x900001) AM_DEVWRITE8_MODERN("ramdac",ramdac_device, index_w, 0xff00 )
674
 
        AM_RANGE(0x900002, 0x900003) AM_DEVWRITE8_MODERN("ramdac",ramdac_device, pal_w, 0xff00 )
675
 
        AM_RANGE(0x900004, 0x900005) AM_DEVWRITE8_MODERN("ramdac",ramdac_device, mask_w, 0xff00 )
 
760
        AM_RANGE(0x900000, 0x900001) AM_DEVWRITE8("ramdac",ramdac_device, index_w, 0xff00 )
 
761
        AM_RANGE(0x900002, 0x900003) AM_DEVWRITE8("ramdac",ramdac_device, pal_w, 0xff00 )
 
762
        AM_RANGE(0x900004, 0x900005) AM_DEVWRITE8("ramdac",ramdac_device, mask_w, 0xff00 )
676
763
 
677
764
//  AM_RANGE(0x940000, 0x940001) AM_WRITE   // lev 6
678
765
 
699
786
 
700
787
        AM_RANGE(0x9b8000, 0x9b8001) AM_WRITE8(blit_draw_w, 0x00ff)
701
788
 
702
 
        AM_RANGE(0x9c0000, 0x9c0001) AM_DEVREAD8_MODERN("ramdac",ramdac_device, index_r, 0xff00 )
703
 
        AM_RANGE(0x9c0002, 0x9c0003) AM_DEVREAD8_MODERN("ramdac",ramdac_device, pal_r, 0xff00 )
 
789
        AM_RANGE(0x9c0000, 0x9c0001) AM_DEVREAD8("ramdac",ramdac_device, index_r, 0xff00 )
 
790
        AM_RANGE(0x9c0002, 0x9c0003) AM_DEVREAD8("ramdac",ramdac_device, pal_r, 0xff00 )
704
791
 
705
792
        AM_RANGE(0x9d0000, 0x9d0001) AM_READ8(bankroba_mcu1_status_write_r, 0xff00)
706
793
 
717
804
    Funny Fruit
718
805
*************************************************************************************************************/
719
806
 
720
 
static WRITE16_HANDLER( cjffruit_leds1_w )
 
807
WRITE16_MEMBER(blitz68k_state::cjffruit_leds1_w)
721
808
{
722
 
        blitz68k_state *state = space->machine().driver_data<blitz68k_state>();
723
 
        data = COMBINE_DATA(state->m_leds[0]);
 
809
        data = COMBINE_DATA(m_leds0);
724
810
        if (ACCESSING_BITS_8_15)
725
811
        {
726
 
                coin_counter_w(space->machine(), 0, data & 0x0100);     // coin in
727
 
                set_led_status(space->machine(), 0, data & 0x0200);     // win???
 
812
                coin_counter_w(machine(), 0, data & 0x0100);    // coin in
 
813
                set_led_status(machine(), 0, data & 0x0200);    // win???
728
814
//                                     1  data & 0x0400     // win???
729
 
                set_led_status(space->machine(), 2, data & 0x0800);     // small
730
 
                set_led_status(space->machine(), 3, data & 0x1000);     // big
731
 
                set_led_status(space->machine(), 4, data & 0x2000);     // take
732
 
                set_led_status(space->machine(), 5, data & 0x4000);     // double up
733
 
                set_led_status(space->machine(), 6, data & 0x8000);     // cancel
734
 
                show_leds123(state);
735
 
        }
736
 
}
737
 
 
738
 
static WRITE16_HANDLER( cjffruit_leds2_w )
739
 
{
740
 
        blitz68k_state *state = space->machine().driver_data<blitz68k_state>();
741
 
        data = COMBINE_DATA(state->m_leds[1]);
742
 
        if (ACCESSING_BITS_8_15)
743
 
        {
744
 
                set_led_status(space->machine(),  7, data & 0x0100);    // start
745
 
                set_led_status(space->machine(),  8, data & 0x0200);    // bet
746
 
                set_led_status(space->machine(),  9, data & 0x0400);    // hold 5
747
 
                set_led_status(space->machine(), 10, data & 0x0800);    // hold 4
748
 
                set_led_status(space->machine(), 11, data & 0x1000);    // hold 3
749
 
                set_led_status(space->machine(), 12, data & 0x2000);    // hold 2
750
 
                set_led_status(space->machine(), 13, data & 0x4000);    // collect
751
 
                set_led_status(space->machine(), 14, data & 0x8000);    // call attendant
752
 
                show_leds123(state);
753
 
        }
754
 
}
755
 
 
756
 
static WRITE16_HANDLER( cjffruit_leds3_w )
757
 
{
758
 
        blitz68k_state *state = space->machine().driver_data<blitz68k_state>();
759
 
        data = COMBINE_DATA(state->m_leds[2]);
760
 
        if (ACCESSING_BITS_8_15)
761
 
        {
762
 
                set_led_status(space->machine(), 15, data & 0x0100);    // hopper coins?
763
 
                set_led_status(space->machine(), 16, data & 0x0400);    // coin out?
764
 
                show_leds123(state);
 
815
                set_led_status(machine(), 2, data & 0x0800);    // small
 
816
                set_led_status(machine(), 3, data & 0x1000);    // big
 
817
                set_led_status(machine(), 4, data & 0x2000);    // take
 
818
                set_led_status(machine(), 5, data & 0x4000);    // double up
 
819
                set_led_status(machine(), 6, data & 0x8000);    // cancel
 
820
                show_leds123();
 
821
        }
 
822
}
 
823
 
 
824
WRITE16_MEMBER(blitz68k_state::cjffruit_leds2_w)
 
825
{
 
826
        data = COMBINE_DATA(m_leds1);
 
827
        if (ACCESSING_BITS_8_15)
 
828
        {
 
829
                set_led_status(machine(),  7, data & 0x0100);   // start
 
830
                set_led_status(machine(),  8, data & 0x0200);   // bet
 
831
                set_led_status(machine(),  9, data & 0x0400);   // hold 5
 
832
                set_led_status(machine(), 10, data & 0x0800);   // hold 4
 
833
                set_led_status(machine(), 11, data & 0x1000);   // hold 3
 
834
                set_led_status(machine(), 12, data & 0x2000);   // hold 2
 
835
                set_led_status(machine(), 13, data & 0x4000);   // collect
 
836
                set_led_status(machine(), 14, data & 0x8000);   // call attendant
 
837
                show_leds123();
 
838
        }
 
839
}
 
840
 
 
841
WRITE16_MEMBER(blitz68k_state::cjffruit_leds3_w)
 
842
{
 
843
        data = COMBINE_DATA(m_leds2);
 
844
        if (ACCESSING_BITS_8_15)
 
845
        {
 
846
                set_led_status(machine(), 15, data & 0x0100);   // hopper coins?
 
847
                set_led_status(machine(), 16, data & 0x0400);   // coin out?
 
848
                show_leds123();
765
849
        }
766
850
}
767
851
 
768
852
// CRTC
769
 
static READ8_HANDLER( crtc_r )
 
853
READ8_MEMBER(blitz68k_state::crtc_r)
770
854
{
771
 
        mc6845_device *mc6845 = space->machine().device<mc6845_device>("crtc");
 
855
        mc6845_device *mc6845 = machine().device<mc6845_device>("crtc");
772
856
        if (offset)
773
 
                return mc6845->register_r(*space, 0);
 
857
                return mc6845->register_r(space, 0);
774
858
        else
775
 
                return mc6845->status_r(*space, 0);
 
859
                return mc6845->status_r(space, 0);
776
860
}
777
861
 
778
 
static WRITE8_HANDLER( crtc_w )
 
862
WRITE8_MEMBER(blitz68k_state::crtc_w)
779
863
{
780
 
        mc6845_device *mc6845 = space->machine().device<mc6845_device>("crtc");
 
864
        mc6845_device *mc6845 = machine().device<mc6845_device>("crtc");
781
865
        if (offset)
782
 
                mc6845->register_w(*space, 0, data);
 
866
                mc6845->register_w(space, 0, data);
783
867
        else
784
 
                mc6845->address_w(*space, 0, data);
 
868
                mc6845->address_w(space, 0, data);
785
869
}
786
870
 
787
871
static WRITE16_DEVICE_HANDLER( crtc_lpen_w )
793
877
}
794
878
 
795
879
// MCU simulation (to be done)
796
 
static READ16_HANDLER( cjffruit_mcu_r )
 
880
READ16_MEMBER(blitz68k_state::cjffruit_mcu_r)
797
881
{
798
 
        UINT8 ret = 0x00;       // space->machine().rand() gives "interesting" results
799
 
        logerror("%s: mcu reads %02x\n", space->machine().describe_context(), ret);
 
882
        UINT8 ret = 0x00;       // machine().rand() gives "interesting" results
 
883
        logerror("%s: mcu reads %02x\n", machine().describe_context(), ret);
800
884
        return ret << 8;
801
885
}
802
886
 
803
 
static WRITE16_HANDLER( cjffruit_mcu_w )
 
887
WRITE16_MEMBER(blitz68k_state::cjffruit_mcu_w)
804
888
{
805
 
        logerror("%s: mcu written with %02x\n", space->machine().describe_context(),data >> 8);
 
889
        logerror("%s: mcu written with %02x\n", machine().describe_context(),data >> 8);
806
890
}
807
891
 
808
 
static ADDRESS_MAP_START( cjffruit_map, AS_PROGRAM, 16 )
 
892
static ADDRESS_MAP_START( cjffruit_map, AS_PROGRAM, 16, blitz68k_state )
809
893
        AM_RANGE(0x000000, 0x07ffff) AM_ROM
810
894
        AM_RANGE(0x400000, 0x41ffff) AM_RAM AM_SHARE("nvram")
811
895
        AM_RANGE(0x480000, 0x4807ff) AM_RAM
812
896
 
813
897
        AM_RANGE(0x820000, 0x820007) AM_WRITE8(blit_hwyxa_draw_w, 0xffff)
814
898
 
815
 
        AM_RANGE(0x850000, 0x850001) AM_READ( cjffruit_mcu_r )
 
899
        AM_RANGE(0x850000, 0x850001) AM_READ(cjffruit_mcu_r )
816
900
 
817
901
        AM_RANGE(0x870000, 0x870001) AM_READ_PORT("IN0")
818
902
        AM_RANGE(0x872000, 0x872001) AM_READ_PORT("IN1")
819
903
        AM_RANGE(0x874000, 0x874001) AM_READ_PORT("IN2")
820
904
        AM_RANGE(0x876000, 0x876001) AM_READ_PORT("DSW")
821
905
 
822
 
        AM_RANGE(0x880000, 0x880001) AM_DEVWRITE8_MODERN("ramdac",ramdac_device, index_w, 0xff00 )
823
 
        AM_RANGE(0x880000, 0x880001) AM_DEVWRITE8_MODERN("ramdac",ramdac_device, pal_w, 0x00ff )
824
 
        AM_RANGE(0x880002, 0x880003) AM_DEVWRITE8_MODERN("ramdac",ramdac_device, mask_w, 0xff00 )
825
 
        AM_RANGE(0x880000, 0x880001) AM_DEVREAD8_MODERN("ramdac",ramdac_device, index_r, 0xff00 )
826
 
        AM_RANGE(0x880000, 0x880001) AM_DEVREAD8_MODERN("ramdac",ramdac_device, pal_r, 0x00ff )
 
906
        AM_RANGE(0x880000, 0x880001) AM_DEVWRITE8("ramdac",ramdac_device, index_w, 0xff00 )
 
907
        AM_RANGE(0x880000, 0x880001) AM_DEVWRITE8("ramdac",ramdac_device, pal_w, 0x00ff )
 
908
        AM_RANGE(0x880002, 0x880003) AM_DEVWRITE8("ramdac",ramdac_device, mask_w, 0xff00 )
 
909
        AM_RANGE(0x880000, 0x880001) AM_DEVREAD8("ramdac",ramdac_device, index_r, 0xff00 )
 
910
        AM_RANGE(0x880000, 0x880001) AM_DEVREAD8("ramdac",ramdac_device, pal_r, 0x00ff )
827
911
 
828
912
        AM_RANGE(0x8a0000, 0x8a0007) AM_WRITE8(blit_hwyxa_draw_w, 0xffff)
829
913
 
830
914
        AM_RANGE(0x8b0000, 0x8b0003) AM_WRITE8(blit_pens_w, 0xffff)
831
915
 
832
 
        AM_RANGE(0x8e0000, 0x8e0001) AM_WRITE( cjffruit_mcu_w )
 
916
        AM_RANGE(0x8e0000, 0x8e0001) AM_WRITE(cjffruit_mcu_w )
833
917
 
834
 
        AM_RANGE(0x8f8000, 0x8f8001) AM_WRITE(cjffruit_leds1_w) AM_BASE_MEMBER(blitz68k_state, m_leds[0])
835
 
        AM_RANGE(0x8fa000, 0x8fa001) AM_WRITE(cjffruit_leds2_w) AM_BASE_MEMBER(blitz68k_state, m_leds[1])
836
 
        AM_RANGE(0x8fc000, 0x8fc001) AM_WRITE(cjffruit_leds3_w) AM_BASE_MEMBER(blitz68k_state, m_leds[2])
 
918
        AM_RANGE(0x8f8000, 0x8f8001) AM_WRITE(cjffruit_leds1_w) AM_SHARE("leds0")
 
919
        AM_RANGE(0x8fa000, 0x8fa001) AM_WRITE(cjffruit_leds2_w) AM_SHARE("leds1")
 
920
        AM_RANGE(0x8fc000, 0x8fc001) AM_WRITE(cjffruit_leds3_w) AM_SHARE("leds2")
837
921
 
838
922
        AM_RANGE(0x8fe000, 0x8fe003) AM_WRITE8(blit_flags_w, 0xffff)    // flipx,y,solid,trans
839
923
        AM_RANGE(0x8fe004, 0x8fe005) AM_WRITEONLY
840
 
        AM_RANGE(0x8fe006, 0x8fe007) AM_DEVWRITE("crtc", crtc_lpen_w)   // 0x8fe006: 0->1, 0x8fe007: 1->0
 
924
        AM_RANGE(0x8fe006, 0x8fe007) AM_DEVWRITE_LEGACY("crtc", crtc_lpen_w)    // 0x8fe006: 0->1, 0x8fe007: 1->0
841
925
 
842
926
        AM_RANGE(0xc40000, 0xc40001) AM_READWRITE8(crtc_r, crtc_w, 0xffff)
843
927
ADDRESS_MAP_END
847
931
*************************************************************************************************************/
848
932
 
849
933
// MCU simulation (to be done)
850
 
static READ16_HANDLER( deucesw2_mcu_r )
 
934
READ16_MEMBER(blitz68k_state::deucesw2_mcu_r)
851
935
{
852
 
        UINT8 ret = 0x00;       // space->machine().rand() gives "interesting" results
853
 
        logerror("%s: mcu reads %02x\n", space->machine().describe_context(), ret);
 
936
        UINT8 ret = 0x00;       // machine().rand() gives "interesting" results
 
937
        logerror("%s: mcu reads %02x\n", machine().describe_context(), ret);
854
938
        return ret << 8;
855
939
}
856
940
 
857
 
static WRITE16_HANDLER( deucesw2_mcu_w )
 
941
WRITE16_MEMBER(blitz68k_state::deucesw2_mcu_w)
858
942
{
859
 
        logerror("%s: mcu written with %02x\n", space->machine().describe_context(),data >> 8);
 
943
        logerror("%s: mcu written with %02x\n", machine().describe_context(),data >> 8);
860
944
}
861
945
 
862
 
static WRITE16_HANDLER( deucesw2_leds1_w )
 
946
WRITE16_MEMBER(blitz68k_state::deucesw2_leds1_w)
863
947
{
864
 
        blitz68k_state *state = space->machine().driver_data<blitz68k_state>();
865
 
        data = COMBINE_DATA(state->m_leds[0]);
 
948
        data = COMBINE_DATA(m_leds0);
866
949
        if (ACCESSING_BITS_8_15)
867
950
        {
868
 
                coin_counter_w(space->machine(), 0, data & 0x0100);     // coin in
869
 
                set_led_status(space->machine(), 0, data & 0x0200);     // win???
 
951
                coin_counter_w(machine(), 0, data & 0x0100);    // coin in
 
952
                set_led_status(machine(), 0, data & 0x0200);    // win???
870
953
//                                     1  data & 0x0400     // win???
871
 
                set_led_status(space->machine(), 2, data & 0x0800);     // small
872
 
                set_led_status(space->machine(), 3, data & 0x1000);     // big
873
 
                set_led_status(space->machine(), 4, data & 0x2000);     // take
874
 
                set_led_status(space->machine(), 5, data & 0x4000);     // double up
875
 
                set_led_status(space->machine(), 6, data & 0x8000);     // cancel
876
 
                show_leds123(state);
877
 
        }
878
 
}
879
 
 
880
 
static WRITE16_HANDLER( deucesw2_leds2_w )
881
 
{
882
 
        blitz68k_state *state = space->machine().driver_data<blitz68k_state>();
883
 
        data = COMBINE_DATA(state->m_leds[1]);
884
 
        if (ACCESSING_BITS_8_15)
885
 
        {
886
 
                set_led_status(space->machine(),  7, data & 0x0100);    // start
887
 
                set_led_status(space->machine(),  8, data & 0x0200);    // bet
888
 
                set_led_status(space->machine(),  9, data & 0x0400);    // hold 5
889
 
                set_led_status(space->machine(), 10, data & 0x0800);    // hold 4
890
 
                set_led_status(space->machine(), 11, data & 0x1000);    // hold 3
891
 
                set_led_status(space->machine(), 12, data & 0x2000);    // hold 2
892
 
                set_led_status(space->machine(), 13, data & 0x4000);    // hold 1
893
 
                set_led_status(space->machine(), 14, data & 0x8000);    // call attendant
894
 
                show_leds123(state);
895
 
        }
896
 
}
897
 
 
898
 
static WRITE16_HANDLER( deucesw2_leds3_w )
899
 
{
900
 
        blitz68k_state *state = space->machine().driver_data<blitz68k_state>();
901
 
        data = COMBINE_DATA(state->m_leds[2]);
902
 
        if (ACCESSING_BITS_8_15)
903
 
        {
904
 
                set_led_status(space->machine(), 15, data & 0x0100);    // hopper coins?
905
 
                set_led_status(space->machine(), 16, data & 0x0400);    // coin out?
906
 
                show_leds123(state);
907
 
        }
908
 
}
909
 
 
910
 
static ADDRESS_MAP_START( deucesw2_map, AS_PROGRAM, 16 )
 
954
                set_led_status(machine(), 2, data & 0x0800);    // small
 
955
                set_led_status(machine(), 3, data & 0x1000);    // big
 
956
                set_led_status(machine(), 4, data & 0x2000);    // take
 
957
                set_led_status(machine(), 5, data & 0x4000);    // double up
 
958
                set_led_status(machine(), 6, data & 0x8000);    // cancel
 
959
                show_leds123();
 
960
        }
 
961
}
 
962
 
 
963
WRITE16_MEMBER(blitz68k_state::deucesw2_leds2_w)
 
964
{
 
965
        data = COMBINE_DATA(m_leds1);
 
966
        if (ACCESSING_BITS_8_15)
 
967
        {
 
968
                set_led_status(machine(),  7, data & 0x0100);   // start
 
969
                set_led_status(machine(),  8, data & 0x0200);   // bet
 
970
                set_led_status(machine(),  9, data & 0x0400);   // hold 5
 
971
                set_led_status(machine(), 10, data & 0x0800);   // hold 4
 
972
                set_led_status(machine(), 11, data & 0x1000);   // hold 3
 
973
                set_led_status(machine(), 12, data & 0x2000);   // hold 2
 
974
                set_led_status(machine(), 13, data & 0x4000);   // hold 1
 
975
                set_led_status(machine(), 14, data & 0x8000);   // call attendant
 
976
                show_leds123();
 
977
        }
 
978
}
 
979
 
 
980
WRITE16_MEMBER(blitz68k_state::deucesw2_leds3_w)
 
981
{
 
982
        data = COMBINE_DATA(m_leds2);
 
983
        if (ACCESSING_BITS_8_15)
 
984
        {
 
985
                set_led_status(machine(), 15, data & 0x0100);   // hopper coins?
 
986
                set_led_status(machine(), 16, data & 0x0400);   // coin out?
 
987
                show_leds123();
 
988
        }
 
989
}
 
990
 
 
991
static ADDRESS_MAP_START( deucesw2_map, AS_PROGRAM, 16, blitz68k_state )
911
992
        AM_RANGE(0x000000, 0x03ffff) AM_ROM
912
993
        AM_RANGE(0x400000, 0x41ffff) AM_RAM
913
994
 
914
995
        AM_RANGE(0x800000, 0x800007) AM_WRITE8(blit_hwyxa_draw_w, 0xffff)
915
996
 
916
 
        AM_RANGE(0x812000, 0x812001) AM_DEVREAD8_MODERN("ramdac",ramdac_device, index_r, 0xff00 )
917
 
        AM_RANGE(0x812000, 0x812001) AM_DEVREAD8_MODERN("ramdac",ramdac_device, pal_r, 0x00ff )
 
997
        AM_RANGE(0x812000, 0x812001) AM_DEVREAD8("ramdac",ramdac_device, index_r, 0xff00 )
 
998
        AM_RANGE(0x812000, 0x812001) AM_DEVREAD8("ramdac",ramdac_device, pal_r, 0x00ff )
918
999
 
919
 
        AM_RANGE(0x830000, 0x830001) AM_READ( deucesw2_mcu_r )
 
1000
        AM_RANGE(0x830000, 0x830001) AM_READ(deucesw2_mcu_r )
920
1001
 
921
1002
        AM_RANGE(0x840000, 0x840001) AM_READ_PORT("IN0")
922
1003
        AM_RANGE(0x850000, 0x850001) AM_READ_PORT("IN1")
925
1006
 
926
1007
        AM_RANGE(0x880000, 0x880007) AM_WRITE8(blit_hwyxa_draw_w, 0xffff)
927
1008
 
928
 
        AM_RANGE(0x890000, 0x890001) AM_DEVWRITE8_MODERN("ramdac",ramdac_device, index_w, 0xff00 )
929
 
        AM_RANGE(0x890000, 0x890001) AM_DEVWRITE8_MODERN("ramdac",ramdac_device, pal_w, 0x00ff )
930
 
        AM_RANGE(0x890002, 0x890003) AM_DEVWRITE8_MODERN("ramdac",ramdac_device, mask_w, 0xff00 )
 
1009
        AM_RANGE(0x890000, 0x890001) AM_DEVWRITE8("ramdac",ramdac_device, index_w, 0xff00 )
 
1010
        AM_RANGE(0x890000, 0x890001) AM_DEVWRITE8("ramdac",ramdac_device, pal_w, 0x00ff )
 
1011
        AM_RANGE(0x890002, 0x890003) AM_DEVWRITE8("ramdac",ramdac_device, mask_w, 0xff00 )
931
1012
 
932
1013
        AM_RANGE(0x894000, 0x894003) AM_WRITE8(blit_pens_w, 0xffff)
933
1014
 
934
 
        AM_RANGE(0x896000, 0x896001) AM_WRITE( deucesw2_mcu_w )
 
1015
        AM_RANGE(0x896000, 0x896001) AM_WRITE(deucesw2_mcu_w )
935
1016
 
936
 
        AM_RANGE(0x898000, 0x898001) AM_WRITE(deucesw2_leds1_w) AM_BASE_MEMBER(blitz68k_state, m_leds[0])
937
 
        AM_RANGE(0x89a000, 0x89a001) AM_WRITE(deucesw2_leds2_w) AM_BASE_MEMBER(blitz68k_state, m_leds[1])
938
 
        AM_RANGE(0x89c000, 0x89c001) AM_WRITE(deucesw2_leds3_w) AM_BASE_MEMBER(blitz68k_state, m_leds[2])
 
1017
        AM_RANGE(0x898000, 0x898001) AM_WRITE(deucesw2_leds1_w) AM_SHARE("leds0")
 
1018
        AM_RANGE(0x89a000, 0x89a001) AM_WRITE(deucesw2_leds2_w) AM_SHARE("leds1")
 
1019
        AM_RANGE(0x89c000, 0x89c001) AM_WRITE(deucesw2_leds3_w) AM_SHARE("leds2")
939
1020
 
940
1021
        AM_RANGE(0x89e000, 0x89e003) AM_WRITE8(blit_flags_w, 0xffff)    // flipx,y,solid,trans
941
1022
        AM_RANGE(0x89e004, 0x89e005) AM_WRITEONLY
942
 
        AM_RANGE(0x89e006, 0x89e007) AM_DEVWRITE("crtc", crtc_lpen_w)   // 0x89e006: 0->1, 0x89e007: 1->0
 
1023
        AM_RANGE(0x89e006, 0x89e007) AM_DEVWRITE_LEGACY("crtc", crtc_lpen_w)    // 0x89e006: 0->1, 0x89e007: 1->0
943
1024
 
944
1025
        AM_RANGE(0xc00000, 0xc00001) AM_READWRITE8(crtc_r, crtc_w, 0xffff)
945
1026
ADDRESS_MAP_END
949
1030
*************************************************************************************************************/
950
1031
 
951
1032
// MCU simulation (to be done)
952
 
static READ8_HANDLER( dualgame_mcu1_r )
953
 
{
954
 
        UINT8 ret = 0;  // space->machine().rand() gives "interesting" results
955
 
        logerror("%s: mcu1 reads %02x\n", space->machine().describe_context(), ret);
956
 
        return ret;
957
 
}
958
 
static READ8_HANDLER( dualgame_mcu2_r )
959
 
{
960
 
        UINT8 ret = 0;  // space->machine().rand() gives "interesting" results
961
 
        logerror("%s: mcu2 reads %02x\n", space->machine().describe_context(), ret);
962
 
        return ret;
963
 
}
964
 
 
965
 
static READ8_HANDLER( dualgame_mcu_status_read_r )
966
 
{
967
 
        return 0x03;    // bit 0 = MCU1, bit 1 = MCU2. Active high.
968
 
}
969
 
 
970
 
static READ8_HANDLER( dualgame_mcu_status_write_r )
971
 
{
972
 
        return 0x03;    // bit 0 = MCU1, bit 1 = MCU2. Active high.
973
 
}
974
 
 
975
 
static WRITE8_HANDLER( dualgame_mcu1_w )
976
 
{
977
 
        logerror("%s: mcu1 written with %02x\n", space->machine().describe_context(), data);
978
 
}
979
 
static WRITE8_HANDLER( dualgame_mcu2_w )
980
 
{
981
 
        logerror("%s: mcu2 written with %02x\n", space->machine().describe_context(), data);
982
 
}
983
 
 
984
 
static ADDRESS_MAP_START( dualgame_map, AS_PROGRAM, 16 )
 
1033
READ8_MEMBER(blitz68k_state::dualgame_mcu1_r)
 
1034
{
 
1035
        UINT8 ret = 0;  // machine().rand() gives "interesting" results
 
1036
        logerror("%s: mcu1 reads %02x\n", machine().describe_context(), ret);
 
1037
        return ret;
 
1038
}
 
1039
READ8_MEMBER(blitz68k_state::dualgame_mcu2_r)
 
1040
{
 
1041
        UINT8 ret = 0;  // machine().rand() gives "interesting" results
 
1042
        logerror("%s: mcu2 reads %02x\n", machine().describe_context(), ret);
 
1043
        return ret;
 
1044
}
 
1045
 
 
1046
READ8_MEMBER(blitz68k_state::dualgame_mcu_status_read_r)
 
1047
{
 
1048
        return 0x03;    // bit 0 = MCU1, bit 1 = MCU2. Active high.
 
1049
}
 
1050
 
 
1051
READ8_MEMBER(blitz68k_state::dualgame_mcu_status_write_r)
 
1052
{
 
1053
        return 0x03;    // bit 0 = MCU1, bit 1 = MCU2. Active high.
 
1054
}
 
1055
 
 
1056
WRITE8_MEMBER(blitz68k_state::dualgame_mcu1_w)
 
1057
{
 
1058
        logerror("%s: mcu1 written with %02x\n", machine().describe_context(), data);
 
1059
}
 
1060
WRITE8_MEMBER(blitz68k_state::dualgame_mcu2_w)
 
1061
{
 
1062
        logerror("%s: mcu2 written with %02x\n", machine().describe_context(), data);
 
1063
}
 
1064
 
 
1065
static ADDRESS_MAP_START( dualgame_map, AS_PROGRAM, 16, blitz68k_state )
985
1066
        AM_RANGE(0x000000, 0x03ffff) AM_ROM
986
1067
        AM_RANGE(0x100000, 0x10ffff) AM_RAM
987
1068
 
988
 
        AM_RANGE(0x220002, 0x220003) AM_DEVREAD8_MODERN("ramdac",ramdac_device, index_r, 0xff00 )
989
 
        AM_RANGE(0x220002, 0x220003) AM_DEVREAD8_MODERN("ramdac",ramdac_device, pal_r, 0x00ff )
 
1069
        AM_RANGE(0x220002, 0x220003) AM_DEVREAD8("ramdac",ramdac_device, index_r, 0xff00 )
 
1070
        AM_RANGE(0x220002, 0x220003) AM_DEVREAD8("ramdac",ramdac_device, pal_r, 0x00ff )
990
1071
 
991
1072
        AM_RANGE(0x240000, 0x240001) AM_WRITE8(blit_addr0_w, 0xff00)
992
1073
        AM_RANGE(0x240002, 0x240003) AM_WRITE8(blit_addr1_w, 0xff00)
1007
1088
 
1008
1089
        AM_RANGE(0x280000, 0x280001) AM_READ8(blit_status_r, 0xff00)
1009
1090
 
1010
 
        AM_RANGE(0x2a0000, 0x2a0001) AM_DEVWRITE("crtc", crtc_lpen_w)
 
1091
        AM_RANGE(0x2a0000, 0x2a0001) AM_DEVWRITE_LEGACY("crtc", crtc_lpen_w)
1011
1092
        AM_RANGE(0x2a0000, 0x2a0001) AM_READNOP
1012
1093
 
1013
1094
        AM_RANGE(0x2c0000, 0x2c0001) AM_WRITENOP        // 1->0 (MCU related?)
1021
1102
        AM_RANGE(0x2e000c, 0x2e000d) AM_WRITE8(blit_flag6_w, 0xff00)
1022
1103
        AM_RANGE(0x2e000e, 0x2e000f) AM_WRITE8(blit_flag7_w, 0xff00)
1023
1104
 
1024
 
        AM_RANGE(0x300000, 0x300001) AM_DEVWRITE8_MODERN("ramdac",ramdac_device, index_w, 0xff00 )
1025
 
        AM_RANGE(0x300002, 0x300003) AM_DEVWRITE8_MODERN("ramdac",ramdac_device, pal_w, 0xff00 )
1026
 
        AM_RANGE(0x300004, 0x300005) AM_DEVWRITE8_MODERN("ramdac",ramdac_device, mask_w, 0xff00 )
 
1105
        AM_RANGE(0x300000, 0x300001) AM_DEVWRITE8("ramdac",ramdac_device, index_w, 0xff00 )
 
1106
        AM_RANGE(0x300002, 0x300003) AM_DEVWRITE8("ramdac",ramdac_device, pal_w, 0xff00 )
 
1107
        AM_RANGE(0x300004, 0x300005) AM_DEVWRITE8("ramdac",ramdac_device, mask_w, 0xff00 )
1027
1108
 
1028
1109
        AM_RANGE(0x400000, 0x400001) AM_READ8(dualgame_mcu_status_write_r, 0x00ff)
1029
1110
        AM_RANGE(0x400002, 0x400003) AM_READ8(dualgame_mcu_status_read_r,  0x00ff)
1031
1112
        AM_RANGE(0x400004, 0x400005) AM_READWRITE8(dualgame_mcu1_r, dualgame_mcu1_w, 0x00ff)
1032
1113
        AM_RANGE(0x400006, 0x400007) AM_READWRITE8(dualgame_mcu2_r, dualgame_mcu2_w, 0xff00)
1033
1114
 
1034
 
        AM_RANGE(0x800000, 0x800001) AM_DEVREADWRITE8_MODERN("crtc", mc6845_device, status_r,   address_w,  0xff00)
1035
 
        AM_RANGE(0x800002, 0x800003) AM_DEVREADWRITE8_MODERN("crtc", mc6845_device, register_r, register_w, 0xff00)
 
1115
        AM_RANGE(0x800000, 0x800001) AM_DEVREADWRITE8("crtc", mc6845_device, status_r,   address_w,  0xff00)
 
1116
        AM_RANGE(0x800002, 0x800003) AM_DEVREADWRITE8("crtc", mc6845_device, register_r, register_w, 0xff00)
1036
1117
ADDRESS_MAP_END
1037
1118
 
1038
1119
/*************************************************************************************************************
1040
1121
*************************************************************************************************************/
1041
1122
 
1042
1123
// MCU simulation (to be done)
1043
 
static READ16_HANDLER( hermit_mcu_r )
 
1124
READ16_MEMBER(blitz68k_state::hermit_mcu_r)
1044
1125
{
1045
 
        UINT8 ret = 0x00;       // space->machine().rand() gives "interesting" results
1046
 
        logerror("%s: mcu reads %02x\n", space->machine().describe_context(), ret);
 
1126
        UINT8 ret = 0x00;       // machine().rand() gives "interesting" results
 
1127
        logerror("%s: mcu reads %02x\n", machine().describe_context(), ret);
1047
1128
        return ret << 8;
1048
1129
}
1049
1130
 
1050
 
static WRITE16_HANDLER( hermit_mcu_w )
1051
 
{
1052
 
        logerror("%s: mcu written with %02x\n", space->machine().describe_context(),data >> 8);
1053
 
}
1054
 
 
1055
 
static WRITE16_HANDLER( hermit_leds1_w )
1056
 
{
1057
 
        blitz68k_state *state = space->machine().driver_data<blitz68k_state>();
1058
 
        data = COMBINE_DATA(state->m_leds[0]);
1059
 
        if (ACCESSING_BITS_8_15)
1060
 
        {
1061
 
                coin_counter_w(space->machine(), 0, data & 0x0100);     // coin in
1062
 
                show_leds12(state);
1063
 
        }
1064
 
}
1065
 
 
1066
 
static WRITE16_HANDLER( hermit_leds2_w )
1067
 
{
1068
 
        blitz68k_state *state = space->machine().driver_data<blitz68k_state>();
1069
 
        data = COMBINE_DATA(state->m_leds[1]);
1070
 
        if (ACCESSING_BITS_8_15)
1071
 
        {
1072
 
                set_led_status(space->machine(),  7, data & 0x0100);    // button
1073
 
                show_leds12(state);
1074
 
        }
1075
 
}
1076
 
 
1077
 
static READ16_HANDLER( hermit_track_r )
 
1131
WRITE16_MEMBER(blitz68k_state::hermit_mcu_w)
 
1132
{
 
1133
        logerror("%s: mcu written with %02x\n", machine().describe_context(),data >> 8);
 
1134
}
 
1135
 
 
1136
WRITE16_MEMBER(blitz68k_state::hermit_leds1_w)
 
1137
{
 
1138
        data = COMBINE_DATA(m_leds0);
 
1139
        if (ACCESSING_BITS_8_15)
 
1140
        {
 
1141
                coin_counter_w(machine(), 0, data & 0x0100);    // coin in
 
1142
                show_leds12();
 
1143
        }
 
1144
}
 
1145
 
 
1146
WRITE16_MEMBER(blitz68k_state::hermit_leds2_w)
 
1147
{
 
1148
        data = COMBINE_DATA(m_leds1);
 
1149
        if (ACCESSING_BITS_8_15)
 
1150
        {
 
1151
                set_led_status(machine(),  7, data & 0x0100);   // button
 
1152
                show_leds12();
 
1153
        }
 
1154
}
 
1155
 
 
1156
READ16_MEMBER(blitz68k_state::hermit_track_r)
1078
1157
{
1079
1158
#ifdef MAME_DEBUG
1080
 
//  popmessage("track %02x %02x", input_port_read(space->machine(), "TRACK_X"), input_port_read(space->machine(), "TRACK_Y"));
 
1159
//  popmessage("track %02x %02x", ioport("TRACK_X")->read(), ioport("TRACK_Y")->read());
1081
1160
#endif
1082
1161
 
1083
1162
        return
1084
 
                ((0xf - ((input_port_read(space->machine(), "TRACK_Y") + 0x7) & 0xf)) << 12) |
1085
 
                ((0xf - ((input_port_read(space->machine(), "TRACK_X") + 0x7) & 0xf)) << 8)  ;
 
1163
                ((0xf - ((ioport("TRACK_Y")->read() + 0x7) & 0xf)) << 12) |
 
1164
                ((0xf - ((ioport("TRACK_X")->read() + 0x7) & 0xf)) << 8)  ;
1086
1165
}
1087
1166
 
1088
 
static ADDRESS_MAP_START( hermit_map, AS_PROGRAM, 16 )
 
1167
static ADDRESS_MAP_START( hermit_map, AS_PROGRAM, 16, blitz68k_state )
1089
1168
        AM_RANGE(0x000000, 0x03ffff) AM_ROM
1090
1169
        AM_RANGE(0x200000, 0x20ffff) AM_RAM
1091
1170
        AM_RANGE(0x400000, 0x41ffff) AM_RAM
1092
1171
 
1093
 
        AM_RANGE(0x800000, 0x800001) AM_DEVWRITE8_MODERN("ramdac",ramdac_device, index_w, 0xff00 )
1094
 
        AM_RANGE(0x800000, 0x800001) AM_DEVWRITE8_MODERN("ramdac",ramdac_device, pal_w, 0x00ff )
1095
 
        AM_RANGE(0x800002, 0x800003) AM_DEVWRITE8_MODERN("ramdac",ramdac_device, mask_w, 0xff00 )
1096
 
        AM_RANGE(0x840000, 0x840001) AM_DEVWRITE8_MODERN("ramdac",ramdac_device, index_w, 0xff00 )
1097
 
        AM_RANGE(0x840000, 0x840001) AM_DEVWRITE8_MODERN("ramdac",ramdac_device, pal_w, 0x00ff )
1098
 
        AM_RANGE(0x840002, 0x840003) AM_DEVWRITE8_MODERN("ramdac",ramdac_device, mask_w, 0xff00 )
1099
 
        AM_RANGE(0x840000, 0x840001) AM_DEVREAD8_MODERN("ramdac",ramdac_device, index_r, 0xff00 )
1100
 
        AM_RANGE(0x840000, 0x840001) AM_DEVREAD8_MODERN("ramdac",ramdac_device, pal_r, 0x00ff )
1101
 
 
1102
 
 
1103
 
        AM_RANGE(0x8c0000, 0x8c0003) AM_WRITE8( blit_pens_w, 0xffff )
1104
 
 
1105
 
        AM_RANGE(0x940000, 0x940001) AM_READ( hermit_mcu_r )
1106
 
        AM_RANGE(0x980000, 0x980001) AM_WRITE( hermit_mcu_w )
 
1172
        AM_RANGE(0x800000, 0x800001) AM_DEVWRITE8("ramdac",ramdac_device, index_w, 0xff00 )
 
1173
        AM_RANGE(0x800000, 0x800001) AM_DEVWRITE8("ramdac",ramdac_device, pal_w, 0x00ff )
 
1174
        AM_RANGE(0x800002, 0x800003) AM_DEVWRITE8("ramdac",ramdac_device, mask_w, 0xff00 )
 
1175
        AM_RANGE(0x840000, 0x840001) AM_DEVWRITE8("ramdac",ramdac_device, index_w, 0xff00 )
 
1176
        AM_RANGE(0x840000, 0x840001) AM_DEVWRITE8("ramdac",ramdac_device, pal_w, 0x00ff )
 
1177
        AM_RANGE(0x840002, 0x840003) AM_DEVWRITE8("ramdac",ramdac_device, mask_w, 0xff00 )
 
1178
        AM_RANGE(0x840000, 0x840001) AM_DEVREAD8("ramdac",ramdac_device, index_r, 0xff00 )
 
1179
        AM_RANGE(0x840000, 0x840001) AM_DEVREAD8("ramdac",ramdac_device, pal_r, 0x00ff )
 
1180
 
 
1181
 
 
1182
        AM_RANGE(0x8c0000, 0x8c0003) AM_WRITE8(blit_pens_w, 0xffff )
 
1183
 
 
1184
        AM_RANGE(0x940000, 0x940001) AM_READ(hermit_mcu_r )
 
1185
        AM_RANGE(0x980000, 0x980001) AM_WRITE(hermit_mcu_w )
1107
1186
 
1108
1187
        AM_RANGE(0x9c0000, 0x9c0001) AM_READ_PORT("IN0")
1109
 
        AM_RANGE(0x9c8000, 0x9c8001) AM_READ( hermit_track_r )
 
1188
        AM_RANGE(0x9c8000, 0x9c8001) AM_READ(hermit_track_r )
1110
1189
        AM_RANGE(0x9d0000, 0x9d0001) AM_READ_PORT("IN2")
1111
1190
        AM_RANGE(0x9d8000, 0x9d8001) AM_READ_PORT("DSW")
1112
1191
 
1113
 
        AM_RANGE(0x9e0000, 0x9e0001) AM_WRITE(hermit_leds1_w) AM_BASE_MEMBER(blitz68k_state, m_leds[0])
1114
 
        AM_RANGE(0x9e8000, 0x9e8001) AM_WRITE(hermit_leds2_w) AM_BASE_MEMBER(blitz68k_state, m_leds[1])
 
1192
        AM_RANGE(0x9e0000, 0x9e0001) AM_WRITE(hermit_leds1_w) AM_SHARE("leds0")
 
1193
        AM_RANGE(0x9e8000, 0x9e8001) AM_WRITE(hermit_leds2_w) AM_SHARE("leds1")
1115
1194
 
1116
1195
        AM_RANGE(0x9f0000, 0x9f0003) AM_WRITE8(blit_flags_w, 0xffff)    // flipx,y,solid,trans
1117
1196
        AM_RANGE(0x9f0004, 0x9f0005) AM_WRITEONLY
1118
 
        AM_RANGE(0x9f0006, 0x9f0007) AM_DEVWRITE("crtc", crtc_lpen_w)   // 0x9f0006: 0->1, 0x9f0007: 1->0
 
1197
        AM_RANGE(0x9f0006, 0x9f0007) AM_DEVWRITE_LEGACY("crtc", crtc_lpen_w)    // 0x9f0006: 0->1, 0x9f0007: 1->0
1119
1198
 
1120
1199
        AM_RANGE(0xb00000, 0xb00001) AM_READWRITE8(crtc_r, crtc_w, 0xffff)      // triggered by MCU?
1121
1200
 
1127
1206
*************************************************************************************************************/
1128
1207
 
1129
1208
// MCU simulation (to be done)
1130
 
static READ8_HANDLER( maxidbl_mcu1_r )
1131
 
{
1132
 
        UINT8 ret = 0;  // space->machine().rand() gives "interesting" results
1133
 
        logerror("%s: mcu1 reads %02x\n", space->machine().describe_context(), ret);
1134
 
        return ret;
1135
 
}
1136
 
static READ8_HANDLER( maxidbl_mcu2_r )
1137
 
{
1138
 
        UINT8 ret = 0;  // space->machine().rand() gives "interesting" results
1139
 
        logerror("%s: mcu2 reads %02x\n", space->machine().describe_context(), ret);
1140
 
        return ret;
1141
 
}
1142
 
 
1143
 
static READ8_HANDLER( maxidbl_mcu_status_read_r )
1144
 
{
1145
 
        return 0x03;    // bit 0 = MCU1, bit 1 = MCU2. Active high.
1146
 
}
1147
 
 
1148
 
static READ8_HANDLER( maxidbl_mcu_status_write_r )
1149
 
{
1150
 
        return 0x03;    // bit 0 = MCU1, bit 1 = MCU2. Active high.
1151
 
}
1152
 
 
1153
 
static WRITE8_HANDLER( maxidbl_mcu1_w )
1154
 
{
1155
 
        logerror("%s: mcu1 written with %02x\n", space->machine().describe_context(), data);
1156
 
}
1157
 
static WRITE8_HANDLER( maxidbl_mcu2_w )
1158
 
{
1159
 
        logerror("%s: mcu2 written with %02x\n", space->machine().describe_context(), data);
1160
 
}
1161
 
 
1162
 
static ADDRESS_MAP_START( maxidbl_map, AS_PROGRAM, 16 )
 
1209
READ8_MEMBER(blitz68k_state::maxidbl_mcu1_r)
 
1210
{
 
1211
        UINT8 ret = 0;  // machine().rand() gives "interesting" results
 
1212
        logerror("%s: mcu1 reads %02x\n", machine().describe_context(), ret);
 
1213
        return ret;
 
1214
}
 
1215
READ8_MEMBER(blitz68k_state::maxidbl_mcu2_r)
 
1216
{
 
1217
        UINT8 ret = 0;  // machine().rand() gives "interesting" results
 
1218
        logerror("%s: mcu2 reads %02x\n", machine().describe_context(), ret);
 
1219
        return ret;
 
1220
}
 
1221
 
 
1222
READ8_MEMBER(blitz68k_state::maxidbl_mcu_status_read_r)
 
1223
{
 
1224
        return 0x03;    // bit 0 = MCU1, bit 1 = MCU2. Active high.
 
1225
}
 
1226
 
 
1227
READ8_MEMBER(blitz68k_state::maxidbl_mcu_status_write_r)
 
1228
{
 
1229
        return 0x03;    // bit 0 = MCU1, bit 1 = MCU2. Active high.
 
1230
}
 
1231
 
 
1232
WRITE8_MEMBER(blitz68k_state::maxidbl_mcu1_w)
 
1233
{
 
1234
        logerror("%s: mcu1 written with %02x\n", machine().describe_context(), data);
 
1235
}
 
1236
WRITE8_MEMBER(blitz68k_state::maxidbl_mcu2_w)
 
1237
{
 
1238
        logerror("%s: mcu2 written with %02x\n", machine().describe_context(), data);
 
1239
}
 
1240
 
 
1241
static ADDRESS_MAP_START( maxidbl_map, AS_PROGRAM, 16, blitz68k_state )
1163
1242
        AM_RANGE(0x000000, 0x03ffff) AM_ROM
1164
1243
        AM_RANGE(0x200000, 0x20ffff) AM_RAM
1165
1244
 
1166
 
        AM_RANGE(0x400000, 0x40ffff) AM_RAM AM_BASE_MEMBER(blitz68k_state, m_frame_buffer)
 
1245
        AM_RANGE(0x400000, 0x40ffff) AM_RAM AM_SHARE("frame_buffer")
1167
1246
 
1168
1247
        AM_RANGE(0x30000c, 0x30000d) AM_WRITENOP        // 0->1 (IRQ3 ack.?)
1169
1248
        AM_RANGE(0x30000e, 0x30000f) AM_WRITENOP        // 1->0 (MCU related?)
1174
1253
        AM_RANGE(0x500004, 0x500005) AM_READWRITE8(maxidbl_mcu1_r, maxidbl_mcu1_w, 0x00ff)
1175
1254
        AM_RANGE(0x500006, 0x500007) AM_READWRITE8(maxidbl_mcu2_r, maxidbl_mcu2_w, 0xff00)
1176
1255
 
1177
 
        AM_RANGE(0x600000, 0x600001) AM_DEVREADWRITE8_MODERN("crtc", mc6845_device, status_r,   address_w,  0xff00)     // triggered by MCU?
1178
 
        AM_RANGE(0x600002, 0x600003) AM_DEVREADWRITE8_MODERN("crtc", mc6845_device, register_r, register_w, 0xff00)
 
1256
        AM_RANGE(0x600000, 0x600001) AM_DEVREADWRITE8("crtc", mc6845_device, status_r,   address_w,  0xff00)    // triggered by MCU?
 
1257
        AM_RANGE(0x600002, 0x600003) AM_DEVREADWRITE8("crtc", mc6845_device, register_r, register_w, 0xff00)
1179
1258
ADDRESS_MAP_END
1180
1259
 
1181
1260
 
1596
1675
        crtc_addr                               /* update address callback */
1597
1676
};
1598
1677
 
1599
 
static ADDRESS_MAP_START( ramdac_map, AS_0, 8 )
1600
 
        AM_RANGE(0x000, 0x3ff) AM_DEVREADWRITE_MODERN("ramdac",ramdac_device,ramdac_pal_r,ramdac_rgb666_w)
 
1678
static ADDRESS_MAP_START( ramdac_map, AS_0, 8, blitz68k_state )
 
1679
        AM_RANGE(0x000, 0x3ff) AM_DEVREADWRITE("ramdac",ramdac_device,ramdac_pal_r,ramdac_rgb666_w)
1601
1680
ADDRESS_MAP_END
1602
1681
 
1603
1682
static RAMDAC_INTERFACE( ramdac_intf )
1658
1737
//  for(i=0;i<8;i+=2)
1659
1738
//      state->m_nvram[((0x8a0)+i)/2] = 0;
1660
1739
        /*finally, read the inputs*/
1661
 
        state->m_nvram[0x89e/2] = input_port_read(timer.machine(), "MENU") & 0xffff;
1662
 
        state->m_nvram[0x8a0/2] = input_port_read(timer.machine(), "STAT") & 0xffff;
1663
 
        state->m_nvram[0x8a2/2] = input_port_read(timer.machine(), "BET_DEAL") & 0xffff;
1664
 
        state->m_nvram[0x8a4/2] = input_port_read(timer.machine(), "TAKE_DOUBLE") & 0xffff;
1665
 
        state->m_nvram[0x8a6/2] = input_port_read(timer.machine(), "SMALL_BIG") & 0xffff;
1666
 
        state->m_nvram[0x8a8/2] = input_port_read(timer.machine(), "CANCEL_HOLD1") & 0xffff;
1667
 
        state->m_nvram[0x8aa/2] = input_port_read(timer.machine(), "HOLD2_HOLD3") & 0xffff;
1668
 
        state->m_nvram[0x8ac/2] = input_port_read(timer.machine(), "HOLD4_HOLD5") & 0xffff;
 
1740
        state->m_nvram[0x89e/2] = timer.machine().root_device().ioport("MENU")->read() & 0xffff;
 
1741
        state->m_nvram[0x8a0/2] = timer.machine().root_device().ioport("STAT")->read() & 0xffff;
 
1742
        state->m_nvram[0x8a2/2] = timer.machine().root_device().ioport("BET_DEAL")->read() & 0xffff;
 
1743
        state->m_nvram[0x8a4/2] = timer.machine().root_device().ioport("TAKE_DOUBLE")->read() & 0xffff;
 
1744
        state->m_nvram[0x8a6/2] = timer.machine().root_device().ioport("SMALL_BIG")->read() & 0xffff;
 
1745
        state->m_nvram[0x8a8/2] = timer.machine().root_device().ioport("CANCEL_HOLD1")->read() & 0xffff;
 
1746
        state->m_nvram[0x8aa/2] = timer.machine().root_device().ioport("HOLD2_HOLD3")->read() & 0xffff;
 
1747
        state->m_nvram[0x8ac/2] = timer.machine().root_device().ioport("HOLD4_HOLD5")->read() & 0xffff;
1669
1748
}
1670
1749
 
1671
1750
 
2611
2690
 
2612
2691
static DRIVER_INIT( bankrob )
2613
2692
{
2614
 
        UINT16 *ROM = (UINT16 *)machine.region("maincpu")->base();
 
2693
        UINT16 *ROM = (UINT16 *)machine.root_device().memregion("maincpu")->base();
2615
2694
 
2616
2695
        // WRONG C8 #1
2617
2696
        ROM[0xb5e0/2] = 0x6028;
2626
2705
 
2627
2706
static DRIVER_INIT( bankroba )
2628
2707
{
2629
 
        UINT16 *ROM = (UINT16 *)machine.region("maincpu")->base();
 
2708
        UINT16 *ROM = (UINT16 *)machine.root_device().memregion("maincpu")->base();
2630
2709
 
2631
2710
        // WRONG C8 #1
2632
2711
        ROM[0x11e4e/2] = 0x6028;
2641
2720
 
2642
2721
static DRIVER_INIT( cjffruit )
2643
2722
{
2644
 
        UINT16 *ROM = (UINT16 *)machine.region("maincpu")->base();
 
2723
        UINT16 *ROM = (UINT16 *)machine.root_device().memregion("maincpu")->base();
2645
2724
 
2646
2725
        // WRONG C8 #1
2647
2726
        ROM[0xf564/2] = 0x6028;
2652
2731
 
2653
2732
static DRIVER_INIT( deucesw2 )
2654
2733
{
2655
 
        UINT16 *ROM = (UINT16 *)machine.region("maincpu")->base();
 
2734
        UINT16 *ROM = (UINT16 *)machine.root_device().memregion("maincpu")->base();
2656
2735
 
2657
2736
        // WRONG C8 #1
2658
2737
        ROM[0x8fe4/2] = 0x6020;
2663
2742
 
2664
2743
static DRIVER_INIT( dualgame )
2665
2744
{
2666
 
        UINT16 *ROM = (UINT16 *)machine.region("maincpu")->base();
 
2745
        UINT16 *ROM = (UINT16 *)machine.root_device().memregion("maincpu")->base();
2667
2746
 
2668
2747
        // WRONG C8 #1
2669
2748
        ROM[0xa518/2] = 0x6024;
2674
2753
 
2675
2754
static DRIVER_INIT( hermit )
2676
2755
{
2677
 
        UINT16 *ROM = (UINT16 *)machine.region("maincpu")->base();
 
2756
        UINT16 *ROM = (UINT16 *)machine.root_device().memregion("maincpu")->base();
2678
2757
 
2679
2758
        // WRONG C8 #1
2680
2759
        ROM[0xdeba/2] = 0x602e;
2691
2770
 
2692
2771
static DRIVER_INIT( maxidbl )
2693
2772
{
2694
 
        UINT16 *ROM = (UINT16 *)machine.region("maincpu")->base();
 
2773
        UINT16 *ROM = (UINT16 *)machine.root_device().memregion("maincpu")->base();
2695
2774
 
2696
2775
        // WRONG C8 #1
2697
2776
        ROM[0xb384/2] = 0x6036;
2702
2781
 
2703
2782
static DRIVER_INIT( megadblj )
2704
2783
{
2705
 
        UINT16 *ROM = (UINT16 *)machine.region("maincpu")->base();
 
2784
        UINT16 *ROM = (UINT16 *)machine.root_device().memregion("maincpu")->base();
2706
2785
 
2707
2786
        // WRONG C8 #1
2708
2787
        ROM[0xe21c/2] = 0x6040;
2713
2792
 
2714
2793
static DRIVER_INIT( megadble )
2715
2794
{
2716
 
        UINT16 *ROM = (UINT16 *)machine.region("maincpu")->base();
 
2795
        UINT16 *ROM = (UINT16 *)machine.root_device().memregion("maincpu")->base();
2717
2796
 
2718
2797
        // WRONG C8 #1
2719
2798
        ROM[0xcfc2/2] = 0x4e71;