← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/mame/drivers/darius.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/darius.c
148
148
        device_set_input_line(state->m_cpub, INPUT_LINE_RESET, (state->m_cpua_ctrl & 0x01) ? CLEAR_LINE : ASSERT_LINE);
149
149
}
150
150
 
151
 
static WRITE16_HANDLER( cpua_ctrl_w )
 
151
WRITE16_MEMBER(darius_state::cpua_ctrl_w)
152
152
{
153
 
        darius_state *state = space->machine().driver_data<darius_state>();
154
153
 
155
154
        if ((data & 0xff00) && ((data & 0xff) == 0))
156
155
                data = data >> 8;
157
156
 
158
 
        state->m_cpua_ctrl = data;
159
 
 
160
 
        parse_control(space->machine());
161
 
 
162
 
        logerror("CPU #0 PC %06x: write %04x to cpu control\n", cpu_get_pc(&space->device()), data);
 
157
        m_cpua_ctrl = data;
 
158
 
 
159
        parse_control(machine());
 
160
 
 
161
        logerror("CPU #0 PC %06x: write %04x to cpu control\n", cpu_get_pc(&space.device()), data);
163
162
}
164
163
 
165
 
static WRITE16_HANDLER( darius_watchdog_w )
 
164
WRITE16_MEMBER(darius_state::darius_watchdog_w)
166
165
{
167
166
        watchdog_reset_w(space, 0, data);
168
167
}
172
171
                        GAME INPUTS
173
172
**********************************************************/
174
173
 
175
 
static READ16_HANDLER( darius_ioc_r )
 
174
READ16_MEMBER(darius_state::darius_ioc_r)
176
175
{
177
 
        darius_state *state = space->machine().driver_data<darius_state>();
178
176
 
179
177
        switch (offset)
180
178
        {
181
179
                case 0x01:
182
 
                        return (tc0140syt_comm_r(state->m_tc0140syt, 0) & 0xff);        /* sound interface read */
 
180
                        return (tc0140syt_comm_r(m_tc0140syt, 0) & 0xff);       /* sound interface read */
183
181
 
184
182
                case 0x04:
185
 
                        return input_port_read(space->machine(), "P1");
 
183
                        return ioport("P1")->read();
186
184
 
187
185
                case 0x05:
188
 
                        return input_port_read(space->machine(), "P2");
 
186
                        return ioport("P2")->read();
189
187
 
190
188
                case 0x06:
191
 
                        return input_port_read(space->machine(), "SYSTEM");
 
189
                        return ioport("SYSTEM")->read();
192
190
 
193
191
                case 0x07:
194
 
                        return state->m_coin_word;      /* bits 3&4 coin lockouts, must return zero */
 
192
                        return m_coin_word;     /* bits 3&4 coin lockouts, must return zero */
195
193
 
196
194
                case 0x08:
197
 
                        return input_port_read(space->machine(), "DSW");
 
195
                        return ioport("DSW")->read();
198
196
        }
199
197
 
200
 
logerror("CPU #0 PC %06x: warning - read unmapped ioc offset %06x\n",cpu_get_pc(&space->device()),offset);
 
198
logerror("CPU #0 PC %06x: warning - read unmapped ioc offset %06x\n",cpu_get_pc(&space.device()),offset);
201
199
 
202
200
        return 0xff;
203
201
}
204
202
 
205
 
static WRITE16_HANDLER( darius_ioc_w )
 
203
WRITE16_MEMBER(darius_state::darius_ioc_w)
206
204
{
207
 
        darius_state *state = space->machine().driver_data<darius_state>();
208
205
 
209
206
        switch (offset)
210
207
        {
211
208
                case 0x00:      /* sound interface write */
212
209
 
213
 
                        tc0140syt_port_w(state->m_tc0140syt, 0, data & 0xff);
 
210
                        tc0140syt_port_w(m_tc0140syt, 0, data & 0xff);
214
211
                        return;
215
212
 
216
213
                case 0x01:      /* sound interface write */
217
214
 
218
 
                        tc0140syt_comm_w(state->m_tc0140syt, 0, data & 0xff);
 
215
                        tc0140syt_comm_w(m_tc0140syt, 0, data & 0xff);
219
216
                        return;
220
217
 
221
218
                case 0x28:      /* unknown, written by both cpus - always 0? */
225
222
                case 0x30:      /* coin control */
226
223
                        /* bits 7,5,4,0 used on reset */
227
224
                        /* bit 4 used whenever bg is blanked ? */
228
 
                        coin_lockout_w(space->machine(), 0, ~data & 0x02);
229
 
                        coin_lockout_w(space->machine(), 1, ~data & 0x04);
230
 
                        coin_counter_w(space->machine(), 0, data & 0x08);
231
 
                        coin_counter_w(space->machine(), 1, data & 0x40);
232
 
                        state->m_coin_word = data & 0xffff;
 
225
                        coin_lockout_w(machine(), 0, ~data & 0x02);
 
226
                        coin_lockout_w(machine(), 1, ~data & 0x04);
 
227
                        coin_counter_w(machine(), 0, data & 0x08);
 
228
                        coin_counter_w(machine(), 1, data & 0x40);
 
229
                        m_coin_word = data & 0xffff;
233
230
//popmessage(" address %04x value %04x",offset,data);
234
231
                        return;
235
232
        }
236
233
 
237
 
logerror("CPU #0 PC %06x: warning - write unmapped ioc offset %06x with %04x\n",cpu_get_pc(&space->device()),offset,data);
 
234
logerror("CPU #0 PC %06x: warning - write unmapped ioc offset %06x with %04x\n",cpu_get_pc(&space.device()),offset,data);
238
235
}
239
236
 
240
237
 
242
239
                     MEMORY STRUCTURES
243
240
***********************************************************/
244
241
 
245
 
static ADDRESS_MAP_START( darius_map, AS_PROGRAM, 16 )
 
242
static ADDRESS_MAP_START( darius_map, AS_PROGRAM, 16, darius_state )
246
243
        AM_RANGE(0x000000, 0x05ffff) AM_ROM
247
244
        AM_RANGE(0x080000, 0x08ffff) AM_RAM                                                                                             /* main RAM */
248
245
        AM_RANGE(0x0a0000, 0x0a0001) AM_WRITE(cpua_ctrl_w)
249
246
        AM_RANGE(0x0b0000, 0x0b0001) AM_WRITE(darius_watchdog_w)
250
247
        AM_RANGE(0xc00000, 0xc0007f) AM_READWRITE(darius_ioc_r, darius_ioc_w)                   /* inputs, sound */
251
 
        AM_RANGE(0xd00000, 0xd0ffff) AM_DEVREADWRITE("pc080sn", pc080sn_word_r, pc080sn_word_w) /* tilemaps */
252
 
        AM_RANGE(0xd20000, 0xd20003) AM_DEVWRITE("pc080sn", pc080sn_yscroll_word_w)
253
 
        AM_RANGE(0xd40000, 0xd40003) AM_DEVWRITE("pc080sn", pc080sn_xscroll_word_w)
254
 
        AM_RANGE(0xd50000, 0xd50003) AM_DEVWRITE("pc080sn", pc080sn_ctrl_word_w)
255
 
        AM_RANGE(0xd80000, 0xd80fff) AM_RAM_WRITE(paletteram16_xBBBBBGGGGGRRRRR_word_w) AM_BASE_GENERIC(paletteram)/* palette */
256
 
        AM_RANGE(0xe00100, 0xe00fff) AM_RAM AM_SHARE("share1") AM_BASE_SIZE_MEMBER(darius_state, m_spriteram, m_spriteram_size)
 
248
        AM_RANGE(0xd00000, 0xd0ffff) AM_DEVREADWRITE_LEGACY("pc080sn", pc080sn_word_r, pc080sn_word_w)  /* tilemaps */
 
249
        AM_RANGE(0xd20000, 0xd20003) AM_DEVWRITE_LEGACY("pc080sn", pc080sn_yscroll_word_w)
 
250
        AM_RANGE(0xd40000, 0xd40003) AM_DEVWRITE_LEGACY("pc080sn", pc080sn_xscroll_word_w)
 
251
        AM_RANGE(0xd50000, 0xd50003) AM_DEVWRITE_LEGACY("pc080sn", pc080sn_ctrl_word_w)
 
252
        AM_RANGE(0xd80000, 0xd80fff) AM_RAM_WRITE(paletteram_xBBBBBGGGGGRRRRR_word_w) AM_SHARE("paletteram")/* palette */
 
253
        AM_RANGE(0xe00100, 0xe00fff) AM_RAM AM_SHARE("spriteram")
257
254
        AM_RANGE(0xe01000, 0xe02fff) AM_RAM AM_SHARE("share2")
258
 
        AM_RANGE(0xe08000, 0xe0ffff) AM_RAM_WRITE(darius_fg_layer_w) AM_SHARE("share3") AM_BASE_MEMBER(darius_state, m_fg_ram)
 
255
        AM_RANGE(0xe08000, 0xe0ffff) AM_RAM_WRITE(darius_fg_layer_w) AM_SHARE("fg_ram")
259
256
        AM_RANGE(0xe10000, 0xe10fff) AM_RAM                                                                                             /* ??? */
260
257
ADDRESS_MAP_END
261
258
 
262
 
static ADDRESS_MAP_START( darius_cpub_map, AS_PROGRAM, 16 )
 
259
static ADDRESS_MAP_START( darius_cpub_map, AS_PROGRAM, 16, darius_state )
263
260
        AM_RANGE(0x000000, 0x03ffff) AM_ROM
264
261
        AM_RANGE(0x040000, 0x04ffff) AM_RAM                             /* local RAM */
265
262
        AM_RANGE(0xc00000, 0xc0007f) AM_WRITE(darius_ioc_w)     /* only writes $c00050 (?) */
266
 
        AM_RANGE(0xd80000, 0xd80fff) AM_WRITE(paletteram16_xBBBBBGGGGGRRRRR_word_w)
267
 
        AM_RANGE(0xe00100, 0xe00fff) AM_RAM AM_SHARE("share1")
 
263
        AM_RANGE(0xd80000, 0xd80fff) AM_WRITE(paletteram_xBBBBBGGGGGRRRRR_word_w)
 
264
        AM_RANGE(0xe00100, 0xe00fff) AM_RAM AM_SHARE("spriteram")
268
265
        AM_RANGE(0xe01000, 0xe02fff) AM_RAM AM_SHARE("share2")
269
 
        AM_RANGE(0xe08000, 0xe0ffff) AM_RAM_WRITE(darius_fg_layer_w) AM_SHARE("share3")
 
266
        AM_RANGE(0xe08000, 0xe0ffff) AM_RAM_WRITE(darius_fg_layer_w) AM_SHARE("fg_ram")
270
267
ADDRESS_MAP_END
271
268
 
272
269
 
277
274
static void reset_sound_region( running_machine &machine )
278
275
{
279
276
        darius_state *state = machine.driver_data<darius_state>();
280
 
        memory_set_bank(machine, "bank1", state->m_banknum);
 
277
        state->membank("bank1")->set_entry(state->m_banknum);
281
278
}
282
279
 
283
 
static WRITE8_HANDLER( sound_bankswitch_w )
 
280
WRITE8_MEMBER(darius_state::sound_bankswitch_w)
284
281
{
285
 
        darius_state *state = space->machine().driver_data<darius_state>();
286
282
 
287
 
        state->m_banknum = data & 0x03;
288
 
        reset_sound_region(space->machine());
 
283
        m_banknum = data & 0x03;
 
284
        reset_sound_region(machine());
289
285
//  banknum = data;
290
286
//  reset_sound_region();
291
287
}
292
288
 
293
 
static WRITE8_HANDLER( adpcm_command_w )
 
289
WRITE8_MEMBER(darius_state::adpcm_command_w)
294
290
{
295
 
        darius_state *state = space->machine().driver_data<darius_state>();
296
 
        state->m_adpcm_command = data;
 
291
        m_adpcm_command = data;
297
292
        /* logerror("#ADPCM command write =%2x\n",data); */
298
293
}
299
294
 
300
295
#if 0
301
 
static WRITE8_HANDLER( display_value )
 
296
WRITE8_MEMBER(darius_state::display_value)
302
297
{
303
298
        popmessage("d800=%x", data);
304
299
}
391
386
                flt_volume_set_volume(state->m_msm5205_r, right / 100.0);
392
387
}
393
388
 
394
 
static WRITE8_HANDLER( darius_fm0_pan )
395
 
{
396
 
        darius_state *state = space->machine().driver_data<darius_state>();
397
 
        state->m_pan[0] = data & 0xff;  /* data 0x00:right 0xff:left */
398
 
        update_fm0(space->machine());
399
 
}
400
 
 
401
 
static WRITE8_HANDLER( darius_fm1_pan )
402
 
{
403
 
        darius_state *state = space->machine().driver_data<darius_state>();
404
 
        state->m_pan[1] = data & 0xff;
405
 
        update_fm1(space->machine());
406
 
}
407
 
 
408
 
static WRITE8_HANDLER( darius_psg0_pan )
409
 
{
410
 
        darius_state *state = space->machine().driver_data<darius_state>();
411
 
        state->m_pan[2] = data & 0xff;
412
 
        update_psg0(space->machine(), 0);
413
 
        update_psg0(space->machine(), 1);
414
 
        update_psg0(space->machine(), 2);
415
 
}
416
 
 
417
 
static WRITE8_HANDLER( darius_psg1_pan )
418
 
{
419
 
        darius_state *state = space->machine().driver_data<darius_state>();
420
 
        state->m_pan[3] = data & 0xff;
421
 
        update_psg1(space->machine(), 0);
422
 
        update_psg1(space->machine(), 1);
423
 
        update_psg1(space->machine(), 2);
424
 
}
425
 
 
426
 
static WRITE8_HANDLER( darius_da_pan )
427
 
{
428
 
        darius_state *state = space->machine().driver_data<darius_state>();
429
 
        state->m_pan[4] = data & 0xff;
430
 
        update_da(space->machine());
 
389
WRITE8_MEMBER(darius_state::darius_fm0_pan)
 
390
{
 
391
        m_pan[0] = data & 0xff;  /* data 0x00:right 0xff:left */
 
392
        update_fm0(machine());
 
393
}
 
394
 
 
395
WRITE8_MEMBER(darius_state::darius_fm1_pan)
 
396
{
 
397
        m_pan[1] = data & 0xff;
 
398
        update_fm1(machine());
 
399
}
 
400
 
 
401
WRITE8_MEMBER(darius_state::darius_psg0_pan)
 
402
{
 
403
        m_pan[2] = data & 0xff;
 
404
        update_psg0(machine(), 0);
 
405
        update_psg0(machine(), 1);
 
406
        update_psg0(machine(), 2);
 
407
}
 
408
 
 
409
WRITE8_MEMBER(darius_state::darius_psg1_pan)
 
410
{
 
411
        m_pan[3] = data & 0xff;
 
412
        update_psg1(machine(), 0);
 
413
        update_psg1(machine(), 1);
 
414
        update_psg1(machine(), 2);
 
415
}
 
416
 
 
417
WRITE8_MEMBER(darius_state::darius_da_pan)
 
418
{
 
419
        m_pan[4] = data & 0xff;
 
420
        update_da(machine());
431
421
}
432
422
 
433
423
/**** Mixer Control ****/
490
480
           Sound memory structures / ADPCM
491
481
*****************************************************/
492
482
 
493
 
static ADDRESS_MAP_START( darius_sound_map, AS_PROGRAM, 8 )
 
483
static ADDRESS_MAP_START( darius_sound_map, AS_PROGRAM, 8, darius_state )
494
484
        AM_RANGE(0x0000, 0x7fff) AM_ROMBANK("bank1")
495
485
        AM_RANGE(0x8000, 0x8fff) AM_RAM
496
 
        AM_RANGE(0x9000, 0x9001) AM_DEVREADWRITE("ym1", ym2203_r, ym2203_w)
497
 
        AM_RANGE(0xa000, 0xa001) AM_DEVREADWRITE("ym2", ym2203_r, ym2203_w)
498
 
        AM_RANGE(0xb000, 0xb000) AM_READNOP AM_DEVWRITE("tc0140syt", tc0140syt_slave_port_w)
499
 
        AM_RANGE(0xb001, 0xb001) AM_DEVREADWRITE("tc0140syt", tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
 
486
        AM_RANGE(0x9000, 0x9001) AM_DEVREADWRITE_LEGACY("ym1", ym2203_r, ym2203_w)
 
487
        AM_RANGE(0xa000, 0xa001) AM_DEVREADWRITE_LEGACY("ym2", ym2203_r, ym2203_w)
 
488
        AM_RANGE(0xb000, 0xb000) AM_READNOP AM_DEVWRITE_LEGACY("tc0140syt", tc0140syt_slave_port_w)
 
489
        AM_RANGE(0xb001, 0xb001) AM_DEVREADWRITE_LEGACY("tc0140syt", tc0140syt_slave_comm_r, tc0140syt_slave_comm_w)
500
490
        AM_RANGE(0xc000, 0xc000) AM_WRITE(darius_fm0_pan)
501
491
        AM_RANGE(0xc400, 0xc400) AM_WRITE(darius_fm1_pan)
502
492
        AM_RANGE(0xc800, 0xc800) AM_WRITE(darius_psg0_pan)
507
497
        AM_RANGE(0xdc00, 0xdc00) AM_WRITE(sound_bankswitch_w)
508
498
ADDRESS_MAP_END
509
499
 
510
 
static ADDRESS_MAP_START( darius_sound2_map, AS_PROGRAM, 8 )
 
500
static ADDRESS_MAP_START( darius_sound2_map, AS_PROGRAM, 8, darius_state )
511
501
        AM_RANGE(0x0000, 0xffff) AM_ROM AM_WRITENOP
512
502
        /* yes, no RAM */
513
503
ADDRESS_MAP_END
527
517
        MSM5205_S48_4B          /* 8KHz   */
528
518
};
529
519
 
530
 
static READ8_HANDLER( adpcm_command_read )
531
 
{
532
 
        darius_state *state = space->machine().driver_data<darius_state>();
533
 
 
534
 
        /* logerror("read port 0: %02x  PC=%4x\n",adpcm_command, cpu_get_pc(&space->device()) ); */
535
 
        return state->m_adpcm_command;
536
 
}
537
 
 
538
 
static READ8_HANDLER( readport2 )
539
 
{
540
 
        return 0;
541
 
}
542
 
 
543
 
static READ8_HANDLER( readport3 )
544
 
{
545
 
        return 0;
546
 
}
547
 
 
548
 
static WRITE8_HANDLER( adpcm_nmi_disable )
549
 
{
550
 
        darius_state *state = space->machine().driver_data<darius_state>();
551
 
 
552
 
        state->m_nmi_enable = 0;
553
 
        /* logerror("write port 0: NMI DISABLE  PC=%4x\n", data, cpu_get_pc(&space->device()) ); */
554
 
}
555
 
 
556
 
static WRITE8_HANDLER( adpcm_nmi_enable )
557
 
{
558
 
        darius_state *state = space->machine().driver_data<darius_state>();
559
 
        state->m_nmi_enable = 1;
560
 
        /* logerror("write port 1: NMI ENABLE   PC=%4x\n", cpu_get_pc(&space->device()) ); */
 
520
READ8_MEMBER(darius_state::adpcm_command_read)
 
521
{
 
522
 
 
523
        /* logerror("read port 0: %02x  PC=%4x\n",adpcm_command, cpu_get_pc(&space.device()) ); */
 
524
        return m_adpcm_command;
 
525
}
 
526
 
 
527
READ8_MEMBER(darius_state::readport2)
 
528
{
 
529
        return 0;
 
530
}
 
531
 
 
532
READ8_MEMBER(darius_state::readport3)
 
533
{
 
534
        return 0;
 
535
}
 
536
 
 
537
WRITE8_MEMBER(darius_state::adpcm_nmi_disable)
 
538
{
 
539
 
 
540
        m_nmi_enable = 0;
 
541
        /* logerror("write port 0: NMI DISABLE  PC=%4x\n", data, cpu_get_pc(&space.device()) ); */
 
542
}
 
543
 
 
544
WRITE8_MEMBER(darius_state::adpcm_nmi_enable)
 
545
{
 
546
        m_nmi_enable = 1;
 
547
        /* logerror("write port 1: NMI ENABLE   PC=%4x\n", cpu_get_pc(&space.device()) ); */
561
548
}
562
549
 
563
550
static WRITE8_DEVICE_HANDLER( adpcm_data_w )
566
553
        msm5205_reset_w(device, !(data & 0x20));        /* my best guess, but it could be output enable as well */
567
554
}
568
555
 
569
 
static ADDRESS_MAP_START( darius_sound2_io_map, AS_IO, 8 )
 
556
static ADDRESS_MAP_START( darius_sound2_io_map, AS_IO, 8, darius_state )
570
557
        ADDRESS_MAP_GLOBAL_MASK(0xff)
571
558
        AM_RANGE(0x00, 0x00) AM_READWRITE(adpcm_command_read, adpcm_nmi_disable)
572
559
        AM_RANGE(0x01, 0x01) AM_WRITE(adpcm_nmi_enable)
573
 
        AM_RANGE(0x02, 0x02) AM_READ(readport2) AM_DEVWRITE("msm", adpcm_data_w)        /* readport2 ??? */
 
560
        AM_RANGE(0x02, 0x02) AM_READ(readport2) AM_DEVWRITE_LEGACY("msm", adpcm_data_w) /* readport2 ??? */
574
561
        AM_RANGE(0x03, 0x03) AM_READ(readport3) /* ??? */
575
562
ADDRESS_MAP_END
576
563
 
855
842
{
856
843
        darius_state *state = machine.driver_data<darius_state>();
857
844
 
858
 
        memory_configure_bank(machine, "bank1", 0, 4, machine.region("audiocpu")->base() + 0x10000, 0x8000);
859
 
        memory_configure_bank(machine, "bank1", 4, 1, machine.region("audiocpu")->base(), 0x8000);
860
 
        memory_set_bank(machine, "bank1", 4);
 
845
        state->membank("bank1")->configure_entries(0, 4, state->memregion("audiocpu")->base() + 0x10000, 0x8000);
 
846
        state->membank("bank1")->configure_entry(4, state->memregion("audiocpu")->base());
 
847
        state->membank("bank1")->set_entry(4);
861
848
 
862
849
        state->m_maincpu = machine.device("maincpu");
863
850
        state->m_audiocpu = machine.device("audiocpu");
1288
1275
static DRIVER_INIT( darius )
1289
1276
{
1290
1277
        /**** setup sound bank image ****/
1291
 
        UINT8 *RAM = machine.region("audiocpu")->base();
 
1278
        UINT8 *RAM = machine.root_device().memregion("audiocpu")->base();
1292
1279
        int  i;
1293
1280
 
1294
1281
        for (i = 3; i >= 0; i--)