← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/mame/drivers/namcos11.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/namcos11.c
284
284
public:
285
285
        namcos11_state(const machine_config &mconfig, device_type type, const char *tag)
286
286
                : psx_state(mconfig, type, tag),
 
287
                m_sharedram(*this,"sharedram"),
 
288
                m_keycus(*this,"keycus"),
287
289
                m_maincpu(*this,"maincpu"),
288
290
                m_mcu(*this,"c76")
289
291
                { }
290
292
 
291
 
        UINT32 *m_sharedram;
292
 
        UINT32 *m_keycus;
 
293
        required_shared_ptr<UINT32> m_sharedram;
 
294
        required_shared_ptr<UINT32> m_keycus;
293
295
        size_t m_keycus_size;
294
296
        UINT8 m_su_83;
295
297
 
297
299
 
298
300
        required_device<cpu_device> m_maincpu;
299
301
        required_device<cpu_device> m_mcu;
 
302
        DECLARE_WRITE32_MEMBER(keycus_w);
 
303
        DECLARE_READ32_MEMBER(keycus_c406_r);
 
304
        DECLARE_READ32_MEMBER(keycus_c409_r);
 
305
        DECLARE_READ32_MEMBER(keycus_c410_r);
 
306
        DECLARE_READ32_MEMBER(keycus_c411_r);
 
307
        DECLARE_READ32_MEMBER(keycus_c430_r);
 
308
        DECLARE_READ32_MEMBER(keycus_c431_r);
 
309
        DECLARE_READ32_MEMBER(keycus_c432_r);
 
310
        DECLARE_READ32_MEMBER(keycus_c442_r);
 
311
        DECLARE_READ32_MEMBER(keycus_c443_r);
 
312
        DECLARE_WRITE32_MEMBER(bankswitch_rom32_w);
 
313
        DECLARE_WRITE32_MEMBER(bankswitch_rom64_upper_w);
 
314
        DECLARE_WRITE32_MEMBER(bankswitch_rom64_w);
 
315
        DECLARE_WRITE32_MEMBER(lightgun_w);
 
316
        DECLARE_READ32_MEMBER(lightgun_r);
 
317
        DECLARE_READ16_MEMBER(c76_shared_r);
 
318
        DECLARE_WRITE16_MEMBER(c76_shared_w);
 
319
        DECLARE_READ16_MEMBER(c76_inputs_r);
 
320
        DECLARE_READ8_MEMBER(dac7_r);
 
321
        DECLARE_READ8_MEMBER(dac6_r);
 
322
        DECLARE_READ8_MEMBER(dac5_r);
 
323
        DECLARE_READ8_MEMBER(dac4_r);
 
324
        DECLARE_READ8_MEMBER(dac3_r);
 
325
        DECLARE_READ8_MEMBER(dac2_r);
 
326
        DECLARE_READ8_MEMBER(dac1_r);
 
327
        DECLARE_READ8_MEMBER(dac0_r);
 
328
        DECLARE_READ8_MEMBER(pocketrc_gas_r);
 
329
        DECLARE_READ8_MEMBER(pocketrc_steer_r);
 
330
        DECLARE_READ16_MEMBER(c76_speedup_r);
 
331
        DECLARE_WRITE16_MEMBER(c76_speedup_w);
300
332
};
301
333
 
302
334
INLINE void ATTR_PRINTF(3,4) verboselog( running_machine &machine, int n_level, const char *s_fmt, ... )
312
344
        }
313
345
}
314
346
 
315
 
static WRITE32_HANDLER( keycus_w )
 
347
WRITE32_MEMBER(namcos11_state::keycus_w)
316
348
{
317
 
        namcos11_state *state = space->machine().driver_data<namcos11_state>();
318
349
 
319
 
        verboselog( space->machine(), 1, "keycus_w( %08x, %08x, %08x )\n", offset, data, mem_mask );
320
 
        COMBINE_DATA( &state->m_keycus[ offset ] );
 
350
        verboselog( machine(), 1, "keycus_w( %08x, %08x, %08x )\n", offset, data, mem_mask );
 
351
        COMBINE_DATA( &m_keycus[ offset ] );
321
352
}
322
353
 
323
354
/* tekken 2 */
324
 
static READ32_HANDLER( keycus_c406_r )
 
355
READ32_MEMBER(namcos11_state::keycus_c406_r)
325
356
{
326
357
        /* todo: verify behaviour */
327
 
        namcos11_state *state = space->machine().driver_data<namcos11_state>();
328
 
        UINT32 *namcos11_keycus = state->m_keycus;
 
358
        UINT32 *namcos11_keycus = m_keycus;
329
359
        UINT32 data;
330
360
 
331
361
        data = namcos11_keycus[ offset ];
339
369
                        ( ( namcos11_keycus[ 1 ] >> 8 ) & 0xf );
340
370
                break;
341
371
        }
342
 
        verboselog( space->machine(), 1, "keycus_c406_r( %08x, %08x, %08x )\n", offset, data, mem_mask );
 
372
        verboselog( machine(), 1, "keycus_c406_r( %08x, %08x, %08x )\n", offset, data, mem_mask );
343
373
        return data;
344
374
}
345
375
 
346
376
/* soul edge */
347
 
static READ32_HANDLER( keycus_c409_r )
 
377
READ32_MEMBER(namcos11_state::keycus_c409_r)
348
378
{
349
379
        /* todo: verify behaviour */
350
 
        namcos11_state *state = space->machine().driver_data<namcos11_state>();
351
380
        UINT32 data;
352
381
 
353
 
        data = state->m_keycus[ offset ];
 
382
        data = m_keycus[ offset ];
354
383
        switch( offset )
355
384
        {
356
385
        case 3:
357
386
                data = ( data & 0x0000ffff ) | 0x000f0000;
358
387
                break;
359
388
        }
360
 
        verboselog( space->machine(), 1, "keycus_c409_r( %08x, %08x, %08x )\n", offset, data, mem_mask );
 
389
        verboselog( machine(), 1, "keycus_c409_r( %08x, %08x, %08x )\n", offset, data, mem_mask );
361
390
        return data;
362
391
}
363
392
 
364
393
/* dunk mania */
365
 
static READ32_HANDLER( keycus_c410_r )
 
394
READ32_MEMBER(namcos11_state::keycus_c410_r)
366
395
{
367
 
        namcos11_state *state = space->machine().driver_data<namcos11_state>();
368
 
        UINT32 *namcos11_keycus = state->m_keycus;
 
396
        UINT32 *namcos11_keycus = m_keycus;
369
397
        UINT32 data;
370
398
        UINT32 n_value;
371
399
 
393
421
                        ( ( ( n_value / 10000 ) % 10 ) << 16 );
394
422
                break;
395
423
        }
396
 
        verboselog( space->machine(), 1, "keycus_c410_r( %08x, %08x, %08x )\n", offset, data, mem_mask );
 
424
        verboselog( machine(), 1, "keycus_c410_r( %08x, %08x, %08x )\n", offset, data, mem_mask );
397
425
        return data;
398
426
}
399
427
 
400
428
/* prime goal ex */
401
 
static READ32_HANDLER( keycus_c411_r )
 
429
READ32_MEMBER(namcos11_state::keycus_c411_r)
402
430
{
403
 
        namcos11_state *state = space->machine().driver_data<namcos11_state>();
404
 
        UINT32 *namcos11_keycus = state->m_keycus;
 
431
        UINT32 *namcos11_keycus = m_keycus;
405
432
        UINT32 data;
406
433
        UINT32 n_value;
407
434
 
428
455
                break;
429
456
        }
430
457
 
431
 
        verboselog( space->machine(), 1, "keycus_c411_r( %08x, %08x, %08x )\n", offset, data, mem_mask );
 
458
        verboselog( machine(), 1, "keycus_c411_r( %08x, %08x, %08x )\n", offset, data, mem_mask );
432
459
        return data;
433
460
}
434
461
 
435
462
/* xevious 3d/g */
436
 
static READ32_HANDLER( keycus_c430_r )
 
463
READ32_MEMBER(namcos11_state::keycus_c430_r)
437
464
{
438
 
        namcos11_state *state = space->machine().driver_data<namcos11_state>();
439
 
        UINT32 *namcos11_keycus = state->m_keycus;
 
465
        UINT32 *namcos11_keycus = m_keycus;
440
466
        UINT32 data;
441
467
        UINT16 n_value;
442
468
 
464
490
                        ( ( ( n_value / 1 ) % 10 ) << 16 );
465
491
                break;
466
492
        }
467
 
        verboselog( space->machine(), 1, "keycus_c430_r( %08x, %08x, %08x )\n", offset, data, mem_mask );
 
493
        verboselog( machine(), 1, "keycus_c430_r( %08x, %08x, %08x )\n", offset, data, mem_mask );
468
494
        return data;
469
495
}
470
496
 
471
497
/* dancing eyes */
472
 
static READ32_HANDLER( keycus_c431_r )
 
498
READ32_MEMBER(namcos11_state::keycus_c431_r)
473
499
{
474
 
        namcos11_state *state = space->machine().driver_data<namcos11_state>();
475
 
        UINT32 *namcos11_keycus = state->m_keycus;
 
500
        UINT32 *namcos11_keycus = m_keycus;
476
501
        UINT32 data;
477
502
        UINT16 n_value;
478
503
 
498
523
                data = ( data & 0xffff0000 ) | ( ( n_value / 10000 ) % 10 );
499
524
                break;
500
525
        }
501
 
        verboselog( space->machine(), 1, "keycus_c431_r( %08x, %08x, %08x )\n", offset, data, mem_mask );
 
526
        verboselog( machine(), 1, "keycus_c431_r( %08x, %08x, %08x )\n", offset, data, mem_mask );
502
527
        return data;
503
528
}
504
529
 
505
530
/* pocket racer */
506
 
static READ32_HANDLER( keycus_c432_r )
 
531
READ32_MEMBER(namcos11_state::keycus_c432_r)
507
532
{
508
 
        namcos11_state *state = space->machine().driver_data<namcos11_state>();
509
 
        UINT32 *namcos11_keycus = state->m_keycus;
 
533
        UINT32 *namcos11_keycus = m_keycus;
510
534
        UINT32 data;
511
535
        UINT16 n_value;
512
536
 
533
557
                break;
534
558
        }
535
559
 
536
 
        verboselog( space->machine(), 1, "keycus_c432_r( %08x, %08x, %08x )\n", offset, data, mem_mask );
 
560
        verboselog( machine(), 1, "keycus_c432_r( %08x, %08x, %08x )\n", offset, data, mem_mask );
537
561
        return data;
538
562
}
539
563
 
540
564
/* star sweep */
541
 
static READ32_HANDLER( keycus_c442_r )
 
565
READ32_MEMBER(namcos11_state::keycus_c442_r)
542
566
{
543
567
        /* todo: verify behaviour */
544
 
        namcos11_state *state = space->machine().driver_data<namcos11_state>();
545
568
        UINT32 data;
546
569
 
547
 
        data = state->m_keycus[ offset ];
 
570
        data = m_keycus[ offset ];
548
571
 
549
572
        switch( offset )
550
573
        {
555
578
                }
556
579
                break;
557
580
        }
558
 
        verboselog( space->machine(), 1, "keycus_c442_r( %08x, %08x, %08x )\n", offset, data, mem_mask );
 
581
        verboselog( machine(), 1, "keycus_c442_r( %08x, %08x, %08x )\n", offset, data, mem_mask );
559
582
        return data;
560
583
}
561
584
 
562
585
/* kosodate quiz my angel 3 / point blank 2 */
563
 
static READ32_HANDLER( keycus_c443_r )
 
586
READ32_MEMBER(namcos11_state::keycus_c443_r)
564
587
{
565
588
        /* todo: verify behaviour */
566
 
        namcos11_state *state = space->machine().driver_data<namcos11_state>();
567
589
        UINT32 data;
568
590
 
569
 
        data = state->m_keycus[ offset ];
 
591
        data = m_keycus[ offset ];
570
592
 
571
593
        switch( offset )
572
594
        {
589
611
                }
590
612
                break;
591
613
        }
592
 
        verboselog( space->machine(), 1, "keycus_c443_r( %08x, %08x, %08x )\n", offset, data, mem_mask );
 
614
        verboselog( machine(), 1, "keycus_c443_r( %08x, %08x, %08x )\n", offset, data, mem_mask );
593
615
        return data;
594
616
}
595
617
 
596
618
INLINE void bankswitch_rom8( address_space *space, const char *bank, int n_data )
597
619
{
598
 
        memory_set_bank( space->machine(), bank, ( ( n_data & 0xc0 ) >> 4 ) + ( n_data & 0x03 ) );
 
620
        space->machine().root_device().membank( bank )->set_entry( ( ( n_data & 0xc0 ) >> 4 ) + ( n_data & 0x03 ) );
599
621
}
600
622
 
601
623
static const char * const bankname[] = { "bank1", "bank2", "bank3", "bank4", "bank5", "bank6", "bank7", "bank8" };
602
624
 
603
 
static WRITE32_HANDLER( bankswitch_rom32_w )
 
625
WRITE32_MEMBER(namcos11_state::bankswitch_rom32_w)
604
626
{
605
 
        verboselog( space->machine(), 2, "bankswitch_rom32_w( %08x, %08x, %08x )\n", offset, data, mem_mask );
 
627
        verboselog( machine(), 2, "bankswitch_rom32_w( %08x, %08x, %08x )\n", offset, data, mem_mask );
606
628
 
607
629
        if( ACCESSING_BITS_0_15 )
608
630
        {
609
 
                bankswitch_rom8( space, bankname[offset * 2], data & 0xffff );
 
631
                bankswitch_rom8( &space, bankname[offset * 2], data & 0xffff );
610
632
        }
611
633
        if( ACCESSING_BITS_16_31 )
612
634
        {
613
 
                bankswitch_rom8( space, bankname[offset * 2 + 1], data >> 16 );
 
635
                bankswitch_rom8( &space, bankname[offset * 2 + 1], data >> 16 );
614
636
        }
615
637
}
616
638
 
617
 
static WRITE32_HANDLER( bankswitch_rom64_upper_w )
 
639
WRITE32_MEMBER(namcos11_state::bankswitch_rom64_upper_w)
618
640
{
619
 
        namcos11_state *state = space->machine().driver_data<namcos11_state>();
620
641
 
621
 
        verboselog( space->machine(), 2, "bankswitch_rom64_upper_w( %08x, %08x, %08x )\n", offset, data, mem_mask );
 
642
        verboselog( machine(), 2, "bankswitch_rom64_upper_w( %08x, %08x, %08x )\n", offset, data, mem_mask );
622
643
 
623
644
        if( ACCESSING_BITS_0_15 )
624
645
        {
625
 
                state->m_n_bankoffset = 0;
 
646
                m_n_bankoffset = 0;
626
647
        }
627
648
        if( ACCESSING_BITS_16_31 )
628
649
        {
629
 
                state->m_n_bankoffset = 16;
 
650
                m_n_bankoffset = 16;
630
651
        }
631
652
}
632
653
 
635
656
        namcos11_state *state = space->machine().driver_data<namcos11_state>();
636
657
 
637
658
        /* todo: verify behaviour */
638
 
        memory_set_bank( space->machine(), bank, ( ( ( ( n_data & 0xc0 ) >> 3 ) + ( n_data & 0x07 ) ) ^ state->m_n_bankoffset ) );
 
659
        state->membank( bank )->set_entry( ( ( ( ( n_data & 0xc0 ) >> 3 ) + ( n_data & 0x07 ) ) ^ state->m_n_bankoffset ) );
639
660
}
640
661
 
641
 
static WRITE32_HANDLER( bankswitch_rom64_w )
 
662
WRITE32_MEMBER(namcos11_state::bankswitch_rom64_w)
642
663
{
643
 
        verboselog( space->machine(), 2, "bankswitch_rom64_w( %08x, %08x, %08x )\n", offset, data, mem_mask );
 
664
        verboselog( machine(), 2, "bankswitch_rom64_w( %08x, %08x, %08x )\n", offset, data, mem_mask );
644
665
 
645
666
        if( ACCESSING_BITS_0_15 )
646
667
        {
647
 
                bankswitch_rom64( space, bankname[offset * 2], data & 0xffff );
 
668
                bankswitch_rom64( &space, bankname[offset * 2], data & 0xffff );
648
669
        }
649
670
        if( ACCESSING_BITS_16_31 )
650
671
        {
651
 
                bankswitch_rom64( space, bankname[offset * 2 + 1], data >> 16 );
 
672
                bankswitch_rom64( &space, bankname[offset * 2 + 1], data >> 16 );
652
673
        }
653
674
}
654
675
 
655
 
static WRITE32_HANDLER( lightgun_w )
 
676
WRITE32_MEMBER(namcos11_state::lightgun_w)
656
677
{
657
678
        if( ACCESSING_BITS_0_15 )
658
679
        {
661
682
                output_set_value( "recoil0", !( data & 0x02 ) );
662
683
                output_set_value( "recoil1", !( data & 0x01 ) );
663
684
 
664
 
                verboselog( space->machine(), 1, "lightgun_w: outputs (%08x %08x)\n", data, mem_mask );
 
685
                verboselog( machine(), 1, "lightgun_w: outputs (%08x %08x)\n", data, mem_mask );
665
686
        }
666
687
        if( ACCESSING_BITS_16_31 )
667
688
        {
668
 
                verboselog( space->machine(), 2, "lightgun_w: start reading (%08x %08x)\n", data, mem_mask );
 
689
                verboselog( machine(), 2, "lightgun_w: start reading (%08x %08x)\n", data, mem_mask );
669
690
        }
670
691
}
671
692
 
672
 
static READ32_HANDLER( lightgun_r )
 
693
READ32_MEMBER(namcos11_state::lightgun_r)
673
694
{
674
695
        UINT32 data = 0;
675
696
        switch( offset )
676
697
        {
677
698
        case 0:
678
 
                data = input_port_read( space->machine(), "GUN1X" );
 
699
                data = ioport( "GUN1X" )->read();
679
700
                break;
680
701
        case 1:
681
 
                data = ( input_port_read( space->machine(), "GUN1Y" ) ) | ( ( input_port_read( space->machine(), "GUN1Y" ) + 1 ) << 16 );
 
702
                data = ( ioport( "GUN1Y" )->read() ) | ( ( ioport( "GUN1Y" )->read() + 1 ) << 16 );
682
703
                break;
683
704
        case 2:
684
 
                data = input_port_read( space->machine(), "GUN2X" );
 
705
                data = ioport( "GUN2X" )->read();
685
706
                break;
686
707
        case 3:
687
 
                data = ( input_port_read( space->machine(), "GUN2Y" ) ) | ( ( input_port_read( space->machine(), "GUN2Y" ) + 1 ) << 16 );
 
708
                data = ( ioport( "GUN2Y" )->read() ) | ( ( ioport( "GUN2Y" )->read() + 1 ) << 16 );
688
709
                break;
689
710
        }
690
 
        verboselog( space->machine(), 2, "lightgun_r( %08x, %08x ) %08x\n", offset, mem_mask, data );
 
711
        verboselog( machine(), 2, "lightgun_r( %08x, %08x ) %08x\n", offset, mem_mask, data );
691
712
        return data;
692
713
}
693
714
 
694
 
static ADDRESS_MAP_START( namcos11_map, AS_PROGRAM, 32 )
 
715
static ADDRESS_MAP_START( namcos11_map, AS_PROGRAM, 32, namcos11_state )
695
716
        AM_RANGE(0x00000000, 0x003fffff) AM_RAM AM_SHARE("share1") /* ram */
696
 
        AM_RANGE(0x1fa04000, 0x1fa0ffff) AM_RAM AM_BASE_MEMBER(namcos11_state, m_sharedram) /* shared ram with C76 */
697
 
        AM_RANGE(0x1fa20000, 0x1fa2ffff) AM_WRITE(keycus_w) AM_BASE_SIZE_MEMBER(namcos11_state, m_keycus, m_keycus_size) /* keycus */
698
 
        AM_RANGE(0x1fa30000, 0x1fa30fff) AM_DEVREADWRITE8("at28c16", at28c16_r, at28c16_w, 0x00ff00ff) /* eeprom */
 
717
        AM_RANGE(0x1fa04000, 0x1fa0ffff) AM_RAM AM_SHARE("sharedram") /* shared ram with C76 */
 
718
        AM_RANGE(0x1fa20000, 0x1fa2ffff) AM_WRITE(keycus_w) AM_SHARE("keycus") /* keycus */
 
719
        AM_RANGE(0x1fa30000, 0x1fa30fff) AM_DEVREADWRITE8_LEGACY("at28c16", at28c16_r, at28c16_w, 0x00ff00ff) /* eeprom */
699
720
        AM_RANGE(0x1fb00000, 0x1fb00003) AM_WRITENOP /* ?? */
700
721
        AM_RANGE(0x1fbf6000, 0x1fbf6003) AM_WRITENOP /* ?? */
701
722
        AM_RANGE(0x1fc00000, 0x1fffffff) AM_ROM AM_SHARE("share2") AM_REGION("user1", 0) /* bios */
706
727
        AM_RANGE(0xfffe0130, 0xfffe0133) AM_WRITENOP
707
728
ADDRESS_MAP_END
708
729
 
709
 
static READ16_HANDLER( c76_shared_r )
 
730
READ16_MEMBER(namcos11_state::c76_shared_r)
710
731
{
711
 
        namcos11_state *state = space->machine().driver_data<namcos11_state>();
712
 
        UINT16 *share16 = (UINT16 *)state->m_sharedram;
 
732
        // ERROR: This cast is NOT endian-safe without the use of BYTE/WORD/DWORD_XOR_* macros!
 
733
        UINT16 *share16 = reinterpret_cast<UINT16 *>(m_sharedram.target());
713
734
 
714
735
        return share16[offset];
715
736
}
716
737
 
717
 
static WRITE16_HANDLER( c76_shared_w )
 
738
WRITE16_MEMBER(namcos11_state::c76_shared_w)
718
739
{
719
 
        namcos11_state *state = space->machine().driver_data<namcos11_state>();
720
 
        UINT16 *share16 = (UINT16 *)state->m_sharedram;
 
740
        // ERROR: This cast is NOT endian-safe without the use of BYTE/WORD/DWORD_XOR_* macros!
 
741
        UINT16 *share16 = reinterpret_cast<UINT16 *>(m_sharedram.target());
721
742
 
722
743
        COMBINE_DATA(&share16[offset]);
723
744
}
724
745
 
725
 
static READ16_HANDLER( c76_inputs_r )
 
746
READ16_MEMBER(namcos11_state::c76_inputs_r)
726
747
{
727
 
//  logerror("'c76' Read port %d @ %06X\n", offset, cpu_get_pc(&space->device()));
 
748
//  logerror("'c76' Read port %d @ %06X\n", offset, cpu_get_pc(&space.device()));
728
749
 
729
750
        switch (offset)
730
751
        {
731
752
                case 0:
732
 
                        return input_port_read(space->machine(), "PLAYER4");
 
753
                        return ioport("PLAYER4")->read();
733
754
 
734
755
                case 1:
735
 
                        return input_port_read(space->machine(), "SWITCH");
 
756
                        return ioport("SWITCH")->read();
736
757
 
737
758
                case 2:
738
 
                        return input_port_read(space->machine(), "PLAYER1");
 
759
                        return ioport("PLAYER1")->read();
739
760
 
740
761
                case 3:
741
 
                        return input_port_read(space->machine(), "PLAYER2");
 
762
                        return ioport("PLAYER2")->read();
742
763
        }
743
764
 
744
765
        return 0xff;
745
766
}
746
767
 
747
 
ADDRESS_MAP_START( c76_map, AS_PROGRAM, 16 )
748
 
        AM_RANGE(0x002000, 0x002fff) AM_DEVREADWRITE_MODERN("c352", c352_device, read, write)
749
 
        AM_RANGE(0x001000, 0x001007) AM_READ( c76_inputs_r )
750
 
        AM_RANGE(0x004000, 0x00bfff) AM_READWRITE( c76_shared_r, c76_shared_w )
 
768
ADDRESS_MAP_START( c76_map, AS_PROGRAM, 16, namcos11_state )
 
769
        AM_RANGE(0x002000, 0x002fff) AM_DEVREADWRITE("c352", c352_device, read, write)
 
770
        AM_RANGE(0x001000, 0x001007) AM_READ(c76_inputs_r )
 
771
        AM_RANGE(0x004000, 0x00bfff) AM_READWRITE(c76_shared_r, c76_shared_w )
751
772
        AM_RANGE(0x00c000, 0x00ffff) AM_ROM AM_REGION("c76", 0x40000)
752
773
        AM_RANGE(0x080000, 0x0fffff) AM_ROM AM_REGION("c76", 0)
753
774
        AM_RANGE(0x200000, 0x27ffff) AM_ROM AM_REGION("c76", 0)
756
777
        AM_RANGE(0x301000, 0x301001) AM_WRITENOP
757
778
ADDRESS_MAP_END
758
779
 
759
 
static READ8_HANDLER(dac7_r)            // bit 7
760
 
{
761
 
        return input_port_read_safe(space->machine(), "PLAYER3", 0xff)&0x80;
762
 
}
763
 
 
764
 
static READ8_HANDLER(dac6_r)            // bit 3
765
 
{
766
 
        return (input_port_read_safe(space->machine(), "PLAYER3", 0xff)<<4)&0x80;
767
 
}
768
 
 
769
 
static READ8_HANDLER(dac5_r)            // bit 2
770
 
{
771
 
        return (input_port_read_safe(space->machine(), "PLAYER3", 0xff)<<5)&0x80;
772
 
}
773
 
 
774
 
static READ8_HANDLER(dac4_r)            // bit 1
775
 
{
776
 
        return (input_port_read_safe(space->machine(), "PLAYER3", 0xff)<<6)&0x80;
777
 
}
778
 
 
779
 
static READ8_HANDLER(dac3_r)            // bit 0
780
 
{
781
 
        return (input_port_read_safe(space->machine(), "PLAYER3", 0xff)<<7)&0x80;
782
 
}
783
 
 
784
 
static READ8_HANDLER(dac2_r)            // bit 4
785
 
{
786
 
        return (input_port_read_safe(space->machine(), "PLAYER3", 0xff)<<3)&0x80;
787
 
}
788
 
 
789
 
static READ8_HANDLER(dac1_r)            // bit 5
790
 
{
791
 
        return (input_port_read_safe(space->machine(), "PLAYER3", 0xff)<<2)&0x80;
792
 
}
793
 
 
794
 
static READ8_HANDLER(dac0_r)            // bit 6
795
 
{
796
 
        return (input_port_read_safe(space->machine(), "PLAYER3", 0xff)<<1)&0x80;
797
 
}
798
 
 
799
 
static READ8_HANDLER(pocketrc_gas_r)
800
 
{
801
 
        return input_port_read(space->machine(), "GAS");
802
 
}
803
 
 
804
 
static READ8_HANDLER(pocketrc_steer_r)
805
 
{
806
 
        return input_port_read(space->machine(), "STEERING");
807
 
}
808
 
 
809
 
ADDRESS_MAP_START( c76_io_map, AS_IO, 8 )
 
780
READ8_MEMBER(namcos11_state::dac7_r)// bit 7
 
781
{
 
782
        return ioport("PLAYER3")->read_safe(0xff)&0x80;
 
783
}
 
784
 
 
785
READ8_MEMBER(namcos11_state::dac6_r)// bit 3
 
786
{
 
787
        return (ioport("PLAYER3")->read_safe(0xff)<<4)&0x80;
 
788
}
 
789
 
 
790
READ8_MEMBER(namcos11_state::dac5_r)// bit 2
 
791
{
 
792
        return (ioport("PLAYER3")->read_safe(0xff)<<5)&0x80;
 
793
}
 
794
 
 
795
READ8_MEMBER(namcos11_state::dac4_r)// bit 1
 
796
{
 
797
        return (ioport("PLAYER3")->read_safe(0xff)<<6)&0x80;
 
798
}
 
799
 
 
800
READ8_MEMBER(namcos11_state::dac3_r)// bit 0
 
801
{
 
802
        return (ioport("PLAYER3")->read_safe(0xff)<<7)&0x80;
 
803
}
 
804
 
 
805
READ8_MEMBER(namcos11_state::dac2_r)// bit 4
 
806
{
 
807
        return (ioport("PLAYER3")->read_safe(0xff)<<3)&0x80;
 
808
}
 
809
 
 
810
READ8_MEMBER(namcos11_state::dac1_r)// bit 5
 
811
{
 
812
        return (ioport("PLAYER3")->read_safe(0xff)<<2)&0x80;
 
813
}
 
814
 
 
815
READ8_MEMBER(namcos11_state::dac0_r)// bit 6
 
816
{
 
817
        return (ioport("PLAYER3")->read_safe(0xff)<<1)&0x80;
 
818
}
 
819
 
 
820
READ8_MEMBER(namcos11_state::pocketrc_gas_r)
 
821
{
 
822
        return ioport("GAS")->read();
 
823
}
 
824
 
 
825
READ8_MEMBER(namcos11_state::pocketrc_steer_r)
 
826
{
 
827
        return ioport("STEERING")->read();
 
828
}
 
829
 
 
830
ADDRESS_MAP_START( c76_io_map, AS_IO, 8, namcos11_state )
810
831
        AM_RANGE(M37710_ADC7_L, M37710_ADC7_L) AM_READ(dac7_r)
811
832
        AM_RANGE(M37710_ADC6_L, M37710_ADC6_L) AM_READ(dac6_r)
812
833
        AM_RANGE(M37710_ADC5_L, M37710_ADC5_L) AM_READ(dac5_r)
819
840
        AM_RANGE(M37710_ADC0_H, M37710_ADC7_H) AM_READNOP
820
841
ADDRESS_MAP_END
821
842
 
822
 
static READ16_HANDLER( c76_speedup_r )
 
843
READ16_MEMBER(namcos11_state::c76_speedup_r)
823
844
{
824
 
        namcos11_state *state = space->machine().driver_data<namcos11_state>();
825
845
 
826
 
        if ((cpu_get_pc(&space->device()) == 0xc153) && (!(state->m_su_83 & 0xff00)))
 
846
        if ((cpu_get_pc(&space.device()) == 0xc153) && (!(m_su_83 & 0xff00)))
827
847
        {
828
 
                device_spin_until_interrupt(&space->device());
 
848
                device_spin_until_interrupt(&space.device());
829
849
        }
830
850
 
831
 
        return state->m_su_83;
 
851
        return m_su_83;
832
852
}
833
853
 
834
 
static WRITE16_HANDLER( c76_speedup_w )
 
854
WRITE16_MEMBER(namcos11_state::c76_speedup_w)
835
855
{
836
 
        namcos11_state *state = space->machine().driver_data<namcos11_state>();
837
856
 
838
 
        COMBINE_DATA(&state->m_su_83);
 
857
        COMBINE_DATA(&m_su_83);
839
858
}
840
859
 
841
860
static void namcos11_init_common(running_machine &machine, int n_daughterboard)
847
866
        if (C76_SPEEDUP)
848
867
        {
849
868
                state->save_item( NAME(state->m_su_83) );
850
 
                machine.device("c76")->memory().space(AS_PROGRAM)->install_legacy_readwrite_handler(0x82, 0x83, FUNC(c76_speedup_r), FUNC(c76_speedup_w));
 
869
                machine.device("c76")->memory().space(AS_PROGRAM)->install_readwrite_handler(0x82, 0x83, read16_delegate(FUNC(namcos11_state::c76_speedup_r),state), write16_delegate(FUNC(namcos11_state::c76_speedup_w),state));
851
870
        }
852
871
 
853
872
        if (!n_daughterboard)
858
877
 
859
878
        // init banks
860
879
        int bank;
861
 
        UINT32 len = machine.region( "user2" )->bytes();
862
 
        UINT8 *rgn = machine.region( "user2" )->base();
 
880
        UINT32 len = machine.root_device().memregion( "user2" )->bytes();
 
881
        UINT8 *rgn = machine.root_device().memregion( "user2" )->base();
863
882
 
864
883
        machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_bank(0x1f000000, 0x1f0fffff, "bank1" );
865
884
        machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_bank(0x1f100000, 0x1f1fffff, "bank2" );
872
891
 
873
892
        for (bank = 0; bank < 8; bank++)
874
893
        {
875
 
                memory_configure_bank(machine, bankname[bank], 0, len / ( 1024 * 1024 ), rgn, 1024 * 1024 );
876
 
                memory_set_bank(machine, bankname[bank], 0 );
 
894
                state->membank(bankname[bank])->configure_entries(0, len / ( 1024 * 1024 ), rgn, 1024 * 1024 );
 
895
                state->membank(bankname[bank])->set_entry(0 );
877
896
        }
878
897
 
879
898
        if (n_daughterboard == 32)
880
899
        {
881
 
                machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x1fa10020, 0x1fa1002f, FUNC(bankswitch_rom32_w) );
 
900
                machine.device("maincpu")->memory().space(AS_PROGRAM)->install_write_handler(0x1fa10020, 0x1fa1002f, write32_delegate(FUNC(namcos11_state::bankswitch_rom32_w),state));
882
901
        }
883
902
        if (n_daughterboard == 64)
884
903
        {
885
904
                state->m_n_bankoffset = 0;
886
 
                machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x1f080000, 0x1f080003, FUNC(bankswitch_rom64_upper_w) );
 
905
                machine.device("maincpu")->memory().space(AS_PROGRAM)->install_write_handler(0x1f080000, 0x1f080003, write32_delegate(FUNC(namcos11_state::bankswitch_rom64_upper_w),state));
887
906
                machine.device("maincpu")->memory().space(AS_PROGRAM)->nop_read(0x1fa10020, 0x1fa1002f);
888
 
                machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x1fa10020, 0x1fa1002f, FUNC(bankswitch_rom64_w) );
 
907
                machine.device("maincpu")->memory().space(AS_PROGRAM)->install_write_handler(0x1fa10020, 0x1fa1002f, write32_delegate(FUNC(namcos11_state::bankswitch_rom64_w),state));
889
908
                state->save_item( NAME(state->m_n_bankoffset) );
890
909
        }
891
910
}
897
916
 
898
917
static DRIVER_INIT( tekken2 )
899
918
{
900
 
        machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler( 0x1fa20000, 0x1fa2ffff, FUNC(keycus_c406_r) );
 
919
        namcos11_state *state = machine.driver_data<namcos11_state>();
 
920
        machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler( 0x1fa20000, 0x1fa2ffff, read32_delegate(FUNC(namcos11_state::keycus_c406_r),state));
901
921
        namcos11_init_common(machine, 32);
902
922
}
903
923
 
904
924
static DRIVER_INIT( souledge )
905
925
{
906
 
        machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler( 0x1fa20000, 0x1fa2ffff, FUNC(keycus_c409_r) );
 
926
        namcos11_state *state = machine.driver_data<namcos11_state>();
 
927
        machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler( 0x1fa20000, 0x1fa2ffff, read32_delegate(FUNC(namcos11_state::keycus_c409_r),state));
907
928
        namcos11_init_common(machine, 32);
908
929
}
909
930
 
910
931
static DRIVER_INIT( dunkmnia )
911
932
{
912
 
        machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler( 0x1fa20000, 0x1fa2ffff, FUNC(keycus_c410_r) );
 
933
        namcos11_state *state = machine.driver_data<namcos11_state>();
 
934
        machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler( 0x1fa20000, 0x1fa2ffff, read32_delegate(FUNC(namcos11_state::keycus_c410_r),state));
913
935
        namcos11_init_common(machine, 32);
914
936
}
915
937
 
916
938
static DRIVER_INIT( primglex )
917
939
{
918
 
        machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler( 0x1fa20000, 0x1fa2ffff, FUNC(keycus_c411_r) );
 
940
        namcos11_state *state = machine.driver_data<namcos11_state>();
 
941
        machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler( 0x1fa20000, 0x1fa2ffff, read32_delegate(FUNC(namcos11_state::keycus_c411_r),state));
919
942
        namcos11_init_common(machine, 32);
920
943
}
921
944
 
922
945
static DRIVER_INIT( xevi3dg )
923
946
{
924
 
        machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler( 0x1fa20000, 0x1fa2ffff, FUNC(keycus_c430_r) );
 
947
        namcos11_state *state = machine.driver_data<namcos11_state>();
 
948
        machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler( 0x1fa20000, 0x1fa2ffff, read32_delegate(FUNC(namcos11_state::keycus_c430_r),state));
925
949
        namcos11_init_common(machine, 32);
926
950
}
927
951
 
928
952
static DRIVER_INIT( danceyes )
929
953
{
930
 
        machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler( 0x1fa20000, 0x1fa2ffff, FUNC(keycus_c431_r) );
 
954
        namcos11_state *state = machine.driver_data<namcos11_state>();
 
955
        machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler( 0x1fa20000, 0x1fa2ffff, read32_delegate(FUNC(namcos11_state::keycus_c431_r),state));
931
956
        namcos11_init_common(machine, 32);
932
957
}
933
958
 
934
959
static DRIVER_INIT( pocketrc )
935
960
{
936
 
        machine.device("c76")->memory().space(AS_IO)->install_legacy_read_handler(M37710_ADC0_L, M37710_ADC0_L, FUNC(pocketrc_steer_r));
937
 
        machine.device("c76")->memory().space(AS_IO)->install_legacy_read_handler(M37710_ADC1_L, M37710_ADC1_L, FUNC(pocketrc_gas_r));
 
961
        namcos11_state *state = machine.driver_data<namcos11_state>();
 
962
        machine.device("c76")->memory().space(AS_IO)->install_read_handler(M37710_ADC0_L, M37710_ADC0_L, read8_delegate(FUNC(namcos11_state::pocketrc_steer_r),state));
 
963
        machine.device("c76")->memory().space(AS_IO)->install_read_handler(M37710_ADC1_L, M37710_ADC1_L, read8_delegate(FUNC(namcos11_state::pocketrc_gas_r),state));
938
964
 
939
 
        machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler( 0x1fa20000, 0x1fa2ffff, FUNC(keycus_c432_r) );
 
965
        machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler( 0x1fa20000, 0x1fa2ffff, read32_delegate(FUNC(namcos11_state::keycus_c432_r),state));
940
966
        namcos11_init_common(machine, 32);
941
967
}
942
968
 
943
969
static DRIVER_INIT( starswep )
944
970
{
945
 
        machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler( 0x1fa20000, 0x1fa2ffff, FUNC(keycus_c442_r) );
 
971
        namcos11_state *state = machine.driver_data<namcos11_state>();
 
972
        machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler( 0x1fa20000, 0x1fa2ffff, read32_delegate(FUNC(namcos11_state::keycus_c442_r),state));
946
973
        namcos11_init_common(machine, 0);
947
974
}
948
975
 
949
976
static DRIVER_INIT( myangel3 )
950
977
{
951
 
        machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler( 0x1fa20000, 0x1fa2ffff, FUNC(keycus_c443_r) );
 
978
        namcos11_state *state = machine.driver_data<namcos11_state>();
 
979
        machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler( 0x1fa20000, 0x1fa2ffff, read32_delegate(FUNC(namcos11_state::keycus_c443_r),state));
952
980
        namcos11_init_common(machine, 64);
953
981
}
954
982
 
955
983
static DRIVER_INIT( ptblank2ua )
956
984
{
957
 
        machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler( 0x1fa20000, 0x1fa2ffff, FUNC(keycus_c443_r) );
 
985
        namcos11_state *state = machine.driver_data<namcos11_state>();
 
986
        machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler( 0x1fa20000, 0x1fa2ffff, read32_delegate(FUNC(namcos11_state::keycus_c443_r),state));
958
987
        namcos11_init_common(machine, 64);
959
988
 
960
 
        machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_write_handler(0x1f788000, 0x1f788003, FUNC(lightgun_w) );
961
 
        machine.device("maincpu")->memory().space(AS_PROGRAM)->install_legacy_read_handler (0x1f780000, 0x1f78000f, FUNC(lightgun_r) );
 
989
        machine.device("maincpu")->memory().space(AS_PROGRAM)->install_write_handler(0x1f788000, 0x1f788003, write32_delegate(FUNC(namcos11_state::lightgun_w),state));
 
990
        machine.device("maincpu")->memory().space(AS_PROGRAM)->install_read_handler (0x1f780000, 0x1f78000f, read32_delegate(FUNC(namcos11_state::lightgun_r),state));
962
991
}
963
992
 
964
993
static MACHINE_RESET( namcos11 )