← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/emu/machine/generic.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/emu/machine/generic.c
21
21
 
22
22
static void counters_load(running_machine &machine, int config_type, xml_data_node *parentnode);
23
23
static void counters_save(running_machine &machine, int config_type, xml_data_node *parentnode);
24
 
static void interrupt_reset(running_machine &machine);
25
24
 
26
25
 
27
26
 
39
38
 
40
39
        /* memory card status */
41
40
        int             memcard_inserted;
42
 
 
43
 
        /* interrupt status for up to 8 CPUs */
44
 
        device_t *      interrupt_device[8];
45
 
        UINT8           interrupt_enable[8];
46
41
};
47
42
 
48
43
 
49
44
 
50
45
/***************************************************************************
51
 
    INLINE FUNCTIONS
52
 
***************************************************************************/
53
 
 
54
 
/*-------------------------------------------------
55
 
    interrupt_enabled - return true if interrupts
56
 
    are enabled for the given CPU
57
 
-------------------------------------------------*/
58
 
 
59
 
INLINE int interrupt_enabled(device_t *device)
60
 
{
61
 
        generic_machine_private *state = device->machine().generic_machine_data;
62
 
        for (int index = 0; index < ARRAY_LENGTH(state->interrupt_device); index++)
63
 
                if (state->interrupt_device[index] == device)
64
 
                        return state->interrupt_enable[index];
65
 
        return TRUE;
66
 
}
67
 
 
68
 
 
69
 
 
70
 
/***************************************************************************
71
46
    INITIALIZATION
72
47
***************************************************************************/
73
48
 
92
67
                state->coinlockedout[counternum] = 0;
93
68
        }
94
69
 
95
 
        // map devices to the interrupt state
96
 
        memset(state->interrupt_device, 0, sizeof(state->interrupt_device));
97
 
        execute_interface_iterator iter(machine.root_device());
98
 
        int index = 0;
99
 
        for (device_execute_interface *exec = iter.first(); exec != NULL && index < ARRAY_LENGTH(state->interrupt_device); exec = iter.next())
100
 
                state->interrupt_device[index++] = &exec->device();
101
 
 
102
70
        /* register coin save state */
103
71
        machine.save().save_item(NAME(state->coin_count));
104
72
        machine.save().save_item(NAME(state->coinlockedout));
107
75
        /* reset memory card info */
108
76
        state->memcard_inserted = -1;
109
77
 
110
 
        /* register a reset callback and save state for interrupt enable */
111
 
        machine.add_notifier(MACHINE_NOTIFY_RESET, machine_notify_delegate(FUNC(interrupt_reset), &machine));
112
 
        machine.save().save_item(NAME(state->interrupt_enable));
113
 
 
114
78
        /* register for configuration */
115
79
        config_register(machine, "counters", config_saveload_delegate(FUNC(counters_load), &machine), config_saveload_delegate(FUNC(counters_save), &machine));
116
80
 
322
286
 
323
287
        // start with either basename or basename_biosnum
324
288
        result.cpy(machine.basename());
325
 
        if (rom_system_bios(machine) != 0 && rom_default_bios(machine) != rom_system_bios(machine))
326
 
                result.catprintf("_%d", rom_system_bios(machine) - 1);
 
289
        if (device.machine().root_device().system_bios() != 0 && device.machine().root_device().default_bios() != device.machine().root_device().system_bios())
 
290
                result.catprintf("_%d", device.machine().root_device().system_bios() - 1);
327
291
 
328
292
        // device-based NVRAM gets its own name in a subdirectory
329
293
        if (&device != &device.machine().root_device())
549
513
 
550
514
 
551
515
 
552
 
/***************************************************************************
553
 
    INTERRUPT ENABLE AND VECTOR HELPERS
554
 
***************************************************************************/
555
 
 
556
 
/*-------------------------------------------------
557
 
    interrupt_reset - reset the interrupt enable
558
 
    states on a reset
559
 
-------------------------------------------------*/
560
 
 
561
 
static void interrupt_reset(running_machine &machine)
562
 
{
563
 
        generic_machine_private *state = machine.generic_machine_data;
564
 
        int cpunum;
565
 
 
566
 
        /* on a reset, enable all interrupts */
567
 
        for (cpunum = 0; cpunum < ARRAY_LENGTH(state->interrupt_enable); cpunum++)
568
 
                state->interrupt_enable[cpunum] = 1;
569
 
}
570
 
 
571
 
 
572
 
/*-------------------------------------------------
573
 
    irq_pulse_clear - clear a "pulsed" IRQ line
574
 
-------------------------------------------------*/
575
 
 
576
 
static TIMER_CALLBACK( irq_pulse_clear )
577
 
{
578
 
        device_t *device = (device_t *)ptr;
579
 
        int irqline = param;
580
 
        device_set_input_line(device, irqline, CLEAR_LINE);
581
 
}
582
 
 
583
 
 
584
 
/*-------------------------------------------------
585
 
    generic_pulse_irq_line - "pulse" an IRQ line by
586
 
    asserting it and then clearing it 1 cycle
587
 
    later
588
 
-------------------------------------------------*/
589
 
 
590
 
void generic_pulse_irq_line(device_t *device, int irqline)
591
 
{
592
 
        assert(irqline != INPUT_LINE_NMI && irqline != INPUT_LINE_RESET);
593
 
        device_set_input_line(device, irqline, ASSERT_LINE);
594
 
 
595
 
        cpu_device *cpudevice = downcast<cpu_device *>(device);
596
 
        attotime target_time = cpudevice->local_time() + cpudevice->cycles_to_attotime(cpudevice->min_cycles());
597
 
        device->machine().scheduler().timer_set(target_time - device->machine().time(), FUNC(irq_pulse_clear), irqline, (void *)device);
598
 
}
599
 
 
600
 
 
601
 
/*-------------------------------------------------
602
 
    generic_pulse_irq_line_and_vector - "pulse" an
603
 
    IRQ line by asserting it and then clearing it
604
 
    1 cycle later, specifying a vector
605
 
-------------------------------------------------*/
606
 
 
607
 
void generic_pulse_irq_line_and_vector(device_t *device, int irqline, int vector)
608
 
{
609
 
        assert(irqline != INPUT_LINE_NMI && irqline != INPUT_LINE_RESET);
610
 
        device_set_input_line_and_vector(device, irqline, ASSERT_LINE, vector);
611
 
 
612
 
        cpu_device *cpudevice = downcast<cpu_device *>(device);
613
 
        attotime target_time = cpudevice->local_time() + cpudevice->cycles_to_attotime(cpudevice->min_cycles());
614
 
        device->machine().scheduler().timer_set(target_time - device->machine().time(), FUNC(irq_pulse_clear), irqline, (void *)device);
615
 
}
616
 
 
617
 
 
618
 
 
619
 
/***************************************************************************
620
 
    INTERRUPT GENERATION CALLBACK HELPERS
621
 
***************************************************************************/
622
 
 
623
 
/*-------------------------------------------------
624
 
    NMI callbacks
625
 
-------------------------------------------------*/
626
 
 
627
 
INTERRUPT_GEN( nmi_line_pulse )         { if (interrupt_enabled(device)) device_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE); }
628
 
INTERRUPT_GEN( nmi_line_assert )        { if (interrupt_enabled(device)) device_set_input_line(device, INPUT_LINE_NMI, ASSERT_LINE); }
629
 
 
630
 
 
631
 
/*-------------------------------------------------
632
 
    IRQn callbacks
633
 
-------------------------------------------------*/
634
 
 
635
 
INTERRUPT_GEN( irq0_line_hold )         { if (interrupt_enabled(device)) device_set_input_line(device, 0, HOLD_LINE); }
636
 
INTERRUPT_GEN( irq0_line_pulse )        { if (interrupt_enabled(device)) generic_pulse_irq_line(device, 0); }
637
 
INTERRUPT_GEN( irq0_line_assert )       { if (interrupt_enabled(device)) device_set_input_line(device, 0, ASSERT_LINE); }
638
 
 
639
 
INTERRUPT_GEN( irq1_line_hold )         { if (interrupt_enabled(device)) device_set_input_line(device, 1, HOLD_LINE); }
640
 
INTERRUPT_GEN( irq1_line_pulse )        { if (interrupt_enabled(device)) generic_pulse_irq_line(device, 1); }
641
 
INTERRUPT_GEN( irq1_line_assert )       { if (interrupt_enabled(device)) device_set_input_line(device, 1, ASSERT_LINE); }
642
 
 
643
 
INTERRUPT_GEN( irq2_line_hold )         { if (interrupt_enabled(device)) device_set_input_line(device, 2, HOLD_LINE); }
644
 
INTERRUPT_GEN( irq2_line_pulse )        { if (interrupt_enabled(device)) generic_pulse_irq_line(device, 2); }
645
 
INTERRUPT_GEN( irq2_line_assert )       { if (interrupt_enabled(device)) device_set_input_line(device, 2, ASSERT_LINE); }
646
 
 
647
 
INTERRUPT_GEN( irq3_line_hold )         { if (interrupt_enabled(device)) device_set_input_line(device, 3, HOLD_LINE); }
648
 
INTERRUPT_GEN( irq3_line_pulse )        { if (interrupt_enabled(device)) generic_pulse_irq_line(device, 3); }
649
 
INTERRUPT_GEN( irq3_line_assert )       { if (interrupt_enabled(device)) device_set_input_line(device, 3, ASSERT_LINE); }
650
 
 
651
 
INTERRUPT_GEN( irq4_line_hold )         { if (interrupt_enabled(device)) device_set_input_line(device, 4, HOLD_LINE); }
652
 
INTERRUPT_GEN( irq4_line_pulse )        { if (interrupt_enabled(device)) generic_pulse_irq_line(device, 4); }
653
 
INTERRUPT_GEN( irq4_line_assert )       { if (interrupt_enabled(device)) device_set_input_line(device, 4, ASSERT_LINE); }
654
 
 
655
 
INTERRUPT_GEN( irq5_line_hold )         { if (interrupt_enabled(device)) device_set_input_line(device, 5, HOLD_LINE); }
656
 
INTERRUPT_GEN( irq5_line_pulse )        { if (interrupt_enabled(device)) generic_pulse_irq_line(device, 5); }
657
 
INTERRUPT_GEN( irq5_line_assert )       { if (interrupt_enabled(device)) device_set_input_line(device, 5, ASSERT_LINE); }
658
 
 
659
 
INTERRUPT_GEN( irq6_line_hold )         { if (interrupt_enabled(device)) device_set_input_line(device, 6, HOLD_LINE); }
660
 
INTERRUPT_GEN( irq6_line_pulse )        { if (interrupt_enabled(device)) generic_pulse_irq_line(device, 6); }
661
 
INTERRUPT_GEN( irq6_line_assert )       { if (interrupt_enabled(device)) device_set_input_line(device, 6, ASSERT_LINE); }
662
 
 
663
 
INTERRUPT_GEN( irq7_line_hold )         { if (interrupt_enabled(device)) device_set_input_line(device, 7, HOLD_LINE); }
664
 
INTERRUPT_GEN( irq7_line_pulse )        { if (interrupt_enabled(device)) generic_pulse_irq_line(device, 7); }
665
 
INTERRUPT_GEN( irq7_line_assert )       { if (interrupt_enabled(device)) device_set_input_line(device, 7, ASSERT_LINE); }
666
 
 
667
 
 
668
 
 
669
 
/***************************************************************************
670
 
    WATCHDOG READ/WRITE HELPERS
671
 
***************************************************************************/
672
 
 
673
 
/*-------------------------------------------------
674
 
    8-bit reset read/write handlers
675
 
-------------------------------------------------*/
676
 
 
677
 
WRITE8_HANDLER( watchdog_reset_w ) { watchdog_reset(space->machine()); }
678
 
READ8_HANDLER( watchdog_reset_r ) { watchdog_reset(space->machine()); return space->unmap(); }
679
 
 
680
 
WRITE8_MEMBER( driver_device::watchdog_reset_w ) { watchdog_reset(machine()); }
681
 
READ8_MEMBER( driver_device::watchdog_reset_r ) { watchdog_reset(machine()); return space.unmap(); }
682
 
 
683
 
 
684
 
/*-------------------------------------------------
685
 
    16-bit reset read/write handlers
686
 
-------------------------------------------------*/
687
 
 
688
 
WRITE16_HANDLER( watchdog_reset16_w ) { watchdog_reset(space->machine()); }
689
 
READ16_HANDLER( watchdog_reset16_r ) { watchdog_reset(space->machine()); return space->unmap(); }
690
 
 
691
 
WRITE16_MEMBER( driver_device::watchdog_reset16_w ) { watchdog_reset(machine()); }
692
 
READ16_MEMBER( driver_device::watchdog_reset16_r ) { watchdog_reset(machine()); return space.unmap(); }
693
 
 
694
 
 
695
 
/*-------------------------------------------------
696
 
    32-bit reset read/write handlers
697
 
-------------------------------------------------*/
698
 
 
699
 
WRITE32_HANDLER( watchdog_reset32_w ) { watchdog_reset(space->machine()); }
700
 
READ32_HANDLER( watchdog_reset32_r ) { watchdog_reset(space->machine()); return space->unmap(); }
701
 
 
702
 
WRITE32_MEMBER( driver_device::watchdog_reset32_w ) { watchdog_reset(machine()); }
703
 
READ32_MEMBER( driver_device::watchdog_reset32_r ) { watchdog_reset(machine()); return space.unmap(); }
704
 
 
705
 
 
706
516
 
707
517
/***************************************************************************
708
518
    PORT READING HELPERS
715
525
    repeated both in the upper and lower half
716
526
-------------------------------------------------*/
717
527
 
718
 
CUSTOM_INPUT( custom_port_read )
 
528
CUSTOM_INPUT_MEMBER( driver_device::custom_port_read )
719
529
{
720
530
        const char *tag = (const char *)param;
721
 
        return input_port_read(field.machine(), tag);
 
531
        return ioport(tag)->read();
722
532
}
 
533
 
 
534
 
 
535
void generic_pulse_irq_line(device_t *device, int irqline, int cycles) { device->machine().driver_data()->generic_pulse_irq_line(device->execute(), irqline, cycles); }
 
536
void generic_pulse_irq_line_and_vector(device_t *device, int irqline, int vector, int cycles) { device->machine().driver_data()->generic_pulse_irq_line_and_vector(device->execute(), irqline, vector, cycles); }
 
537
 
 
538
INTERRUPT_GEN( nmi_line_pulse ) { device->machine().driver_data()->nmi_line_pulse(*device); }
 
539
INTERRUPT_GEN( nmi_line_assert ) { device->machine().driver_data()->nmi_line_assert(*device); }
 
540
 
 
541
INTERRUPT_GEN( irq0_line_hold ) { device->machine().driver_data()->irq0_line_hold(*device); }
 
542
INTERRUPT_GEN( irq0_line_pulse ) { device->machine().driver_data()->irq0_line_pulse(*device); }
 
543
INTERRUPT_GEN( irq0_line_assert ) { device->machine().driver_data()->irq0_line_assert(*device); }
 
544
 
 
545
INTERRUPT_GEN( irq1_line_hold ) { device->machine().driver_data()->irq1_line_hold(*device); }
 
546
INTERRUPT_GEN( irq1_line_pulse ) { device->machine().driver_data()->irq1_line_pulse(*device); }
 
547
INTERRUPT_GEN( irq1_line_assert ) { device->machine().driver_data()->irq1_line_assert(*device); }
 
548
 
 
549
INTERRUPT_GEN( irq2_line_hold ) { device->machine().driver_data()->irq2_line_hold(*device); }
 
550
INTERRUPT_GEN( irq2_line_pulse ) { device->machine().driver_data()->irq2_line_pulse(*device); }
 
551
INTERRUPT_GEN( irq2_line_assert ) { device->machine().driver_data()->irq2_line_assert(*device); }
 
552
 
 
553
INTERRUPT_GEN( irq3_line_hold ) { device->machine().driver_data()->irq3_line_hold(*device); }
 
554
INTERRUPT_GEN( irq3_line_pulse ) { device->machine().driver_data()->irq3_line_pulse(*device); }
 
555
INTERRUPT_GEN( irq3_line_assert ) { device->machine().driver_data()->irq3_line_assert(*device); }
 
556
 
 
557
INTERRUPT_GEN( irq4_line_hold ) { device->machine().driver_data()->irq4_line_hold(*device); }
 
558
INTERRUPT_GEN( irq4_line_pulse ) { device->machine().driver_data()->irq4_line_pulse(*device); }
 
559
INTERRUPT_GEN( irq4_line_assert ) { device->machine().driver_data()->irq4_line_assert(*device); }
 
560
 
 
561
INTERRUPT_GEN( irq5_line_hold ) { device->machine().driver_data()->irq5_line_hold(*device); }
 
562
INTERRUPT_GEN( irq5_line_pulse ) { device->machine().driver_data()->irq5_line_pulse(*device); }
 
563
INTERRUPT_GEN( irq5_line_assert ) { device->machine().driver_data()->irq5_line_assert(*device); }
 
564
 
 
565
INTERRUPT_GEN( irq6_line_hold ) { device->machine().driver_data()->irq6_line_hold(*device); }
 
566
INTERRUPT_GEN( irq6_line_pulse ) { device->machine().driver_data()->irq6_line_pulse(*device); }
 
567
INTERRUPT_GEN( irq6_line_assert ) { device->machine().driver_data()->irq6_line_assert(*device); }
 
568
 
 
569
INTERRUPT_GEN( irq7_line_hold ) { device->machine().driver_data()->irq7_line_hold(*device); }
 
570
INTERRUPT_GEN( irq7_line_pulse ) { device->machine().driver_data()->irq7_line_pulse(*device); }
 
571
INTERRUPT_GEN( irq7_line_assert ) { device->machine().driver_data()->irq7_line_assert(*device); }