src/mess/machine/z80dart.c
| r3740 | r3741 | |
| 30 | 30 | |
| 31 | 31 | #define VERBOSE 0 |
| 32 | 32 | |
| 33 | | #define LOGERROR if (VERBOSE) logerror |
| 33 | #define LOG(x) do { if (VERBOSE) logerror x; } while (0) |
| 34 | 34 | |
| 35 | 35 | /*************************************************************************** |
| 36 | 36 | CONSTANTS |
| r3740 | r3741 | |
| 234 | 234 | z80dart->intf->on_rts_changed(device, channel, state); |
| 235 | 235 | } |
| 236 | 236 | |
| 237 | | LOGERROR("Z80DART \"%s\" Channel %c : RTS %u\n", device->tag, 'A' + channel, state); |
| 237 | LOG(("Z80DART \"%s\" Channel %c : RTS %u\n", device->tag, 'A' + channel, state)); |
| 238 | 238 | } |
| 239 | 239 | |
| 240 | 240 | static void z80dart_dtr_w(const device_config *device, int channel, int state) |
| r3740 | r3741 | |
| 246 | 246 | z80dart->intf->on_dtr_changed(device, channel, state); |
| 247 | 247 | } |
| 248 | 248 | |
| 249 | | LOGERROR("Z80DART \"%s\" Channel %c : DTR %u\n", device->tag, 'A' + channel, state); |
| 249 | LOG(("Z80DART \"%s\" Channel %c : DTR %u\n", device->tag, 'A' + channel, state)); |
| 250 | 250 | } |
| 251 | 251 | |
| 252 | 252 | /*************************************************************************** |
| r3740 | r3741 | |
| 271 | 271 | UINT8 vector = ch->wr[2]; |
| 272 | 272 | int priority = (channel << 2) | level; |
| 273 | 273 | |
| 274 | | LOGERROR("Z80DART \"%s\" Channel %c : Interrupt Request %u\n", device->tag, 'A' + channel, level); |
| 274 | LOG(("Z80DART \"%s\" Channel %c : Interrupt Request %u\n", device->tag, 'A' + channel, level)); |
| 275 | 275 | |
| 276 | 276 | if ((channel == Z80DART_CH_B) && (ch->wr[1] & Z80DART_WR1_STATUS_VECTOR)) |
| 277 | 277 | { |
| r3740 | r3741 | |
| 737 | 737 | break; |
| 738 | 738 | } |
| 739 | 739 | |
| 740 | | LOGERROR("Z80DART \"%s\" Channel %c : Control Register Read '%02x'\n", device->tag, 'A' + channel, data); |
| 740 | LOG(("Z80DART \"%s\" Channel %c : Control Register Read '%02x'\n", device->tag, 'A' + channel, data)); |
| 741 | 741 | |
| 742 | 742 | return data; |
| 743 | 743 | } |
| r3740 | r3741 | |
| 750 | 750 | |
| 751 | 751 | int reg = ch->wr[0] & Z80DART_WR0_REGISTER_MASK; |
| 752 | 752 | |
| 753 | | LOGERROR("Z80DART \"%s\" Channel %c : Control Register Write '%02x'\n", device->tag, 'A' + channel, data); |
| 753 | LOG(("Z80DART \"%s\" Channel %c : Control Register Write '%02x'\n", device->tag, 'A' + channel, data)); |
| 754 | 754 | |
| 755 | 755 | /* write data to selected register */ |
| 756 | 756 | ch->wr[reg] = data; |
| r3740 | r3741 | |
| 776 | 776 | |
| 777 | 777 | ch->rx_rr0_latch = 0; |
| 778 | 778 | |
| 779 | | LOGERROR("Z80DART \"%s\" Channel %c : Reset External/Status Interrupt\n", device->tag, 'A' + channel); |
| 779 | LOG(("Z80DART \"%s\" Channel %c : Reset External/Status Interrupt\n", device->tag, 'A' + channel)); |
| 780 | 780 | break; |
| 781 | 781 | |
| 782 | 782 | case Z80DART_WR0_CHANNEL_RESET: |
| 783 | 783 | /* channel reset */ |
| 784 | | LOGERROR("Z80DART \"%s\" Channel %c : Channel Reset\n", device->tag, 'A' + channel); |
| 784 | LOG(("Z80DART \"%s\" Channel %c : Channel Reset\n", device->tag, 'A' + channel)); |
| 785 | 785 | z80dart_reset_channel(device, channel); |
| 786 | 786 | break; |
| 787 | 787 | |
| 788 | 788 | case Z80DART_WR0_ENABLE_INT_NEXT_RX: |
| 789 | 789 | /* enable interrupt on next receive character */ |
| 790 | | LOGERROR("Z80DART \"%s\" Channel %c : Enable Interrupt on Next Received Character\n", device->tag, 'A' + channel); |
| 790 | LOG(("Z80DART \"%s\" Channel %c : Enable Interrupt on Next Received Character\n", device->tag, 'A' + channel)); |
| 791 | 791 | ch->rx_first = 1; |
| 792 | 792 | break; |
| 793 | 793 | |
| 794 | 794 | case Z80DART_WR0_RESET_TX_INT: |
| 795 | 795 | /* reset transmitter interrupt pending */ |
| 796 | | LOGERROR("Z80DART \"%s\" Channel %c : Reset Transmitter Interrupt Pending\n", device->tag, 'A' + channel); |
| 796 | LOG(("Z80DART \"%s\" Channel %c : Reset Transmitter Interrupt Pending\n", device->tag, 'A' + channel)); |
| 797 | 797 | break; |
| 798 | 798 | |
| 799 | 799 | case Z80DART_WR0_ERROR_RESET: |
| 800 | 800 | /* error reset */ |
| 801 | | LOGERROR("Z80DART \"%s\" Channel %c : Error Reset\n", device->tag, 'A' + channel); |
| 801 | LOG(("Z80DART \"%s\" Channel %c : Error Reset\n", device->tag, 'A' + channel)); |
| 802 | 802 | ch->rr[1] &= ~(Z80DART_RR1_FRAMING_ERROR | Z80DART_RR1_RX_OVERRUN_ERROR | Z80DART_RR1_PARITY_ERROR); |
| 803 | 803 | break; |
| 804 | 804 | |
| 805 | 805 | case Z80DART_WR0_RETURN_FROM_INT: |
| 806 | 806 | /* return from interrupt */ |
| 807 | | LOGERROR("Z80DART \"%s\" Channel %c : Return from Interrupt\n", device->tag, 'A' + channel); |
| 807 | LOG(("Z80DART \"%s\" Channel %c : Return from Interrupt\n", device->tag, 'A' + channel)); |
| 808 | 808 | z80dart_irq_reti(device); |
| 809 | 809 | break; |
| 810 | 810 | } |
| 811 | 811 | break; |
| 812 | 812 | |
| 813 | 813 | case 1: |
| 814 | | LOGERROR("Z80DART \"%s\" Channel %c : External Interrupt Enable %u\n", device->tag, 'A' + channel, (data & Z80DART_WR1_EXT_INT_ENABLE) ? 1 : 0); |
| 815 | | LOGERROR("Z80DART \"%s\" Channel %c : Transmit Interrupt Enable %u\n", device->tag, 'A' + channel, (data & Z80DART_WR1_TX_INT_ENABLE) ? 1 : 0); |
| 816 | | LOGERROR("Z80DART \"%s\" Channel %c : Status Affects Vector %u\n", device->tag, 'A' + channel, (data & Z80DART_WR1_STATUS_VECTOR) ? 1 : 0); |
| 817 | | LOGERROR("Z80DART \"%s\" Channel %c : Wait/Ready Enable %u\n", device->tag, 'A' + channel, (data & Z80DART_WR1_WRDY_ENABLE) ? 1 : 0); |
| 814 | LOG(("Z80DART \"%s\" Channel %c : External Interrupt Enable %u\n", device->tag, 'A' + channel, (data & Z80DART_WR1_EXT_INT_ENABLE) ? 1 : 0)); |
| 815 | LOG(("Z80DART \"%s\" Channel %c : Transmit Interrupt Enable %u\n", device->tag, 'A' + channel, (data & Z80DART_WR1_TX_INT_ENABLE) ? 1 : 0)); |
| 816 | LOG(("Z80DART \"%s\" Channel %c : Status Affects Vector %u\n", device->tag, 'A' + channel, (data & Z80DART_WR1_STATUS_VECTOR) ? 1 : 0)); |
| 817 | LOG(("Z80DART \"%s\" Channel %c : Wait/Ready Enable %u\n", device->tag, 'A' + channel, (data & Z80DART_WR1_WRDY_ENABLE) ? 1 : 0)); |
| 818 | 818 | |
| 819 | 819 | switch (data & Z80DART_WR1_RX_INT_ENABLE_MASK) |
| 820 | 820 | { |
| 821 | 821 | case Z80DART_WR1_RX_INT_DISABLE: |
| 822 | | LOGERROR("Z80DART \"%s\" Channel %c : Receiver Interrupt Disabled\n", device->tag, 'A' + channel); |
| 822 | LOG(("Z80DART \"%s\" Channel %c : Receiver Interrupt Disabled\n", device->tag, 'A' + channel)); |
| 823 | 823 | break; |
| 824 | 824 | |
| 825 | 825 | case Z80DART_WR1_RX_INT_FIRST: |
| 826 | | LOGERROR("Z80DART \"%s\" Channel %c : Receiver Interrupt on First Character\n", device->tag, 'A' + channel); |
| 826 | LOG(("Z80DART \"%s\" Channel %c : Receiver Interrupt on First Character\n", device->tag, 'A' + channel)); |
| 827 | 827 | break; |
| 828 | 828 | |
| 829 | 829 | case Z80DART_WR1_RX_INT_ALL_PARITY: |
| 830 | | LOGERROR("Z80DART \"%s\" Channel %c : Receiver Interrupt on All Characters, Parity Affects Vector\n", device->tag, 'A' + channel); |
| 830 | LOG(("Z80DART \"%s\" Channel %c : Receiver Interrupt on All Characters, Parity Affects Vector\n", device->tag, 'A' + channel)); |
| 831 | 831 | break; |
| 832 | 832 | |
| 833 | 833 | case Z80DART_WR1_RX_INT_ALL: |
| 834 | | LOGERROR("Z80DART \"%s\" Channel %c : Receiver Interrupt on All Characters\n", device->tag, 'A' + channel); |
| 834 | LOG(("Z80DART \"%s\" Channel %c : Receiver Interrupt on All Characters\n", device->tag, 'A' + channel)); |
| 835 | 835 | break; |
| 836 | 836 | } |
| 837 | 837 | |
| r3740 | r3741 | |
| 841 | 841 | case 2: |
| 842 | 842 | /* interrupt vector */ |
| 843 | 843 | z80dart_check_interrupt(device); |
| 844 | | LOGERROR("Z80DART \"%s\" Channel %c : Interrupt Vector %02x\n", device->tag, 'A' + channel, data); |
| 844 | LOG(("Z80DART \"%s\" Channel %c : Interrupt Vector %02x\n", device->tag, 'A' + channel, data)); |
| 845 | 845 | break; |
| 846 | 846 | |
| 847 | 847 | case 3: |
| 848 | | LOGERROR("Z80DART \"%s\" Channel %c : Receiver Enable %u\n", device->tag, 'A' + channel, (data & Z80DART_WR3_RX_ENABLE) ? 1 : 0); |
| 849 | | LOGERROR("Z80DART \"%s\" Channel %c : Auto Enables %u\n", device->tag, 'A' + channel, (data & Z80DART_WR3_AUTO_ENABLES) ? 1 : 0); |
| 850 | | LOGERROR("Z80DART \"%s\" Channel %c : Receiver Bits/Character %u\n", device->tag, 'A' + channel, z80dart_get_rx_word_length(device, channel)); |
| 848 | LOG(("Z80DART \"%s\" Channel %c : Receiver Enable %u\n", device->tag, 'A' + channel, (data & Z80DART_WR3_RX_ENABLE) ? 1 : 0)); |
| 849 | LOG(("Z80DART \"%s\" Channel %c : Auto Enables %u\n", device->tag, 'A' + channel, (data & Z80DART_WR3_AUTO_ENABLES) ? 1 : 0)); |
| 850 | LOG(("Z80DART \"%s\" Channel %c : Receiver Bits/Character %u\n", device->tag, 'A' + channel, z80dart_get_rx_word_length(device, channel))); |
| 851 | 851 | break; |
| 852 | 852 | |
| 853 | 853 | case 4: |
| 854 | | LOGERROR("Z80DART \"%s\" Channel %c : Parity Enable %u\n", device->tag, 'A' + channel, (data & Z80DART_WR4_PARITY_ENABLE) ? 1 : 0); |
| 855 | | LOGERROR("Z80DART \"%s\" Channel %c : Parity %s\n", device->tag, 'A' + channel, (data & Z80DART_WR4_PARITY_EVEN) ? "Even" : "Odd"); |
| 856 | | LOGERROR("Z80DART \"%s\" Channel %c : Stop Bits %f\n", device->tag, 'A' + channel, z80dart_get_stop_bits(device, channel)); |
| 857 | | LOGERROR("Z80DART \"%s\" Channel %c : Clock Mode %uX\n", device->tag, 'A' + channel, z80dart_get_clock_mode(device, channel)); |
| 854 | LOG(("Z80DART \"%s\" Channel %c : Parity Enable %u\n", device->tag, 'A' + channel, (data & Z80DART_WR4_PARITY_ENABLE) ? 1 : 0)); |
| 855 | LOG(("Z80DART \"%s\" Channel %c : Parity %s\n", device->tag, 'A' + channel, (data & Z80DART_WR4_PARITY_EVEN) ? "Even" : "Odd")); |
| 856 | LOG(("Z80DART \"%s\" Channel %c : Stop Bits %f\n", device->tag, 'A' + channel, z80dart_get_stop_bits(device, channel))); |
| 857 | LOG(("Z80DART \"%s\" Channel %c : Clock Mode %uX\n", device->tag, 'A' + channel, z80dart_get_clock_mode(device, channel))); |
| 858 | 858 | break; |
| 859 | 859 | |
| 860 | 860 | case 5: |
| 861 | | LOGERROR("Z80DART \"%s\" Channel %c : Transmitter Enable %u\n", device->tag, 'A' + channel, (data & Z80DART_WR5_TX_ENABLE) ? 1 : 0); |
| 862 | | LOGERROR("Z80DART \"%s\" Channel %c : Transmitter Bits/Character %u\n", device->tag, 'A' + channel, z80dart_get_tx_word_length(device, channel)); |
| 863 | | LOGERROR("Z80DART \"%s\" Channel %c : Send Break %u\n", device->tag, 'A' + channel, (data & Z80DART_WR5_SEND_BREAK) ? 1 : 0); |
| 864 | | LOGERROR("Z80DART \"%s\" Channel %c : Request to Send %u\n", device->tag, 'A' + channel, (data & Z80DART_WR5_RTS) ? 1 : 0); |
| 865 | | LOGERROR("Z80DART \"%s\" Channel %c : Data Terminal Ready %u\n", device->tag, 'A' + channel, (data & Z80DART_WR5_DTR) ? 1 : 0); |
| 861 | LOG(("Z80DART \"%s\" Channel %c : Transmitter Enable %u\n", device->tag, 'A' + channel, (data & Z80DART_WR5_TX_ENABLE) ? 1 : 0)); |
| 862 | LOG(("Z80DART \"%s\" Channel %c : Transmitter Bits/Character %u\n", device->tag, 'A' + channel, z80dart_get_tx_word_length(device, channel))); |
| 863 | LOG(("Z80DART \"%s\" Channel %c : Send Break %u\n", device->tag, 'A' + channel, (data & Z80DART_WR5_SEND_BREAK) ? 1 : 0)); |
| 864 | LOG(("Z80DART \"%s\" Channel %c : Request to Send %u\n", device->tag, 'A' + channel, (data & Z80DART_WR5_RTS) ? 1 : 0)); |
| 865 | LOG(("Z80DART \"%s\" Channel %c : Data Terminal Ready %u\n", device->tag, 'A' + channel, (data & Z80DART_WR5_DTR) ? 1 : 0)); |
| 866 | 866 | |
| 867 | 867 | if (data & Z80DART_WR5_RTS) |
| 868 | 868 | { |
| r3740 | r3741 | |
| 913 | 913 | } |
| 914 | 914 | } |
| 915 | 915 | |
| 916 | | LOGERROR("Z80DART \"%s\" Channel %c : Data Register Read '%02x'\n", device->tag, 'A' + channel, data); |
| 916 | LOG(("Z80DART \"%s\" Channel %c : Data Register Read '%02x'\n", device->tag, 'A' + channel, data)); |
| 917 | 917 | |
| 918 | 918 | return data; |
| 919 | 919 | } |
| r3740 | r3741 | |
| 929 | 929 | ch->rr[0] &= ~Z80DART_RR0_TX_BUFFER_EMPTY; |
| 930 | 930 | ch->rr[1] &= ~Z80DART_RR1_ALL_SENT; |
| 931 | 931 | |
| 932 | | LOGERROR("Z80DART \"%s\" Channel %c : Data Register Write '%02x'\n", device->tag, 'A' + channel, data); |
| 932 | LOG(("Z80DART \"%s\" Channel %c : Data Register Write '%02x'\n", device->tag, 'A' + channel, data)); |
| 933 | 933 | } |
| 934 | 934 | |
| 935 | 935 | /*************************************************************************** |
| r3740 | r3741 | |
| 941 | 941 | z80dart_t *z80dart = get_safe_token(device); |
| 942 | 942 | dart_channel *ch = &z80dart->channel[channel]; |
| 943 | 943 | |
| 944 | | LOGERROR("Z80DART \"%s\" Channel %c : Receive Data Byte '%02x'\n", device->tag, 'A' + channel, data); |
| 944 | LOG(("Z80DART \"%s\" Channel %c : Receive Data Byte '%02x'\n", device->tag, 'A' + channel, data)); |
| 945 | 945 | |
| 946 | 946 | if (ch->rx_fifo == 2) |
| 947 | 947 | { |
| r3740 | r3741 | |
| 998 | 998 | z80dart_t *z80dart = get_safe_token(device); |
| 999 | 999 | dart_channel *ch = &z80dart->channel[channel]; |
| 1000 | 1000 | |
| 1001 | | LOGERROR("Z80DART \"%s\" Channel %c : CTS %u\n", device->tag, 'A' + channel, state); |
| 1001 | LOG(("Z80DART \"%s\" Channel %c : CTS %u\n", device->tag, 'A' + channel, state)); |
| 1002 | 1002 | |
| 1003 | 1003 | if (ch->cts != state) |
| 1004 | 1004 | { |
| r3740 | r3741 | |
| 1035 | 1035 | z80dart_t *z80dart = get_safe_token(device); |
| 1036 | 1036 | dart_channel *ch = &z80dart->channel[channel]; |
| 1037 | 1037 | |
| 1038 | | LOGERROR("Z80DART \"%s\" Channel %c : DCD %u\n", device->tag, 'A' + channel, state); |
| 1038 | LOG(("Z80DART \"%s\" Channel %c : DCD %u\n", device->tag, 'A' + channel, state)); |
| 1039 | 1039 | |
| 1040 | 1040 | if (ch->dcd != state) |
| 1041 | 1041 | { |
| r3740 | r3741 | |
| 1071 | 1071 | z80dart_t *z80dart = get_safe_token(device); |
| 1072 | 1072 | dart_channel *ch = &z80dart->channel[channel]; |
| 1073 | 1073 | |
| 1074 | | LOGERROR("Z80DART \"%s\" Channel %c : RI %u\n", device->tag, 'A' + channel, state); |
| 1074 | LOG(("Z80DART \"%s\" Channel %c : RI %u\n", device->tag, 'A' + channel, state)); |
| 1075 | 1075 | |
| 1076 | 1076 | if (ch->ri != state) |
| 1077 | 1077 | { |
| r3740 | r3741 | |
| 1108 | 1108 | |
| 1109 | 1109 | int clocks = z80dart_get_clock_mode(device, Z80DART_CH_A); |
| 1110 | 1110 | |
| 1111 | | LOGERROR("Z80DART \"%s\" Channel A : Receiver Clock Pulse\n", device->tag); |
| 1111 | LOG(("Z80DART \"%s\" Channel A : Receiver Clock Pulse\n", device->tag)); |
| 1112 | 1112 | |
| 1113 | 1113 | ch->rx_clock++; |
| 1114 | 1114 | |
| r3740 | r3741 | |
| 1128 | 1128 | |
| 1129 | 1129 | int clocks = z80dart_get_clock_mode(device, Z80DART_CH_A); |
| 1130 | 1130 | |
| 1131 | | LOGERROR("Z80DART \"%s\" Channel A : Transmitter Clock Pulse\n", device->tag); |
| 1131 | LOG(("Z80DART \"%s\" Channel A : Transmitter Clock Pulse\n", device->tag)); |
| 1132 | 1132 | |
| 1133 | 1133 | ch->tx_clock++; |
| 1134 | 1134 | |
| r3740 | r3741 | |
| 1148 | 1148 | |
| 1149 | 1149 | int clocks = z80dart_get_clock_mode(device, Z80DART_CH_B); |
| 1150 | 1150 | |
| 1151 | | LOGERROR("Z80DART \"%s\" Channel A : Receiver/Transmitter Clock Pulse\n", device->tag); |
| 1151 | LOG(("Z80DART \"%s\" Channel A : Receiver/Transmitter Clock Pulse\n", device->tag)); |
| 1152 | 1152 | |
| 1153 | 1153 | ch->rx_clock++; |
| 1154 | 1154 | ch->tx_clock++; |
| r3740 | r3741 | |
| 1189 | 1189 | int state = 0; |
| 1190 | 1190 | int i; |
| 1191 | 1191 | |
| 1192 | | LOGERROR("Z80DART \"%s\" : Interrupt State B:%d%d%d%d A:%d%d%d%d\n", device->tag, |
| 1192 | LOG(("Z80DART \"%s\" : Interrupt State B:%d%d%d%d A:%d%d%d%d\n", device->tag, |
| 1193 | 1193 | z80dart->int_state[0], z80dart->int_state[1], z80dart->int_state[2], z80dart->int_state[3], |
| 1194 | | z80dart->int_state[4], z80dart->int_state[5], z80dart->int_state[6], z80dart->int_state[7]); |
| 1194 | z80dart->int_state[4], z80dart->int_state[5], z80dart->int_state[6], z80dart->int_state[7])); |
| 1195 | 1195 | |
| 1196 | 1196 | /* loop over all interrupt sources */ |
| 1197 | 1197 | for (i = 0; i < 8; i++) |
| r3740 | r3741 | |
| 1205 | 1205 | state |= z80dart->int_state[i]; |
| 1206 | 1206 | } |
| 1207 | 1207 | |
| 1208 | | LOGERROR("Z80DART \"%s\" : Interrupt State %u\n", device->tag, state); |
| 1208 | LOG(("Z80DART \"%s\" : Interrupt State %u\n", device->tag, state)); |
| 1209 | 1209 | |
| 1210 | 1210 | return state; |
| 1211 | 1211 | } |
| r3740 | r3741 | |
| 1215 | 1215 | z80dart_t *z80dart = get_safe_token( device ); |
| 1216 | 1216 | int i; |
| 1217 | 1217 | |
| 1218 | | LOGERROR("Z80DART \"%s\" Interrupt Acknowledge\n", device->tag); |
| 1218 | LOG(("Z80DART \"%s\" Interrupt Acknowledge\n", device->tag)); |
| 1219 | 1219 | |
| 1220 | 1220 | /* loop over all interrupt sources */ |
| 1221 | 1221 | for (i = 0; i < 8; i++) |
| r3740 | r3741 | |
| 1228 | 1228 | z80dart->channel[Z80DART_CH_A].rr[0] &= ~Z80DART_RR0_INTERRUPT_PENDING; |
| 1229 | 1229 | z80dart_check_interrupt(device); |
| 1230 | 1230 | |
| 1231 | | LOGERROR("Z80DART \"%s\" : Interrupt Acknowledge Vector %02x\n", device->tag, z80dart->channel[Z80DART_CH_B].rr[2]); |
| 1231 | LOG(("Z80DART \"%s\" : Interrupt Acknowledge Vector %02x\n", device->tag, z80dart->channel[Z80DART_CH_B].rr[2])); |
| 1232 | 1232 | |
| 1233 | 1233 | return z80dart->channel[Z80DART_CH_B].rr[2]; |
| 1234 | 1234 | } |
| r3740 | r3741 | |
| 1244 | 1244 | z80dart_t *z80dart = get_safe_token( device ); |
| 1245 | 1245 | int i; |
| 1246 | 1246 | |
| 1247 | | LOGERROR("Z80DART \"%s\" Return from Interrupt\n", device->tag); |
| 1247 | LOG(("Z80DART \"%s\" Return from Interrupt\n", device->tag)); |
| 1248 | 1248 | |
| 1249 | 1249 | /* loop over all interrupt sources */ |
| 1250 | 1250 | for (i = 0; i < 8; i++) |
| r3740 | r3741 | |
| 1357 | 1357 | { |
| 1358 | 1358 | int channel; |
| 1359 | 1359 | |
| 1360 | | LOGERROR("Z80DART \"%s\" Reset\n", device->tag); |
| 1360 | LOG(("Z80DART \"%s\" Reset\n", device->tag)); |
| 1361 | 1361 | |
| 1362 | 1362 | for (channel = Z80DART_CH_A; channel <= Z80DART_CH_B; channel++) |
| 1363 | 1363 | { |