src/mame/machine/pcshare.c
| r2300 | r2301 | |
| 33 | 33 | #include "machine/8237dma.h" |
| 34 | 34 | #include "machine/pckeybrd.h" |
| 35 | 35 | |
| 36 | | #ifdef MESS |
| 37 | | #include "machine/pc_fdc.h" |
| 38 | | #include "machine/pc_hdc.h" |
| 39 | | #endif /* MESS */ |
| 40 | | |
| 41 | 36 | #define VERBOSE_DBG 0 /* general debug messages */ |
| 42 | 37 | #define DBG_LOG(N,M,A) \ |
| 43 | 38 | if(VERBOSE_DBG>=N){ if( M )logerror("%11.6f: %-24s",attotime_to_double(timer_get_time()),(char*)M ); logerror A; } |
| r2300 | r2301 | |
| 51 | 46 | |
| 52 | 47 | static TIMER_CALLBACK( pc_keyb_timer ); |
| 53 | 48 | |
| 54 | | #define LOG_PORT80 0 |
| 55 | 49 | |
| 56 | | |
| 57 | | /************************************************************************* |
| 58 | | * |
| 59 | | * PC DMA stuff |
| 60 | | * |
| 61 | | *************************************************************************/ |
| 62 | | |
| 63 | | static UINT8 dma_offset[2][4]; |
| 64 | | static UINT8 at_pages[0x10]; |
| 65 | | static offs_t pc_page_offset_mask; |
| 66 | | |
| 67 | | |
| 68 | | |
| 69 | | READ8_HANDLER(pc_page_r) |
| 70 | | { |
| 71 | | return 0xFF; |
| 72 | | } |
| 73 | | |
| 74 | | |
| 75 | | |
| 76 | | WRITE8_HANDLER(pc_page_w) |
| 77 | | { |
| 78 | | switch(offset % 4) { |
| 79 | | case 1: |
| 80 | | dma_offset[0][2] = data; |
| 81 | | break; |
| 82 | | case 2: |
| 83 | | dma_offset[0][3] = data; |
| 84 | | break; |
| 85 | | case 3: |
| 86 | | dma_offset[0][0] = dma_offset[0][1] = data; |
| 87 | | break; |
| 88 | | } |
| 89 | | } |
| 90 | | |
| 91 | | |
| 92 | | |
| 93 | | READ16_HANDLER(pc_page16le_r) { return read16le_with_read8_handler(pc_page_r, machine, offset, mem_mask); } |
| 94 | | WRITE16_HANDLER(pc_page16le_w) { write16le_with_write8_handler(pc_page_w, machine, offset, data, mem_mask); } |
| 95 | | |
| 96 | | |
| 97 | | |
| 98 | | READ8_HANDLER(at_page8_r) |
| 99 | | { |
| 100 | | UINT8 data = at_pages[offset % 0x10]; |
| 101 | | |
| 102 | | switch(offset % 8) { |
| 103 | | case 1: |
| 104 | | data = dma_offset[(offset / 8) & 1][2]; |
| 105 | | break; |
| 106 | | case 2: |
| 107 | | data = dma_offset[(offset / 8) & 1][3]; |
| 108 | | break; |
| 109 | | case 3: |
| 110 | | data = dma_offset[(offset / 8) & 1][1]; |
| 111 | | break; |
| 112 | | case 7: |
| 113 | | data = dma_offset[(offset / 8) & 1][0]; |
| 114 | | break; |
| 115 | | } |
| 116 | | return data; |
| 117 | | } |
| 118 | | |
| 119 | | |
| 120 | | |
| 121 | | WRITE8_HANDLER(at_page8_w) |
| 122 | | { |
| 123 | | at_pages[offset % 0x10] = data; |
| 124 | | |
| 125 | | if (LOG_PORT80 && (offset == 0)) |
| 126 | | logerror(" at_page8_w(): Port 80h <== 0x%02x (PC=0x%08x)\n", data, (unsigned) activecpu_get_reg(REG_PC)); |
| 127 | | |
| 128 | | switch(offset % 8) { |
| 129 | | case 1: |
| 130 | | dma_offset[(offset / 8) & 1][2] = data; |
| 131 | | break; |
| 132 | | case 2: |
| 133 | | dma_offset[(offset / 8) & 1][3] = data; |
| 134 | | break; |
| 135 | | case 3: |
| 136 | | dma_offset[(offset / 8) & 1][1] = data; |
| 137 | | break; |
| 138 | | case 7: |
| 139 | | dma_offset[(offset / 8) & 1][0] = data; |
| 140 | | break; |
| 141 | | } |
| 142 | | } |
| 143 | | |
| 144 | | |
| 145 | | |
| 146 | | READ32_HANDLER(at_page32_r) |
| 147 | | { |
| 148 | | return read32le_with_read8_handler(at_page8_r, machine, offset, mem_mask); |
| 149 | | } |
| 150 | | |
| 151 | | |
| 152 | | |
| 153 | | WRITE32_HANDLER(at_page32_w) |
| 154 | | { |
| 155 | | write32le_with_write8_handler(at_page8_w, machine, offset, data, mem_mask); |
| 156 | | } |
| 157 | | |
| 158 | | |
| 159 | | |
| 160 | | static UINT8 pc_dma_read_byte(int channel, offs_t offset) |
| 161 | | { |
| 162 | | UINT8 result; |
| 163 | | offs_t page_offset = (((offs_t) dma_offset[0][channel]) << 16) |
| 164 | | & pc_page_offset_mask; |
| 165 | | |
| 166 | | cpuintrf_push_context(0); |
| 167 | | result = program_read_byte(page_offset + offset); |
| 168 | | cpuintrf_pop_context(); |
| 169 | | |
| 170 | | return result; |
| 171 | | } |
| 172 | | |
| 173 | | |
| 174 | | |
| 175 | | static void pc_dma_write_byte(int channel, offs_t offset, UINT8 data) |
| 176 | | { |
| 177 | | offs_t page_offset = (((offs_t) dma_offset[0][channel]) << 16) |
| 178 | | & pc_page_offset_mask; |
| 179 | | |
| 180 | | cpuintrf_push_context(0); |
| 181 | | program_write_byte(page_offset + offset, data); |
| 182 | | cpuintrf_pop_context(); |
| 183 | | } |
| 184 | | |
| 185 | | |
| 186 | | |
| 187 | | static const struct dma8237_interface pc_dma = |
| 188 | | { |
| 189 | | 0, |
| 190 | | 1.0e-6, // 1us |
| 191 | | |
| 192 | | pc_dma_read_byte, |
| 193 | | pc_dma_write_byte, |
| 194 | | |
| 195 | | #ifdef MESS |
| 196 | | { 0, 0, pc_fdc_dack_r, pc_hdc_dack_r }, |
| 197 | | { 0, 0, pc_fdc_dack_w, pc_hdc_dack_w }, |
| 198 | | pc_fdc_set_tc_state |
| 199 | | #else |
| 200 | | { 0, 0, 0, 0 }, |
| 201 | | { 0, 0, 0, 0 }, |
| 202 | | 0 |
| 203 | | #endif |
| 204 | | }; |
| 205 | | |
| 206 | | |
| 207 | | |
| 208 | 50 | /* ----------------------------------------------------------------------- */ |
| 209 | 51 | |
| 210 | 52 | static void pc_pic_set_int_line(int which, int interrupt) |
| r2300 | r2301 | |
| 237 | 79 | /* PIC */ |
| 238 | 80 | pic8259_init(2, pc_pic_set_int_line); |
| 239 | 81 | |
| 240 | | /* DMA */ |
| 241 | | if (flags & PCCOMMON_DMA8237_AT) |
| 242 | | { |
| 243 | | dma8237_init(2); |
| 244 | | dma8237_config(0, &pc_dma); |
| 245 | | pc_page_offset_mask = 0xFF0000; |
| 246 | | } |
| 247 | | else |
| 248 | | { |
| 249 | | dma8237_init(1); |
| 250 | | dma8237_config(0, &pc_dma); |
| 251 | | pc_page_offset_mask = 0x0F0000; |
| 252 | | } |
| 253 | | |
| 254 | 82 | pc_keyboard_timer = timer_alloc(pc_keyb_timer, NULL); |
| 255 | 83 | } |
| 256 | 84 | |
src/mame/drivers/mediagx.c
| r2300 | r2301 | |
| 349 | 349 | } |
| 350 | 350 | |
| 351 | 351 | |
| 352 | | static READ8_HANDLER(at_dma8237_1_r) |
| 352 | static READ8_HANDLER(at_dma8237_2_r) |
| 353 | 353 | { |
| 354 | | return dma8237_1_r(machine, offset / 2); |
| 354 | return dma8237_r((device_config*)device_list_find_by_tag( machine->config->devicelist, DMA8237, "dma8237_2" ), offset / 2); |
| 355 | 355 | } |
| 356 | 356 | |
| 357 | | static WRITE8_HANDLER(at_dma8237_1_w) |
| 357 | static WRITE8_HANDLER(at_dma8237_2_w) |
| 358 | 358 | { |
| 359 | | dma8237_1_w(machine, offset / 2, data); |
| 359 | dma8237_w((device_config*)device_list_find_by_tag( machine->config->devicelist, DMA8237, "dma8237_2" ), offset / 2, data); |
| 360 | 360 | } |
| 361 | 361 | |
| 362 | | static READ32_HANDLER(at32_dma8237_1_r) |
| 362 | static READ32_HANDLER(at32_dma8237_2_r) |
| 363 | 363 | { |
| 364 | | return read32le_with_read8_handler(at_dma8237_1_r, machine, offset, mem_mask); |
| 364 | return read32le_with_read8_handler(at_dma8237_2_r, machine, offset, mem_mask); |
| 365 | 365 | } |
| 366 | 366 | |
| 367 | | static WRITE32_HANDLER(at32_dma8237_1_w) |
| 367 | static WRITE32_HANDLER(at32_dma8237_2_w) |
| 368 | 368 | { |
| 369 | | write32le_with_write8_handler(at_dma8237_1_w, machine, offset, data, mem_mask); |
| 369 | write32le_with_write8_handler(at_dma8237_2_w, machine, offset, data, mem_mask); |
| 370 | 370 | } |
| 371 | 371 | |
| 372 | 372 | |
| r2300 | r2301 | |
| 719 | 719 | } |
| 720 | 720 | } |
| 721 | 721 | |
| 722 | |
| 723 | /************************************************************************* |
| 724 | * |
| 725 | * PC DMA stuff |
| 726 | * |
| 727 | *************************************************************************/ |
| 728 | |
| 729 | static UINT8 dma_offset[2][4]; |
| 730 | static UINT8 at_pages[0x10]; |
| 731 | |
| 732 | |
| 733 | static READ8_HANDLER(at_page8_r) |
| 734 | { |
| 735 | UINT8 data = at_pages[offset % 0x10]; |
| 736 | |
| 737 | switch(offset % 8) { |
| 738 | case 1: |
| 739 | data = dma_offset[(offset / 8) & 1][2]; |
| 740 | break; |
| 741 | case 2: |
| 742 | data = dma_offset[(offset / 8) & 1][3]; |
| 743 | break; |
| 744 | case 3: |
| 745 | data = dma_offset[(offset / 8) & 1][1]; |
| 746 | break; |
| 747 | case 7: |
| 748 | data = dma_offset[(offset / 8) & 1][0]; |
| 749 | break; |
| 750 | } |
| 751 | return data; |
| 752 | } |
| 753 | |
| 754 | |
| 755 | static WRITE8_HANDLER(at_page8_w) |
| 756 | { |
| 757 | at_pages[offset % 0x10] = data; |
| 758 | |
| 759 | switch(offset % 8) { |
| 760 | case 1: |
| 761 | dma_offset[(offset / 8) & 1][2] = data; |
| 762 | break; |
| 763 | case 2: |
| 764 | dma_offset[(offset / 8) & 1][3] = data; |
| 765 | break; |
| 766 | case 3: |
| 767 | dma_offset[(offset / 8) & 1][1] = data; |
| 768 | break; |
| 769 | case 7: |
| 770 | dma_offset[(offset / 8) & 1][0] = data; |
| 771 | break; |
| 772 | } |
| 773 | } |
| 774 | |
| 775 | |
| 776 | static DMA8237_MEM_READ( pc_dma_read_byte ) |
| 777 | { |
| 778 | UINT8 result; |
| 779 | offs_t page_offset = (((offs_t) dma_offset[0][channel]) << 16) |
| 780 | & 0xFF0000; |
| 781 | |
| 782 | cpuintrf_push_context(0); |
| 783 | result = program_read_byte(page_offset + offset); |
| 784 | cpuintrf_pop_context(); |
| 785 | |
| 786 | return result; |
| 787 | } |
| 788 | |
| 789 | |
| 790 | static DMA8237_MEM_WRITE( pc_dma_write_byte ) |
| 791 | { |
| 792 | offs_t page_offset = (((offs_t) dma_offset[0][channel]) << 16) |
| 793 | & 0xFF0000; |
| 794 | |
| 795 | cpuintrf_push_context(0); |
| 796 | program_write_byte(page_offset + offset, data); |
| 797 | cpuintrf_pop_context(); |
| 798 | } |
| 799 | |
| 800 | |
| 801 | static const struct dma8237_interface dma8237_1_config = |
| 802 | { |
| 803 | 0, |
| 804 | 1.0e-6, // 1us |
| 805 | |
| 806 | pc_dma_read_byte, |
| 807 | pc_dma_write_byte, |
| 808 | |
| 809 | { 0, 0, NULL, NULL }, |
| 810 | { 0, 0, NULL, NULL }, |
| 811 | NULL |
| 812 | }; |
| 813 | |
| 814 | |
| 815 | static const struct dma8237_interface dma8237_2_config = |
| 816 | { |
| 817 | 0, |
| 818 | 1.0e-6, // 1us |
| 819 | |
| 820 | NULL, |
| 821 | NULL, |
| 822 | |
| 823 | { NULL, NULL, NULL, NULL }, |
| 824 | { NULL, NULL, NULL, NULL }, |
| 825 | NULL |
| 826 | }; |
| 827 | |
| 828 | static READ32_HANDLER(at_page32_r) |
| 829 | { |
| 830 | return read32le_with_read8_handler(at_page8_r, machine, offset, mem_mask); |
| 831 | } |
| 832 | |
| 833 | |
| 834 | static WRITE32_HANDLER(at_page32_w) |
| 835 | { |
| 836 | write32le_with_write8_handler(at_page8_w, machine, offset, data, mem_mask); |
| 837 | } |
| 838 | |
| 839 | |
| 722 | 840 | DEV_READWRITE8TO32LE( mediagx_pit8254_32le, pit8253_r, pit8253_w ) |
| 841 | DEV_READWRITE8TO32LE( mediagx_dma8237_32le, dma8237_r, dma8237_w ) |
| 723 | 842 | |
| 724 | 843 | |
| 725 | 844 | /*****************************************************************************/ |
| r2300 | r2301 | |
| 738 | 857 | ADDRESS_MAP_END |
| 739 | 858 | |
| 740 | 859 | static ADDRESS_MAP_START(mediagx_io, ADDRESS_SPACE_IO, 32) |
| 741 | | AM_RANGE(0x0000, 0x001f) AM_READWRITE(dma8237_32le_0_r, dma8237_32le_0_w) |
| 860 | AM_RANGE(0x0000, 0x001f) AM_DEVREADWRITE(DMA8237, "dma8237_1", mediagx_dma8237_32le_r, mediagx_dma8237_32le_w) |
| 742 | 861 | AM_RANGE(0x0020, 0x0023) AM_READWRITE(io20_r, io20_w) |
| 743 | 862 | AM_RANGE(0x0040, 0x005f) AM_DEVREADWRITE(PIT8254, "pit8254", mediagx_pit8254_32le_r, mediagx_pit8254_32le_w) |
| 744 | 863 | AM_RANGE(0x0060, 0x006f) AM_READWRITE(kbdc8042_32le_r, kbdc8042_32le_w) |
| 745 | 864 | AM_RANGE(0x0070, 0x007f) AM_READWRITE(mc146818_port32le_r, mc146818_port32le_w) |
| 746 | 865 | AM_RANGE(0x0080, 0x009f) AM_READWRITE(at_page32_r, at_page32_w) |
| 747 | 866 | AM_RANGE(0x00a0, 0x00af) AM_READWRITE(pic8259_32le_1_r, pic8259_32le_1_w) |
| 748 | | AM_RANGE(0x00c0, 0x00cf) AM_READWRITE(at32_dma8237_1_r, at32_dma8237_1_w) |
| 867 | AM_RANGE(0x00c0, 0x00cf) AM_READWRITE(at32_dma8237_2_r, at32_dma8237_2_w) |
| 749 | 868 | AM_RANGE(0x00e8, 0x00eb) AM_NOP // I/O delay port |
| 750 | 869 | AM_RANGE(0x01f0, 0x01f7) AM_READWRITE(ide0_r, ide0_w) |
| 751 | 870 | AM_RANGE(0x0378, 0x037b) AM_READWRITE(parallel_port_r, parallel_port_w) |
| r2300 | r2301 | |
| 849 | 968 | { |
| 850 | 969 | UINT8 *rom = memory_region(REGION_USER1); |
| 851 | 970 | |
| 852 | | dma8237_reset(); |
| 853 | 971 | cpunum_set_irq_callback(0, irq_callback); |
| 854 | 972 | |
| 855 | 973 | memcpy(bios_ram, rom, 0x40000); |
| r2300 | r2301 | |
| 902 | 1020 | MDRV_DEVICE_ADD( "pit8254", PIT8254 ) |
| 903 | 1021 | MDRV_DEVICE_CONFIG( mediagx_pit8254_config ) |
| 904 | 1022 | |
| 1023 | MDRV_DEVICE_ADD( "dma8237_1", DMA8237 ) |
| 1024 | MDRV_DEVICE_CONFIG( dma8237_1_config ) |
| 1025 | |
| 1026 | MDRV_DEVICE_ADD( "dma8237_2", DMA8237 ) |
| 1027 | MDRV_DEVICE_CONFIG( dma8237_2_config ) |
| 1028 | |
| 905 | 1029 | MDRV_NVRAM_HANDLER( mc146818 ) |
| 906 | 1030 | |
| 907 | 1031 | /* video hardware */ |
| r2300 | r2301 | |
| 960 | 1084 | |
| 961 | 1085 | static void init_mediagx(running_machine *machine) |
| 962 | 1086 | { |
| 963 | | init_pc_common(PCCOMMON_KEYBOARD_AT | PCCOMMON_DMA8237_AT); |
| 1087 | init_pc_common(PCCOMMON_KEYBOARD_AT); |
| 964 | 1088 | mc146818_init(MC146818_STANDARD); |
| 965 | 1089 | |
| 966 | 1090 | pci_init(); |
src/mame/drivers/taitowlf.c
| r2300 | r2301 | |
| 85 | 85 | return 0; |
| 86 | 86 | } |
| 87 | 87 | |
| 88 | | static READ8_HANDLER(at_dma8237_1_r) |
| 88 | static READ8_HANDLER(at_dma8237_2_r) |
| 89 | 89 | { |
| 90 | | return dma8237_1_r(machine, offset / 2); |
| 90 | return dma8237_r((device_config*)device_list_find_by_tag( machine->config->devicelist, DMA8237, "dma8237_2" ), offset / 2); |
| 91 | 91 | } |
| 92 | 92 | |
| 93 | | static WRITE8_HANDLER(at_dma8237_1_w) |
| 93 | static WRITE8_HANDLER(at_dma8237_2_w) |
| 94 | 94 | { |
| 95 | | dma8237_1_w(machine, offset / 2, data); |
| 95 | dma8237_w((device_config*)device_list_find_by_tag( machine->config->devicelist, DMA8237, "dma8237_2" ), offset / 2, data); |
| 96 | 96 | } |
| 97 | 97 | |
| 98 | | static READ32_HANDLER(at32_dma8237_1_r) |
| 98 | static READ32_HANDLER(at32_dma8237_2_r) |
| 99 | 99 | { |
| 100 | | return read32le_with_read8_handler(at_dma8237_1_r, machine, offset, mem_mask); |
| 100 | return read32le_with_read8_handler(at_dma8237_2_r, machine, offset, mem_mask); |
| 101 | 101 | } |
| 102 | 102 | |
| 103 | | static WRITE32_HANDLER(at32_dma8237_1_w) |
| 103 | static WRITE32_HANDLER(at32_dma8237_2_w) |
| 104 | 104 | { |
| 105 | | write32le_with_write8_handler(at_dma8237_1_w, machine, offset, data, mem_mask); |
| 105 | write32le_with_write8_handler(at_dma8237_2_w, machine, offset, data, mem_mask); |
| 106 | 106 | } |
| 107 | 107 | |
| 108 | 108 | |
| r2300 | r2301 | |
| 300 | 300 | } |
| 301 | 301 | |
| 302 | 302 | |
| 303 | /************************************************************************* |
| 304 | * |
| 305 | * PC DMA stuff |
| 306 | * |
| 307 | *************************************************************************/ |
| 308 | |
| 309 | static UINT8 dma_offset[2][4]; |
| 310 | static UINT8 at_pages[0x10]; |
| 311 | |
| 312 | |
| 313 | static READ8_HANDLER(at_page8_r) |
| 314 | { |
| 315 | UINT8 data = at_pages[offset % 0x10]; |
| 316 | |
| 317 | switch(offset % 8) { |
| 318 | case 1: |
| 319 | data = dma_offset[(offset / 8) & 1][2]; |
| 320 | break; |
| 321 | case 2: |
| 322 | data = dma_offset[(offset / 8) & 1][3]; |
| 323 | break; |
| 324 | case 3: |
| 325 | data = dma_offset[(offset / 8) & 1][1]; |
| 326 | break; |
| 327 | case 7: |
| 328 | data = dma_offset[(offset / 8) & 1][0]; |
| 329 | break; |
| 330 | } |
| 331 | return data; |
| 332 | } |
| 333 | |
| 334 | |
| 335 | static WRITE8_HANDLER(at_page8_w) |
| 336 | { |
| 337 | at_pages[offset % 0x10] = data; |
| 338 | |
| 339 | switch(offset % 8) { |
| 340 | case 1: |
| 341 | dma_offset[(offset / 8) & 1][2] = data; |
| 342 | break; |
| 343 | case 2: |
| 344 | dma_offset[(offset / 8) & 1][3] = data; |
| 345 | break; |
| 346 | case 3: |
| 347 | dma_offset[(offset / 8) & 1][1] = data; |
| 348 | break; |
| 349 | case 7: |
| 350 | dma_offset[(offset / 8) & 1][0] = data; |
| 351 | break; |
| 352 | } |
| 353 | } |
| 354 | |
| 355 | |
| 356 | static DMA8237_MEM_READ( pc_dma_read_byte ) |
| 357 | { |
| 358 | UINT8 result; |
| 359 | offs_t page_offset = (((offs_t) dma_offset[0][channel]) << 16) |
| 360 | & 0xFF0000; |
| 361 | |
| 362 | cpuintrf_push_context(0); |
| 363 | result = program_read_byte(page_offset + offset); |
| 364 | cpuintrf_pop_context(); |
| 365 | |
| 366 | return result; |
| 367 | } |
| 368 | |
| 369 | |
| 370 | static DMA8237_MEM_WRITE( pc_dma_write_byte ) |
| 371 | { |
| 372 | offs_t page_offset = (((offs_t) dma_offset[0][channel]) << 16) |
| 373 | & 0xFF0000; |
| 374 | |
| 375 | cpuintrf_push_context(0); |
| 376 | program_write_byte(page_offset + offset, data); |
| 377 | cpuintrf_pop_context(); |
| 378 | } |
| 379 | |
| 380 | |
| 381 | static const struct dma8237_interface dma8237_1_config = |
| 382 | { |
| 383 | 0, |
| 384 | 1.0e-6, // 1us |
| 385 | |
| 386 | pc_dma_read_byte, |
| 387 | pc_dma_write_byte, |
| 388 | |
| 389 | { 0, 0, NULL, NULL }, |
| 390 | { 0, 0, NULL, NULL }, |
| 391 | NULL |
| 392 | }; |
| 393 | |
| 394 | |
| 395 | static const struct dma8237_interface dma8237_2_config = |
| 396 | { |
| 397 | 0, |
| 398 | 1.0e-6, // 1us |
| 399 | |
| 400 | NULL, |
| 401 | NULL, |
| 402 | |
| 403 | { NULL, NULL, NULL, NULL }, |
| 404 | { NULL, NULL, NULL, NULL }, |
| 405 | NULL |
| 406 | }; |
| 407 | |
| 408 | static READ32_HANDLER(at_page32_r) |
| 409 | { |
| 410 | return read32le_with_read8_handler(at_page8_r, machine, offset, mem_mask); |
| 411 | } |
| 412 | |
| 413 | |
| 414 | static WRITE32_HANDLER(at_page32_w) |
| 415 | { |
| 416 | write32le_with_write8_handler(at_page8_w, machine, offset, data, mem_mask); |
| 417 | } |
| 418 | |
| 419 | |
| 303 | 420 | DEV_READWRITE8TO32LE( taitowlf_pit8254_32le, pit8253_r, pit8253_w ) |
| 421 | DEV_READWRITE8TO32LE( taitowlf_dma8237_32le, dma8237_r, dma8237_w ) |
| 304 | 422 | |
| 305 | 423 | |
| 306 | 424 | /*****************************************************************************/ |
| r2300 | r2301 | |
| 317 | 435 | ADDRESS_MAP_END |
| 318 | 436 | |
| 319 | 437 | static ADDRESS_MAP_START(taitowlf_io, ADDRESS_SPACE_IO, 32) |
| 320 | | AM_RANGE(0x0000, 0x001f) AM_READWRITE(dma8237_32le_0_r, dma8237_32le_0_w) |
| 438 | AM_RANGE(0x0000, 0x001f) AM_DEVREADWRITE(DMA8237, "dma8237_1", taitowlf_dma8237_32le_r, taitowlf_dma8237_32le_w) |
| 321 | 439 | AM_RANGE(0x0020, 0x003f) AM_READWRITE(pic8259_32le_0_r, pic8259_32le_0_w) |
| 322 | 440 | AM_RANGE(0x0040, 0x005f) AM_DEVREADWRITE(PIT8254, "pit8254", taitowlf_pit8254_32le_r, taitowlf_pit8254_32le_w) |
| 323 | 441 | AM_RANGE(0x0060, 0x006f) AM_READWRITE(kbdc8042_32le_r, kbdc8042_32le_w) |
| 324 | 442 | AM_RANGE(0x0070, 0x007f) AM_READWRITE(mc146818_port32le_r, mc146818_port32le_w) |
| 325 | 443 | AM_RANGE(0x0080, 0x009f) AM_READWRITE(at_page32_r, at_page32_w) |
| 326 | 444 | AM_RANGE(0x00a0, 0x00bf) AM_READWRITE(pic8259_32le_1_r, pic8259_32le_1_w) |
| 327 | | AM_RANGE(0x00c0, 0x00df) AM_READWRITE(at32_dma8237_1_r, at32_dma8237_1_w) |
| 445 | AM_RANGE(0x00c0, 0x00df) AM_READWRITE(at32_dma8237_2_r, at32_dma8237_2_w) |
| 328 | 446 | AM_RANGE(0x00e8, 0x00eb) AM_NOP |
| 329 | 447 | AM_RANGE(0x01f0, 0x01f7) AM_READWRITE(ide0_r, ide0_w) |
| 330 | 448 | AM_RANGE(0x0300, 0x03af) AM_NOP |
| r2300 | r2301 | |
| 408 | 526 | { |
| 409 | 527 | memory_set_bankptr(1, memory_region(REGION_USER1) + 0x30000); |
| 410 | 528 | |
| 411 | | dma8237_reset(); |
| 412 | 529 | cpunum_set_irq_callback(0, irq_callback); |
| 413 | 530 | } |
| 414 | 531 | |
| r2300 | r2301 | |
| 448 | 565 | MDRV_DEVICE_ADD( "pit8254", PIT8254 ) |
| 449 | 566 | MDRV_DEVICE_CONFIG( taitowlf_pit8254_config ) |
| 450 | 567 | |
| 568 | MDRV_DEVICE_ADD( "dma8237_1", DMA8237 ) |
| 569 | MDRV_DEVICE_CONFIG( dma8237_1_config ) |
| 570 | |
| 571 | MDRV_DEVICE_ADD( "dma8237_2", DMA8237 ) |
| 572 | MDRV_DEVICE_CONFIG( dma8237_2_config ) |
| 573 | |
| 451 | 574 | MDRV_NVRAM_HANDLER( mc146818 ) |
| 452 | 575 | |
| 453 | 576 | /* video hardware */ |
| r2300 | r2301 | |
| 507 | 630 | { |
| 508 | 631 | bios_ram = auto_malloc(0x10000); |
| 509 | 632 | |
| 510 | | init_pc_common(PCCOMMON_KEYBOARD_AT | PCCOMMON_DMA8237_AT); |
| 633 | init_pc_common(PCCOMMON_KEYBOARD_AT); |
| 511 | 634 | mc146818_init(MC146818_STANDARD); |
| 512 | 635 | |
| 513 | 636 | intel82439tx_init(); |
src/mame/drivers/gamecstl.c
| r2300 | r2301 | |
| 119 | 119 | return 0; |
| 120 | 120 | } |
| 121 | 121 | |
| 122 | | static READ8_HANDLER(at_dma8237_1_r) |
| 122 | static READ8_HANDLER(at_dma8237_2_r) |
| 123 | 123 | { |
| 124 | | return dma8237_1_r(machine, offset / 2); |
| 124 | return dma8237_r((device_config*)device_list_find_by_tag( machine->config->devicelist, DMA8237, "dma8237_2" ), offset / 2); |
| 125 | 125 | } |
| 126 | 126 | |
| 127 | | static WRITE8_HANDLER(at_dma8237_1_w) |
| 127 | static WRITE8_HANDLER(at_dma8237_2_w) |
| 128 | 128 | { |
| 129 | | dma8237_1_w(machine, offset / 2, data); |
| 129 | dma8237_w((device_config*)device_list_find_by_tag( machine->config->devicelist, DMA8237, "dma8237_2" ), offset / 2, data); |
| 130 | 130 | } |
| 131 | 131 | |
| 132 | | static READ32_HANDLER(at32_dma8237_1_r) |
| 132 | static READ32_HANDLER(at32_dma8237_2_r) |
| 133 | 133 | { |
| 134 | | return read32le_with_read8_handler(at_dma8237_1_r, machine, offset, mem_mask); |
| 134 | return read32le_with_read8_handler(at_dma8237_2_r, machine, offset, mem_mask); |
| 135 | 135 | } |
| 136 | 136 | |
| 137 | | static WRITE32_HANDLER(at32_dma8237_1_w) |
| 137 | static WRITE32_HANDLER(at32_dma8237_2_w) |
| 138 | 138 | { |
| 139 | | write32le_with_write8_handler(at_dma8237_1_w, machine, offset, data, mem_mask); |
| 139 | write32le_with_write8_handler(at_dma8237_2_w, machine, offset, data, mem_mask); |
| 140 | 140 | } |
| 141 | 141 | |
| 142 | 142 | |
| r2300 | r2301 | |
| 334 | 334 | } |
| 335 | 335 | |
| 336 | 336 | |
| 337 | /************************************************************************* |
| 338 | * |
| 339 | * PC DMA stuff |
| 340 | * |
| 341 | *************************************************************************/ |
| 342 | |
| 343 | static UINT8 dma_offset[2][4]; |
| 344 | static UINT8 at_pages[0x10]; |
| 345 | |
| 346 | |
| 347 | static READ8_HANDLER(at_page8_r) |
| 348 | { |
| 349 | UINT8 data = at_pages[offset % 0x10]; |
| 350 | |
| 351 | switch(offset % 8) { |
| 352 | case 1: |
| 353 | data = dma_offset[(offset / 8) & 1][2]; |
| 354 | break; |
| 355 | case 2: |
| 356 | data = dma_offset[(offset / 8) & 1][3]; |
| 357 | break; |
| 358 | case 3: |
| 359 | data = dma_offset[(offset / 8) & 1][1]; |
| 360 | break; |
| 361 | case 7: |
| 362 | data = dma_offset[(offset / 8) & 1][0]; |
| 363 | break; |
| 364 | } |
| 365 | return data; |
| 366 | } |
| 367 | |
| 368 | |
| 369 | static WRITE8_HANDLER(at_page8_w) |
| 370 | { |
| 371 | at_pages[offset % 0x10] = data; |
| 372 | |
| 373 | switch(offset % 8) { |
| 374 | case 1: |
| 375 | dma_offset[(offset / 8) & 1][2] = data; |
| 376 | break; |
| 377 | case 2: |
| 378 | dma_offset[(offset / 8) & 1][3] = data; |
| 379 | break; |
| 380 | case 3: |
| 381 | dma_offset[(offset / 8) & 1][1] = data; |
| 382 | break; |
| 383 | case 7: |
| 384 | dma_offset[(offset / 8) & 1][0] = data; |
| 385 | break; |
| 386 | } |
| 387 | } |
| 388 | |
| 389 | |
| 390 | static DMA8237_MEM_READ( pc_dma_read_byte ) |
| 391 | { |
| 392 | UINT8 result; |
| 393 | offs_t page_offset = (((offs_t) dma_offset[0][channel]) << 16) |
| 394 | & 0xFF0000; |
| 395 | |
| 396 | cpuintrf_push_context(0); |
| 397 | result = program_read_byte(page_offset + offset); |
| 398 | cpuintrf_pop_context(); |
| 399 | |
| 400 | return result; |
| 401 | } |
| 402 | |
| 403 | |
| 404 | static DMA8237_MEM_WRITE( pc_dma_write_byte ) |
| 405 | { |
| 406 | offs_t page_offset = (((offs_t) dma_offset[0][channel]) << 16) |
| 407 | & 0xFF0000; |
| 408 | |
| 409 | cpuintrf_push_context(0); |
| 410 | program_write_byte(page_offset + offset, data); |
| 411 | cpuintrf_pop_context(); |
| 412 | } |
| 413 | |
| 414 | |
| 415 | static const struct dma8237_interface dma8237_1_config = |
| 416 | { |
| 417 | 0, |
| 418 | 1.0e-6, // 1us |
| 419 | |
| 420 | pc_dma_read_byte, |
| 421 | pc_dma_write_byte, |
| 422 | |
| 423 | { 0, 0, NULL, NULL }, |
| 424 | { 0, 0, NULL, NULL }, |
| 425 | NULL |
| 426 | }; |
| 427 | |
| 428 | |
| 429 | static const struct dma8237_interface dma8237_2_config = |
| 430 | { |
| 431 | 0, |
| 432 | 1.0e-6, // 1us |
| 433 | |
| 434 | NULL, |
| 435 | NULL, |
| 436 | |
| 437 | { NULL, NULL, NULL, NULL }, |
| 438 | { NULL, NULL, NULL, NULL }, |
| 439 | NULL |
| 440 | }; |
| 441 | |
| 442 | static READ32_HANDLER(at_page32_r) |
| 443 | { |
| 444 | return read32le_with_read8_handler(at_page8_r, machine, offset, mem_mask); |
| 445 | } |
| 446 | |
| 447 | |
| 448 | static WRITE32_HANDLER(at_page32_w) |
| 449 | { |
| 450 | write32le_with_write8_handler(at_page8_w, machine, offset, data, mem_mask); |
| 451 | } |
| 452 | |
| 453 | |
| 337 | 454 | DEV_READWRITE8TO32LE( gamecstl_pit8254_32le, pit8253_r, pit8253_w ) |
| 455 | DEV_READWRITE8TO32LE( gamecstl_dma8237_32le, dma8237_r, dma8237_w ) |
| 338 | 456 | |
| 339 | 457 | |
| 340 | 458 | /*****************************************************************************/ |
| r2300 | r2301 | |
| 351 | 469 | ADDRESS_MAP_END |
| 352 | 470 | |
| 353 | 471 | static ADDRESS_MAP_START(gamecstl_io, ADDRESS_SPACE_IO, 32) |
| 354 | | AM_RANGE(0x0000, 0x001f) AM_READWRITE(dma8237_32le_0_r, dma8237_32le_0_w) |
| 472 | AM_RANGE(0x0000, 0x001f) AM_DEVREADWRITE(DMA8237, "dma8237_1", gamecstl_dma8237_32le_r, gamecstl_dma8237_32le_w) |
| 355 | 473 | AM_RANGE(0x0020, 0x003f) AM_READWRITE(pic8259_32le_0_r, pic8259_32le_0_w) |
| 356 | 474 | AM_RANGE(0x0040, 0x005f) AM_DEVREADWRITE(PIT8254, "pit8254", gamecstl_pit8254_32le_r, gamecstl_pit8254_32le_w) |
| 357 | 475 | AM_RANGE(0x0060, 0x006f) AM_READWRITE(kbdc8042_32le_r, kbdc8042_32le_w) |
| 358 | 476 | AM_RANGE(0x0070, 0x007f) AM_READWRITE(mc146818_port32le_r, mc146818_port32le_w) |
| 359 | 477 | AM_RANGE(0x0080, 0x009f) AM_READWRITE(at_page32_r, at_page32_w) |
| 360 | 478 | AM_RANGE(0x00a0, 0x00bf) AM_READWRITE(pic8259_32le_1_r, pic8259_32le_1_w) |
| 361 | | AM_RANGE(0x00c0, 0x00df) AM_READWRITE(at32_dma8237_1_r, at32_dma8237_1_w) |
| 479 | AM_RANGE(0x00c0, 0x00df) AM_READWRITE(at32_dma8237_2_r, at32_dma8237_2_w) |
| 362 | 480 | AM_RANGE(0x00e8, 0x00eb) AM_NOP |
| 363 | 481 | AM_RANGE(0x01f0, 0x01f7) AM_READWRITE(ide0_r, ide0_w) |
| 364 | 482 | AM_RANGE(0x0300, 0x03af) AM_NOP |
| r2300 | r2301 | |
| 442 | 560 | { |
| 443 | 561 | memory_set_bankptr(1, memory_region(REGION_USER1) + 0x30000); |
| 444 | 562 | |
| 445 | | dma8237_reset(); |
| 446 | 563 | cpunum_set_irq_callback(0, irq_callback); |
| 447 | 564 | } |
| 448 | 565 | |
| r2300 | r2301 | |
| 482 | 599 | MDRV_DEVICE_ADD( "pit8254", PIT8254 ) |
| 483 | 600 | MDRV_DEVICE_CONFIG( gamecstl_pit8254_config ) |
| 484 | 601 | |
| 602 | MDRV_DEVICE_ADD( "dma8237_1", DMA8237 ) |
| 603 | MDRV_DEVICE_CONFIG( dma8237_1_config ) |
| 604 | |
| 605 | MDRV_DEVICE_ADD( "dma8237_2", DMA8237 ) |
| 606 | MDRV_DEVICE_CONFIG( dma8237_2_config ) |
| 607 | |
| 485 | 608 | MDRV_NVRAM_HANDLER( mc146818 ) |
| 486 | 609 | |
| 487 | 610 | /* video hardware */ |
| r2300 | r2301 | |
| 541 | 664 | { |
| 542 | 665 | bios_ram = auto_malloc(0x10000); |
| 543 | 666 | |
| 544 | | init_pc_common(PCCOMMON_KEYBOARD_AT | PCCOMMON_DMA8237_AT); |
| 667 | init_pc_common(PCCOMMON_KEYBOARD_AT); |
| 545 | 668 | mc146818_init(MC146818_STANDARD); |
| 546 | 669 | |
| 547 | 670 | intel82439tx_init(); |
src/emu/machine/8237dma.c
| r2300 | r2301 | |
| 23 | 23 | #include "memconv.h" |
| 24 | 24 | #include "8237dma.h" |
| 25 | 25 | |
| 26 | |
| 27 | typedef struct dma8237 dma8237_t; |
| 28 | |
| 26 | 29 | struct dma8237 |
| 27 | 30 | { |
| 28 | 31 | const struct dma8237_interface *intf; |
| r2300 | r2301 | |
| 48 | 51 | UINT8 status; |
| 49 | 52 | }; |
| 50 | 53 | |
| 51 | | static struct dma8237 *dma; |
| 52 | | static int dma_count; |
| 53 | 54 | |
| 54 | | |
| 55 | 55 | #define DMA_MODE_CHANNEL(mode) ((mode) & 0x03) |
| 56 | 56 | #define DMA_MODE_OPERATION(mode) (((mode) >> 2) & 0x03) |
| 57 | 57 | #define DMA_MODE_DIRECTION(mode) (((mode) & 0x20) ? -1 : +1) |
| r2300 | r2301 | |
| 61 | 61 | |
| 62 | 62 | static TIMER_CALLBACK( dma8237_timerproc ); |
| 63 | 63 | static TIMER_CALLBACK( dma8237_msbflip_timerproc ); |
| 64 | | static void dma8237_update_status(int which); |
| 64 | static void dma8237_update_status(const device_config *device); |
| 65 | 65 | |
| 66 | 66 | /* ----------------------------------------------------------------------- */ |
| 67 | 67 | |
| 68 | | int dma8237_init(int count) |
| 69 | | { |
| 70 | | int which; |
| 71 | | |
| 72 | | dma = auto_malloc(count * sizeof(struct dma8237)); |
| 73 | | memset(dma, 0, count * sizeof(struct dma8237)); |
| 74 | | dma_count = count; |
| 75 | | |
| 76 | | for (which = 0; which < dma_count; which++) |
| 77 | | { |
| 78 | | dma[which].status = 0x0F; |
| 79 | | dma[which].timer = timer_alloc(dma8237_timerproc, NULL); |
| 80 | | dma[which].msbflip_timer = timer_alloc(dma8237_msbflip_timerproc, NULL); |
| 81 | | dma[which].eop = 1; |
| 82 | | } |
| 83 | | return 0; |
| 68 | INLINE dma8237_t *get_safe_token(const device_config *device) { |
| 69 | assert( device != NULL ); |
| 70 | assert( device->token != NULL ); |
| 71 | assert( device->type == DEVICE_GET_INFO_NAME(dma8237) ); |
| 72 | return ( dma8237_t *) device->token; |
| 84 | 73 | } |
| 85 | 74 | |
| 86 | 75 | |
| 87 | | |
| 88 | | void dma8237_config(int which, const struct dma8237_interface *intf) |
| 89 | | { |
| 90 | | dma[which].intf = intf; |
| 91 | | } |
| 92 | | |
| 93 | | |
| 94 | | |
| 95 | | void dma8237_reset(void) |
| 96 | | { |
| 97 | | int which; |
| 98 | | |
| 99 | | for (which = 0; which < dma_count; which++) |
| 100 | | { |
| 101 | | dma[which].mask = 0x00; |
| 102 | | dma[which].status = 0x0F; |
| 103 | | dma[which].chan[0].mode = 0; |
| 104 | | dma[which].chan[1].mode = 0; |
| 105 | | dma[which].chan[2].mode = 0; |
| 106 | | dma[which].chan[3].mode = 0; |
| 107 | | dma8237_update_status(which); |
| 108 | | } |
| 109 | | } |
| 110 | | |
| 111 | | |
| 112 | | |
| 113 | 76 | /* ----------------------------------------------------------------------- */ |
| 114 | 77 | |
| 115 | 78 | |
| 116 | | |
| 117 | | static int dma8237_do_operation(int which, int channel) |
| 79 | static int dma8237_do_operation(const device_config *device, int channel) |
| 118 | 80 | { |
| 81 | dma8237_t *dma8237 = get_safe_token(device); |
| 119 | 82 | int done; |
| 120 | 83 | UINT8 data; |
| 121 | 84 | UINT8 mode; |
| 122 | 85 | |
| 123 | | mode = dma[which].chan[channel].mode; |
| 86 | mode = dma8237->chan[channel].mode; |
| 124 | 87 | |
| 125 | 88 | switch(DMA_MODE_OPERATION(mode)) { |
| 126 | 89 | case 1: |
| 127 | | data = dma[which].intf->channel_read_func[channel](); |
| 128 | | dma[which].intf->memory_write_func(channel, dma[which].chan[channel].address, data); |
| 90 | data = dma8237->intf->channel_read_func[channel](device); |
| 91 | dma8237->intf->memory_write_func(device, channel, dma8237->chan[channel].address, data); |
| 129 | 92 | |
| 130 | | dma[which].chan[channel].address += DMA_MODE_DIRECTION(mode); |
| 131 | | dma[which].chan[channel].count--; |
| 132 | | done = (dma[which].chan[channel].count == 0xFFFF); |
| 93 | dma8237->chan[channel].address += DMA_MODE_DIRECTION(mode); |
| 94 | dma8237->chan[channel].count--; |
| 95 | done = (dma8237->chan[channel].count == 0xFFFF); |
| 133 | 96 | break; |
| 134 | 97 | |
| 135 | 98 | case 2: |
| 136 | | data = dma[which].intf->memory_read_func(channel, dma[which].chan[channel].address); |
| 137 | | dma[which].intf->channel_write_func[channel](data); |
| 99 | data = dma8237->intf->memory_read_func(device, channel, dma8237->chan[channel].address); |
| 100 | dma8237->intf->channel_write_func[channel](device, data); |
| 138 | 101 | |
| 139 | | dma[which].chan[channel].address += DMA_MODE_DIRECTION(mode); |
| 140 | | dma[which].chan[channel].count--; |
| 141 | | done = (dma[which].chan[channel].count == 0xFFFF); |
| 102 | dma8237->chan[channel].address += DMA_MODE_DIRECTION(mode); |
| 103 | dma8237->chan[channel].count--; |
| 104 | done = (dma8237->chan[channel].count == 0xFFFF); |
| 142 | 105 | break; |
| 143 | 106 | |
| 144 | 107 | default: |
| r2300 | r2301 | |
| 152 | 115 | |
| 153 | 116 | static TIMER_CALLBACK( dma8237_timerproc ) |
| 154 | 117 | { |
| 155 | | int which = param / 4; |
| 118 | const device_config *device = ptr; |
| 119 | dma8237_t *dma8237 = get_safe_token(device); |
| 156 | 120 | int channel = param % 4; |
| 157 | 121 | int done; |
| 158 | 122 | |
| 159 | | done = dma8237_do_operation(which, channel); |
| 123 | done = dma8237_do_operation(device, channel); |
| 160 | 124 | |
| 161 | 125 | if (done) |
| 162 | 126 | { |
| 163 | | dma[which].status &= ~(0x10 << channel); |
| 164 | | dma[which].status |= (0x01 << channel); |
| 165 | | dma[which].drq &= ~(0x01 << channel); |
| 166 | | dma8237_update_status(which); |
| 127 | dma8237->status &= ~(0x10 << channel); |
| 128 | dma8237->status |= (0x01 << channel); |
| 129 | dma8237->drq &= ~(0x01 << channel); |
| 130 | dma8237_update_status(device); |
| 167 | 131 | } |
| 168 | 132 | } |
| 169 | 133 | |
| r2300 | r2301 | |
| 171 | 135 | |
| 172 | 136 | static TIMER_CALLBACK( dma8237_msbflip_timerproc ) |
| 173 | 137 | { |
| 174 | | dma[param].msb ^= 1; |
| 138 | const device_config *device = ptr; |
| 139 | dma8237_t *dma8237 = get_safe_token(device); |
| 140 | dma8237->msb ^= 1; |
| 175 | 141 | } |
| 176 | 142 | |
| 177 | 143 | |
| 178 | 144 | |
| 179 | | static void dma8237_update_status(int which) |
| 145 | static void dma8237_update_status(const device_config *device) |
| 180 | 146 | { |
| 147 | dma8237_t *dma8237 = get_safe_token(device); |
| 181 | 148 | UINT16 pending_transfer; |
| 182 | 149 | int channel; |
| 183 | 150 | UINT32 new_eop; |
| 184 | 151 | |
| 185 | | if ((dma[which].status & 0xF0) == 0) |
| 152 | if ((dma8237->status & 0xF0) == 0) |
| 186 | 153 | { |
| 187 | 154 | /* no transfer is active right now; is there a transfer pending right now? */ |
| 188 | | pending_transfer = dma[which].drq & ~dma[which].mask; |
| 155 | pending_transfer = dma8237->drq & ~dma8237->mask; |
| 189 | 156 | |
| 190 | 157 | if (pending_transfer) |
| 191 | 158 | { |
| r2300 | r2301 | |
| 193 | 160 | for (channel = 3; (pending_transfer & (1 << channel)) == 0; channel--) |
| 194 | 161 | ; |
| 195 | 162 | |
| 196 | | dma[which].status |= 0x10 << channel; |
| 197 | | dma[which].status &= ~(0x01 << channel); |
| 163 | dma8237->status |= 0x10 << channel; |
| 164 | dma8237->status &= ~(0x01 << channel); |
| 198 | 165 | |
| 199 | | timer_adjust_periodic(dma[which].timer, |
| 166 | timer_adjust_periodic(dma8237->timer, |
| 200 | 167 | attotime_zero, |
| 201 | | which * 4 + channel, |
| 202 | | double_to_attotime(dma[which].intf->bus_speed)); |
| 168 | channel, |
| 169 | double_to_attotime(dma8237->intf->bus_speed)); |
| 203 | 170 | } |
| 204 | 171 | else |
| 205 | 172 | { |
| 206 | 173 | /* no transfers active right now */ |
| 207 | | timer_reset(dma[which].timer, attotime_never); |
| 174 | timer_reset(dma8237->timer, attotime_never); |
| 208 | 175 | } |
| 209 | 176 | |
| 210 | 177 | /* set the halt line */ |
| 211 | | if (dma[which].intf && dma[which].intf->cpunum >= 0) |
| 178 | if (dma8237->intf && dma8237->intf->cpunum >= 0) |
| 212 | 179 | { |
| 213 | | cpunum_set_input_line(Machine, dma[which].intf->cpunum, INPUT_LINE_HALT, |
| 180 | cpunum_set_input_line(Machine, dma8237->intf->cpunum, INPUT_LINE_HALT, |
| 214 | 181 | pending_transfer ? ASSERT_LINE : CLEAR_LINE); |
| 215 | 182 | } |
| 216 | 183 | |
| 217 | 184 | /* set the eop line, if it has changed */ |
| 218 | | new_eop = (dma[which].status & 0x0F) == 0x0F ? 1 : 0; |
| 219 | | if (dma[which].eop != new_eop) |
| 185 | new_eop = (dma8237->status & 0x0F) == 0x0F ? 1 : 0; |
| 186 | if (dma8237->eop != new_eop) |
| 220 | 187 | { |
| 221 | | dma[which].eop = new_eop; |
| 222 | | if (dma[which].intf->out_eop_func) |
| 223 | | dma[which].intf->out_eop_func(new_eop ? ASSERT_LINE : CLEAR_LINE); |
| 188 | dma8237->eop = new_eop; |
| 189 | if (dma8237->intf->out_eop_func) |
| 190 | dma8237->intf->out_eop_func(device, new_eop ? ASSERT_LINE : CLEAR_LINE); |
| 224 | 191 | } |
| 225 | 192 | } |
| 226 | 193 | } |
| r2300 | r2301 | |
| 229 | 196 | |
| 230 | 197 | /* ----------------------------------------------------------------------- */ |
| 231 | 198 | |
| 232 | | static void dma8237_verify(int which) |
| 233 | | { |
| 234 | | } |
| 235 | 199 | |
| 236 | | |
| 237 | | |
| 238 | | static void prepare_msb_flip(int which) |
| 200 | INLINE void prepare_msb_flip(const device_config *device) |
| 239 | 201 | { |
| 240 | | timer_adjust_oneshot(dma[which].msbflip_timer, attotime_zero, which); |
| 202 | dma8237_t *dma8237 = get_safe_token(device); |
| 203 | |
| 204 | timer_adjust_oneshot(dma8237->msbflip_timer, attotime_zero, 0); |
| 241 | 205 | } |
| 242 | 206 | |
| 243 | 207 | |
| 244 | 208 | |
| 245 | | static UINT8 dma8237_read(int which, offs_t offset) |
| 209 | READ8_DEVICE_HANDLER( dma8237_r ) |
| 246 | 210 | { |
| 211 | dma8237_t *dma8237 = get_safe_token(device); |
| 247 | 212 | UINT8 data = 0xFF; |
| 248 | 213 | UINT8 mode; |
| 249 | 214 | |
| 250 | | dma8237_verify(which); |
| 251 | 215 | offset &= 0x0F; |
| 252 | 216 | |
| 253 | 217 | switch(offset) { |
| r2300 | r2301 | |
| 256 | 220 | case 4: |
| 257 | 221 | case 6: |
| 258 | 222 | /* DMA address register */ |
| 259 | | data = dma[which].chan[offset / 2].address >> (dma[which].msb ? 8 : 0); |
| 260 | | prepare_msb_flip(which); |
| 223 | data = dma8237->chan[offset / 2].address >> (dma8237->msb ? 8 : 0); |
| 224 | prepare_msb_flip(device); |
| 261 | 225 | |
| 262 | 226 | /* hack simulating refresh activity for 'ibmxt' BIOS; I do not know |
| 263 | 227 | * why this is needed; but in any case, the ibmxt driver does not load |
| 264 | 228 | * if this code is not present */ |
| 265 | | mode = dma[which].chan[0].mode; |
| 229 | mode = dma8237->chan[0].mode; |
| 266 | 230 | if ((DMA_MODE_OPERATION(mode) == 2) && (offset == 0)) |
| 267 | 231 | { |
| 268 | | dma[which].chan[0].address++; |
| 269 | | dma[which].chan[0].count--; |
| 232 | dma8237->chan[0].address++; |
| 233 | dma8237->chan[0].count--; |
| 270 | 234 | } |
| 271 | 235 | break; |
| 272 | 236 | |
| r2300 | r2301 | |
| 275 | 239 | case 5: |
| 276 | 240 | case 7: |
| 277 | 241 | /* DMA count register */ |
| 278 | | data = dma[which].chan[offset / 2].count >> (dma[which].msb ? 8 : 0); |
| 279 | | prepare_msb_flip(which); |
| 242 | data = dma8237->chan[offset / 2].count >> (dma8237->msb ? 8 : 0); |
| 243 | prepare_msb_flip(device); |
| 280 | 244 | break; |
| 281 | 245 | |
| 282 | 246 | case 8: |
| 283 | 247 | /* DMA status register */ |
| 284 | | data = (UINT8) dma[which].status; |
| 248 | data = (UINT8) dma8237->status; |
| 285 | 249 | break; |
| 286 | 250 | |
| 287 | 251 | case 10: |
| 288 | 252 | /* DMA mask register */ |
| 289 | | data = dma[which].mask; |
| 253 | data = dma8237->mask; |
| 290 | 254 | break; |
| 291 | 255 | |
| 292 | 256 | case 13: |
| 293 | 257 | /* DMA master clear */ |
| 294 | | data = dma[which].temp; |
| 258 | data = dma8237->temp; |
| 295 | 259 | break; |
| 296 | 260 | |
| 297 | 261 | case 9: /* DMA write request register */ |
| r2300 | r2301 | |
| 307 | 271 | |
| 308 | 272 | |
| 309 | 273 | |
| 310 | | static void dma8237_write(int which, offs_t offset, UINT8 data) |
| 274 | WRITE8_DEVICE_HANDLER( dma8237_w ) |
| 311 | 275 | { |
| 276 | dma8237_t *dma8237 = get_safe_token(device); |
| 312 | 277 | int channel; |
| 313 | 278 | |
| 314 | | dma8237_verify(which); |
| 315 | 279 | offset &= 0x0F; |
| 316 | 280 | |
| 317 | 281 | switch(offset) { |
| r2300 | r2301 | |
| 320 | 284 | case 4: |
| 321 | 285 | case 6: |
| 322 | 286 | /* DMA address register */ |
| 323 | | if (dma[which].msb) |
| 324 | | dma[which].chan[offset / 2].address |= ((UINT16) data) << 8; |
| 287 | if (dma8237->msb) |
| 288 | dma8237->chan[offset / 2].address |= ((UINT16) data) << 8; |
| 325 | 289 | else |
| 326 | | dma[which].chan[offset / 2].address = data; |
| 327 | | prepare_msb_flip(which); |
| 290 | dma8237->chan[offset / 2].address = data; |
| 291 | prepare_msb_flip(device); |
| 328 | 292 | break; |
| 329 | 293 | |
| 330 | 294 | case 1: |
| r2300 | r2301 | |
| 332 | 296 | case 5: |
| 333 | 297 | case 7: |
| 334 | 298 | /* DMA count register */ |
| 335 | | if (dma[which].msb) |
| 336 | | dma[which].chan[offset / 2].count |= ((UINT16) data) << 8; |
| 299 | if (dma8237->msb) |
| 300 | dma8237->chan[offset / 2].count |= ((UINT16) data) << 8; |
| 337 | 301 | else |
| 338 | | dma[which].chan[offset / 2].count = data; |
| 339 | | prepare_msb_flip(which); |
| 302 | dma8237->chan[offset / 2].count = data; |
| 303 | prepare_msb_flip(device); |
| 340 | 304 | break; |
| 341 | 305 | |
| 342 | 306 | case 8: |
| 343 | 307 | /* DMA command register */ |
| 344 | | dma[which].command = data; |
| 308 | dma8237->command = data; |
| 345 | 309 | break; |
| 346 | 310 | |
| 347 | 311 | case 10: |
| 348 | 312 | /* DMA mask register */ |
| 349 | 313 | channel = DMA_MODE_CHANNEL(data); |
| 350 | 314 | if (data & 0x04) |
| 351 | | dma[which].mask |= 0x11 << channel; |
| 315 | dma8237->mask |= 0x11 << channel; |
| 352 | 316 | else |
| 353 | | dma[which].mask &= ~(0x11 << channel); |
| 317 | dma8237->mask &= ~(0x11 << channel); |
| 354 | 318 | break; |
| 355 | 319 | |
| 356 | 320 | case 11: |
| 357 | 321 | /* DMA mode register */ |
| 358 | 322 | channel = DMA_MODE_CHANNEL(data); |
| 359 | | dma[which].chan[channel].mode = data; |
| 323 | dma8237->chan[channel].mode = data; |
| 360 | 324 | break; |
| 361 | 325 | |
| 362 | 326 | case 12: |
| 363 | 327 | /* DMA clear byte pointer flip-flop */ |
| 364 | | dma[which].temp = data; |
| 365 | | dma[which].msb = 0; |
| 328 | dma8237->temp = data; |
| 329 | dma8237->msb = 0; |
| 366 | 330 | break; |
| 367 | 331 | |
| 368 | 332 | case 13: |
| 369 | 333 | /* DMA master clear */ |
| 370 | | dma[which].msb = 0; |
| 334 | dma8237->msb = 0; |
| 371 | 335 | break; |
| 372 | 336 | |
| 373 | 337 | case 14: |
| 374 | 338 | /* DMA clear mask register */ |
| 375 | | dma[which].mask &= ~data; |
| 376 | | dma8237_update_status(which); |
| 339 | dma8237->mask &= ~data; |
| 340 | dma8237_update_status(device); |
| 377 | 341 | break; |
| 378 | 342 | |
| 379 | 343 | case 15: |
| 380 | 344 | /* DMA write mask register */ |
| 381 | | dma[which].mask |= data; |
| 345 | dma8237->mask |= data; |
| 382 | 346 | break; |
| 383 | 347 | } |
| 384 | 348 | } |
| 385 | 349 | |
| 386 | 350 | |
| 387 | 351 | |
| 388 | | static void dma8237_drq_write_callback(int param) |
| 352 | static void dma8237_drq_write_callback(const device_config *device, int param) |
| 389 | 353 | { |
| 390 | | int which = param >> 3; |
| 354 | dma8237_t *dma8237 = get_safe_token(device); |
| 391 | 355 | int channel = (param >> 1) & 0x03; |
| 392 | 356 | int state = param & 0x01; |
| 393 | 357 | |
| 394 | 358 | /* normalize state */ |
| 395 | 359 | if (state) |
| 396 | | dma[which].drq |= 0x01 << channel; |
| 360 | dma8237->drq |= 0x01 << channel; |
| 397 | 361 | else |
| 398 | | dma[which].drq &= ~(0x01 << channel); |
| 362 | dma8237->drq &= ~(0x01 << channel); |
| 399 | 363 | |
| 400 | | dma8237_update_status(which); |
| 364 | dma8237_update_status(device); |
| 401 | 365 | } |
| 402 | 366 | |
| 403 | 367 | |
| 404 | 368 | |
| 405 | | void dma8237_drq_write(int which, int channel, int state) |
| 369 | void dma8237_drq_write(const device_config *device, int channel, int state) |
| 406 | 370 | { |
| 407 | | int param; |
| 408 | | |
| 409 | | param = (which << 3) | (channel << 1) | (state ? 1 : 0); |
| 371 | int param = (channel << 1) | (state ? 1 : 0); |
| 410 | 372 | //timer_call_after_resynch(NULL, param, dma8237_drq_write_callback); |
| 411 | | dma8237_drq_write_callback(param); |
| 373 | dma8237_drq_write_callback(device, param); |
| 412 | 374 | } |
| 413 | 375 | |
| 414 | 376 | |
| 415 | 377 | |
| 416 | 378 | /******************* Unfortunate hacks *******************/ |
| 417 | 379 | |
| 418 | | void dma8237_run_transfer(int which, int channel) |
| 380 | void dma8237_run_transfer(const device_config *device, int channel) |
| 419 | 381 | { |
| 420 | | dma[which].status |= 0x10 << channel; /* reset DMA running flag */ |
| 382 | dma8237_t *dma8237 = get_safe_token(device); |
| 421 | 383 | |
| 422 | | while(!dma8237_do_operation(which, channel)) |
| 384 | dma8237->status |= 0x10 << channel; /* reset DMA running flag */ |
| 385 | |
| 386 | while(!dma8237_do_operation(device, channel)) |
| 423 | 387 | ; |
| 424 | 388 | |
| 425 | | dma[which].status &= ~(0x10 << channel); |
| 426 | | dma[which].status |= (0x01 << channel); |
| 389 | dma8237->status &= ~(0x10 << channel); |
| 390 | dma8237->status |= (0x01 << channel); |
| 427 | 391 | } |
| 428 | 392 | |
| 429 | 393 | |
| 430 | 394 | |
| 431 | | /******************* Standard 8-bit/32-bit/64-bit CPU interfaces *******************/ |
| 395 | static DEVICE_START( dma8237 ) { |
| 396 | dma8237_t *dma8237 = get_safe_token(device); |
| 432 | 397 | |
| 433 | | READ8_HANDLER( dma8237_0_r ) { return dma8237_read(0, offset); } |
| 434 | | READ8_HANDLER( dma8237_1_r ) { return dma8237_read(1, offset); } |
| 435 | | WRITE8_HANDLER( dma8237_0_w ) { dma8237_write(0, offset, data); } |
| 436 | | WRITE8_HANDLER( dma8237_1_w ) { dma8237_write(1, offset, data); } |
| 398 | dma8237->intf = device->static_config; |
| 399 | } |
| 437 | 400 | |
| 438 | | READ16_HANDLER( dma8237_16le_0_r ) { return read16le_with_read8_handler(dma8237_0_r, machine, offset, mem_mask); } |
| 439 | | READ16_HANDLER( dma8237_16le_1_r ) { return read16le_with_read8_handler(dma8237_1_r, machine, offset, mem_mask); } |
| 440 | | WRITE16_HANDLER( dma8237_16le_0_w ) { write16le_with_write8_handler(dma8237_0_w, machine, offset, data, mem_mask); } |
| 441 | | WRITE16_HANDLER( dma8237_16le_1_w ) { write16le_with_write8_handler(dma8237_1_w, machine, offset, data, mem_mask); } |
| 442 | 401 | |
| 443 | | READ32_HANDLER( dma8237_32le_0_r ) { return read32le_with_read8_handler(dma8237_0_r, machine, offset, mem_mask); } |
| 444 | | READ32_HANDLER( dma8237_32le_1_r ) { return read32le_with_read8_handler(dma8237_1_r, machine, offset, mem_mask); } |
| 445 | | WRITE32_HANDLER( dma8237_32le_0_w ) { write32le_with_write8_handler(dma8237_0_w, machine, offset, data, mem_mask); } |
| 446 | | WRITE32_HANDLER( dma8237_32le_1_w ) { write32le_with_write8_handler(dma8237_1_w, machine, offset, data, mem_mask); } |
| 402 | static DEVICE_RESET( dma8237 ) { |
| 403 | dma8237_t *dma8237 = get_safe_token(device); |
| 447 | 404 | |
| 448 | | READ64_HANDLER( dma8237_64be_0_r ) { return read64be_with_read8_handler(dma8237_0_r, machine, offset, mem_mask); } |
| 449 | | READ64_HANDLER( dma8237_64be_1_r ) { return read64be_with_read8_handler(dma8237_1_r, machine, offset, mem_mask); } |
| 450 | | WRITE64_HANDLER( dma8237_64be_0_w ) { write64be_with_write8_handler(dma8237_0_w, machine, offset, data, mem_mask); } |
| 451 | | WRITE64_HANDLER( dma8237_64be_1_w ) { write64be_with_write8_handler(dma8237_1_w, machine, offset, data, mem_mask); } |
| 405 | dma8237->status = 0x0F; |
| 406 | dma8237->timer = timer_alloc(dma8237_timerproc, (void *)device); |
| 407 | dma8237->msbflip_timer = timer_alloc(dma8237_msbflip_timerproc, (void *)device); |
| 408 | dma8237->eop = 1; |
| 409 | |
| 410 | dma8237->mask = 0x00; |
| 411 | dma8237->status = 0x0F; |
| 412 | dma8237->chan[0].mode = 0; |
| 413 | dma8237->chan[1].mode = 0; |
| 414 | dma8237->chan[2].mode = 0; |
| 415 | dma8237->chan[3].mode = 0; |
| 416 | |
| 417 | dma8237_update_status(device); |
| 418 | } |
| 419 | |
| 420 | |
| 421 | static DEVICE_SET_INFO( dma8237 ) { |
| 422 | switch ( state ) { |
| 423 | /* no parameters to set */ |
| 424 | } |
| 425 | } |
| 426 | |
| 427 | |
| 428 | DEVICE_GET_INFO( dma8237 ) { |
| 429 | switch ( state ) { |
| 430 | /* --- the following bits of info are returned as 64-bit signed integers --- */ |
| 431 | case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(dma8237_t); break; |
| 432 | case DEVINFO_INT_INLINE_CONFIG_BYTES: info->i = 0; break; |
| 433 | case DEVINFO_INT_CLASS: info->i = DEVICE_CLASS_PERIPHERAL; break; |
| 434 | |
| 435 | /* --- the following bits of info are returned as pointers to data or functions --- */ |
| 436 | case DEVINFO_FCT_SET_INFO: info->set_info = DEVICE_SET_INFO_NAME(dma8237); break; |
| 437 | case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(dma8237); break; |
| 438 | case DEVINFO_FCT_STOP: /* nothing */ break; |
| 439 | case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(dma8237); break; |
| 440 | |
| 441 | /* --- the following bits of info are returned as NULL-terminated strings --- */ |
| 442 | case DEVINFO_STR_NAME: info->s = "Intel DMA8237"; break; |
| 443 | case DEVINFO_STR_FAMILY: info->s = "DMA8237"; break; |
| 444 | case DEVINFO_STR_VERSION: info->s = "1.00"; break; |
| 445 | case DEVINFO_STR_SOURCE_FILE: info->s = __FILE__; break; |
| 446 | case DEVINFO_STR_CREDITS: info->s = "Copyright the MAME and MESS Teams"; break; |
| 447 | } |
| 448 | } |
| 449 | |
src/emu/machine/8237dma.h
| r2300 | r2301 | |
| 4 | 4 | |
| 5 | 5 | **********************************************************************/ |
| 6 | 6 | |
| 7 | | #ifndef DMA8237_H |
| 8 | | #define DMA8237_H |
| 7 | #ifndef __DMA8237_H_ |
| 8 | #define __DMA8237_H_ |
| 9 | 9 | |
| 10 | #define DMA8237 DEVICE_GET_INFO_NAME(dma8237) |
| 11 | |
| 12 | typedef UINT8 (*dma8237_mem_read_func)(const device_config *device, int channel, offs_t offset); |
| 13 | typedef void (*dma8237_mem_write_func)(const device_config *device, int channel, offs_t offset, UINT8 data); |
| 14 | typedef int (*dma8237_channel_read_func)(const device_config *device); |
| 15 | typedef void (*dma8237_channel_write_func)(const device_config *device, int data); |
| 16 | typedef void (*dma8237_out_eop_func)(const device_config *device, int state); |
| 17 | |
| 18 | #define DMA8237_MEM_READ(name) UINT8 name(const device_config *device, int channel, offs_t offset) |
| 19 | #define DMA8237_MEM_WRITE(name) void name(const device_config *device, int channel, offs_t offset, UINT8 data) |
| 20 | #define DMA8237_CHANNEL_READ(name) int name(const device_config *device) |
| 21 | #define DMA8237_CHANNEL_WRITE(name) void name(const device_config *device, int data) |
| 22 | #define DMA8237_OUT_EOP(name) void name(const device_config *device, int state) |
| 23 | |
| 10 | 24 | struct dma8237_interface |
| 11 | 25 | { |
| 12 | 26 | /* CPU to halt when DMA is active */ |
| r2300 | r2301 | |
| 16 | 30 | double bus_speed; |
| 17 | 31 | |
| 18 | 32 | /* accessors to main memory */ |
| 19 | | UINT8 (*memory_read_func)(int channel, offs_t offset); |
| 20 | | void (*memory_write_func)(int channel, offs_t offset, UINT8 data); |
| 33 | dma8237_mem_read_func memory_read_func; |
| 34 | dma8237_mem_write_func memory_write_func; |
| 21 | 35 | |
| 22 | 36 | /* channel accesors */ |
| 23 | | int (*channel_read_func[4])(void); |
| 24 | | void (*channel_write_func[4])(int data); |
| 37 | dma8237_channel_read_func channel_read_func[4]; |
| 38 | dma8237_channel_write_func channel_write_func[4]; |
| 25 | 39 | |
| 26 | 40 | /* function to call when DMA completes */ |
| 27 | | void (*out_eop_func)(int state); |
| 41 | dma8237_out_eop_func out_eop_func; |
| 28 | 42 | }; |
| 29 | 43 | |
| 30 | 44 | |
| 45 | /* device interface */ |
| 46 | DEVICE_GET_INFO( dma8237 ); |
| 47 | READ8_DEVICE_HANDLER( dma8237_r ); |
| 48 | WRITE8_DEVICE_HANDLER( dma8237_w ); |
| 49 | void dma8237_drq_write(const device_config *device, int channel, int state); |
| 31 | 50 | |
| 32 | | int dma8237_init(int count); |
| 33 | | void dma8237_config(int which, const struct dma8237_interface *intf); |
| 34 | | void dma8237_reset(void); |
| 35 | | |
| 36 | | void dma8237_drq_write(int which, int channel, int state); |
| 37 | | |
| 38 | 51 | /* unfortunate hack for the interim for PC HDC */ |
| 39 | | void dma8237_run_transfer(int which, int channel); |
| 52 | void dma8237_run_transfer(const device_config *device, int channel); |
| 40 | 53 | |
| 41 | | READ8_HANDLER( dma8237_0_r ); |
| 42 | | READ8_HANDLER( dma8237_1_r ); |
| 43 | | WRITE8_HANDLER( dma8237_0_w ); |
| 44 | | WRITE8_HANDLER( dma8237_1_w ); |
| 45 | | |
| 46 | | READ16_HANDLER( dma8237_16le_0_r ); |
| 47 | | READ16_HANDLER( dma8237_16le_1_r ); |
| 48 | | WRITE16_HANDLER( dma8237_16le_0_w ); |
| 49 | | WRITE16_HANDLER( dma8237_16le_1_w ); |
| 50 | | |
| 51 | | READ32_HANDLER( dma8237_32le_0_r ); |
| 52 | | READ32_HANDLER( dma8237_32le_1_r ); |
| 53 | | WRITE32_HANDLER( dma8237_32le_0_w ); |
| 54 | | WRITE32_HANDLER( dma8237_32le_1_w ); |
| 55 | | |
| 56 | | READ64_HANDLER( dma8237_64be_0_r ); |
| 57 | | READ64_HANDLER( dma8237_64be_1_r ); |
| 58 | | WRITE64_HANDLER( dma8237_64be_0_w ); |
| 59 | | WRITE64_HANDLER( dma8237_64be_1_w ); |
| 60 | | |
| 61 | | #endif /* DMA8237_H */ |
| 54 | #endif /* __DMA8237_H_ */ |