Previous 15994 Revisions Next

r2301 Sunday 6th April, 2008 at 14:13:17 UTC by Wilbert Pol
Changed 8237 dma implementation into a device. Also submitted to mamedev.
[src/emu/machine]8237dma.c 8237dma.h
[src/mame/drivers]gamecstl.c mediagx.c taitowlf.c
[src/mame/machine]pcshare.c pcshare.h

src/mame/machine/pcshare.c
r2300r2301
3333#include "machine/8237dma.h"
3434#include "machine/pckeybrd.h"
3535
36#ifdef MESS
37#include "machine/pc_fdc.h"
38#include "machine/pc_hdc.h"
39#endif /* MESS */
40
4136#define VERBOSE_DBG 0       /* general debug messages */
4237#define DBG_LOG(N,M,A) \
4338   if(VERBOSE_DBG>=N){ if( M )logerror("%11.6f: %-24s",attotime_to_double(timer_get_time()),(char*)M ); logerror A; }
r2300r2301
5146
5247static TIMER_CALLBACK( pc_keyb_timer );
5348
54#define LOG_PORT80 0
5549
56
57/*************************************************************************
58 *
59 *      PC DMA stuff
60 *
61 *************************************************************************/
62
63static UINT8 dma_offset[2][4];
64static UINT8 at_pages[0x10];
65static offs_t pc_page_offset_mask;
66
67
68
69READ8_HANDLER(pc_page_r)
70{
71   return 0xFF;
72}
73
74
75
76WRITE8_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
93READ16_HANDLER(pc_page16le_r) { return read16le_with_read8_handler(pc_page_r, machine, offset, mem_mask); }
94WRITE16_HANDLER(pc_page16le_w) { write16le_with_write8_handler(pc_page_w, machine, offset, data, mem_mask); }
95
96
97
98READ8_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
121WRITE8_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
146READ32_HANDLER(at_page32_r)
147{
148   return read32le_with_read8_handler(at_page8_r, machine, offset, mem_mask);
149}
150
151
152
153WRITE32_HANDLER(at_page32_w)
154{
155   write32le_with_write8_handler(at_page8_w, machine, offset, data, mem_mask);
156}
157
158
159
160static 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
175static 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
187static 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
20850/* ----------------------------------------------------------------------- */
20951
21052static void pc_pic_set_int_line(int which, int interrupt)
r2300r2301
23779   /* PIC */
23880   pic8259_init(2, pc_pic_set_int_line);
23981
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
25482   pc_keyboard_timer = timer_alloc(pc_keyb_timer, NULL);
25583}
25684
src/mame/machine/pcshare.h
r2300r2301
33/* flags for init_pc_common */
44#define PCCOMMON_KEYBOARD_PC   0
55#define PCCOMMON_KEYBOARD_AT   1
6#define PCCOMMON_DMA8237_PC      0
7#define PCCOMMON_DMA8237_AT      2
8#define PCCOMMON_NEC765_RDY_NC   16
96
107void init_pc_common(UINT32 flags);
118
r2300r2301
1411void pc_keyb_set_clock(int on);
1512void pc_keyb_clear(void);
1613
17READ8_HANDLER(pc_page_r);
18WRITE8_HANDLER(pc_page_w);
19
20READ16_HANDLER(pc_page16le_r);
21WRITE16_HANDLER(pc_page16le_w);
22
23READ8_HANDLER(at_page8_r);
24WRITE8_HANDLER(at_page8_w);
25
26READ32_HANDLER(at_page32_r);
27WRITE32_HANDLER(at_page32_w);
src/mame/drivers/mediagx.c
r2300r2301
349349}
350350
351351
352static READ8_HANDLER(at_dma8237_1_r)
352static READ8_HANDLER(at_dma8237_2_r)
353353{
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);
355355}
356356
357static WRITE8_HANDLER(at_dma8237_1_w)
357static WRITE8_HANDLER(at_dma8237_2_w)
358358{
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);
360360}
361361
362static READ32_HANDLER(at32_dma8237_1_r)
362static READ32_HANDLER(at32_dma8237_2_r)
363363{
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);
365365}
366366
367static WRITE32_HANDLER(at32_dma8237_1_w)
367static WRITE32_HANDLER(at32_dma8237_2_w)
368368{
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);
370370}
371371
372372
r2300r2301
719719   }
720720}
721721
722
723/*************************************************************************
724 *
725 *      PC DMA stuff
726 *
727 *************************************************************************/
728
729static UINT8 dma_offset[2][4];
730static UINT8 at_pages[0x10];
731
732
733static 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
755static 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
776static 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
790static 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
801static 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
815static 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
828static READ32_HANDLER(at_page32_r)
829{
830   return read32le_with_read8_handler(at_page8_r, machine, offset, mem_mask);
831}
832
833
834static WRITE32_HANDLER(at_page32_w)
835{
836   write32le_with_write8_handler(at_page8_w, machine, offset, data, mem_mask);
837}
838
839
722840DEV_READWRITE8TO32LE( mediagx_pit8254_32le, pit8253_r, pit8253_w )
841DEV_READWRITE8TO32LE( mediagx_dma8237_32le, dma8237_r, dma8237_w )
723842
724843
725844/*****************************************************************************/
r2300r2301
738857ADDRESS_MAP_END
739858
740859static 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)
742861   AM_RANGE(0x0020, 0x0023) AM_READWRITE(io20_r, io20_w)
743862   AM_RANGE(0x0040, 0x005f) AM_DEVREADWRITE(PIT8254, "pit8254", mediagx_pit8254_32le_r, mediagx_pit8254_32le_w)
744863   AM_RANGE(0x0060, 0x006f) AM_READWRITE(kbdc8042_32le_r,         kbdc8042_32le_w)
745864   AM_RANGE(0x0070, 0x007f) AM_READWRITE(mc146818_port32le_r,      mc146818_port32le_w)
746865   AM_RANGE(0x0080, 0x009f) AM_READWRITE(at_page32_r,            at_page32_w)
747866   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)
749868   AM_RANGE(0x00e8, 0x00eb) AM_NOP      // I/O delay port
750869   AM_RANGE(0x01f0, 0x01f7) AM_READWRITE(ide0_r, ide0_w)
751870   AM_RANGE(0x0378, 0x037b) AM_READWRITE(parallel_port_r, parallel_port_w)
r2300r2301
849968{
850969   UINT8 *rom = memory_region(REGION_USER1);
851970
852   dma8237_reset();
853971   cpunum_set_irq_callback(0, irq_callback);
854972
855973   memcpy(bios_ram, rom, 0x40000);
r2300r2301
9021020   MDRV_DEVICE_ADD( "pit8254", PIT8254 )
9031021   MDRV_DEVICE_CONFIG( mediagx_pit8254_config )
9041022
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
9051029   MDRV_NVRAM_HANDLER( mc146818 )
9061030
9071031    /* video hardware */
r2300r2301
9601084
9611085static void init_mediagx(running_machine *machine)
9621086{
963   init_pc_common(PCCOMMON_KEYBOARD_AT | PCCOMMON_DMA8237_AT);
1087   init_pc_common(PCCOMMON_KEYBOARD_AT);
9641088   mc146818_init(MC146818_STANDARD);
9651089
9661090   pci_init();
src/mame/drivers/taitowlf.c
r2300r2301
8585   return 0;
8686}
8787
88static READ8_HANDLER(at_dma8237_1_r)
88static READ8_HANDLER(at_dma8237_2_r)
8989{
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);
9191}
9292
93static WRITE8_HANDLER(at_dma8237_1_w)
93static WRITE8_HANDLER(at_dma8237_2_w)
9494{
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);
9696}
9797
98static READ32_HANDLER(at32_dma8237_1_r)
98static READ32_HANDLER(at32_dma8237_2_r)
9999{
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);
101101}
102102
103static WRITE32_HANDLER(at32_dma8237_1_w)
103static WRITE32_HANDLER(at32_dma8237_2_w)
104104{
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);
106106}
107107
108108
r2300r2301
300300}
301301
302302
303/*************************************************************************
304 *
305 *      PC DMA stuff
306 *
307 *************************************************************************/
308
309static UINT8 dma_offset[2][4];
310static UINT8 at_pages[0x10];
311
312
313static 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
335static 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
356static 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
370static 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
381static 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
395static 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
408static READ32_HANDLER(at_page32_r)
409{
410   return read32le_with_read8_handler(at_page8_r, machine, offset, mem_mask);
411}
412
413
414static WRITE32_HANDLER(at_page32_w)
415{
416   write32le_with_write8_handler(at_page8_w, machine, offset, data, mem_mask);
417}
418
419
303420DEV_READWRITE8TO32LE( taitowlf_pit8254_32le, pit8253_r, pit8253_w )
421DEV_READWRITE8TO32LE( taitowlf_dma8237_32le, dma8237_r, dma8237_w )
304422
305423
306424/*****************************************************************************/
r2300r2301
317435ADDRESS_MAP_END
318436
319437static 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)
321439   AM_RANGE(0x0020, 0x003f) AM_READWRITE(pic8259_32le_0_r,         pic8259_32le_0_w)
322440   AM_RANGE(0x0040, 0x005f) AM_DEVREADWRITE(PIT8254, "pit8254", taitowlf_pit8254_32le_r, taitowlf_pit8254_32le_w)
323441   AM_RANGE(0x0060, 0x006f) AM_READWRITE(kbdc8042_32le_r,         kbdc8042_32le_w)
324442   AM_RANGE(0x0070, 0x007f) AM_READWRITE(mc146818_port32le_r,      mc146818_port32le_w)
325443   AM_RANGE(0x0080, 0x009f) AM_READWRITE(at_page32_r,            at_page32_w)
326444   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)
328446   AM_RANGE(0x00e8, 0x00eb) AM_NOP
329447   AM_RANGE(0x01f0, 0x01f7) AM_READWRITE(ide0_r, ide0_w)
330448   AM_RANGE(0x0300, 0x03af) AM_NOP
r2300r2301
408526{
409527   memory_set_bankptr(1, memory_region(REGION_USER1) + 0x30000);
410528
411   dma8237_reset();
412529   cpunum_set_irq_callback(0, irq_callback);
413530}
414531
r2300r2301
448565   MDRV_DEVICE_ADD( "pit8254", PIT8254 )
449566   MDRV_DEVICE_CONFIG( taitowlf_pit8254_config )
450567
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
451574   MDRV_NVRAM_HANDLER( mc146818 )
452575
453576    /* video hardware */
r2300r2301
507630{
508631   bios_ram = auto_malloc(0x10000);
509632
510   init_pc_common(PCCOMMON_KEYBOARD_AT | PCCOMMON_DMA8237_AT);
633   init_pc_common(PCCOMMON_KEYBOARD_AT);
511634   mc146818_init(MC146818_STANDARD);
512635
513636   intel82439tx_init();
src/mame/drivers/gamecstl.c
r2300r2301
119119   return 0;
120120}
121121
122static READ8_HANDLER(at_dma8237_1_r)
122static READ8_HANDLER(at_dma8237_2_r)
123123{
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);
125125}
126126
127static WRITE8_HANDLER(at_dma8237_1_w)
127static WRITE8_HANDLER(at_dma8237_2_w)
128128{
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);
130130}
131131
132static READ32_HANDLER(at32_dma8237_1_r)
132static READ32_HANDLER(at32_dma8237_2_r)
133133{
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);
135135}
136136
137static WRITE32_HANDLER(at32_dma8237_1_w)
137static WRITE32_HANDLER(at32_dma8237_2_w)
138138{
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);
140140}
141141
142142
r2300r2301
334334}
335335
336336
337/*************************************************************************
338 *
339 *      PC DMA stuff
340 *
341 *************************************************************************/
342
343static UINT8 dma_offset[2][4];
344static UINT8 at_pages[0x10];
345
346
347static 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
369static 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
390static 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
404static 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
415static 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
429static 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
442static READ32_HANDLER(at_page32_r)
443{
444   return read32le_with_read8_handler(at_page8_r, machine, offset, mem_mask);
445}
446
447
448static WRITE32_HANDLER(at_page32_w)
449{
450   write32le_with_write8_handler(at_page8_w, machine, offset, data, mem_mask);
451}
452
453
337454DEV_READWRITE8TO32LE( gamecstl_pit8254_32le, pit8253_r, pit8253_w )
455DEV_READWRITE8TO32LE( gamecstl_dma8237_32le, dma8237_r, dma8237_w )
338456
339457
340458/*****************************************************************************/
r2300r2301
351469ADDRESS_MAP_END
352470
353471static 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)
355473   AM_RANGE(0x0020, 0x003f) AM_READWRITE(pic8259_32le_0_r,         pic8259_32le_0_w)
356474   AM_RANGE(0x0040, 0x005f) AM_DEVREADWRITE(PIT8254, "pit8254", gamecstl_pit8254_32le_r, gamecstl_pit8254_32le_w)
357475   AM_RANGE(0x0060, 0x006f) AM_READWRITE(kbdc8042_32le_r,         kbdc8042_32le_w)
358476   AM_RANGE(0x0070, 0x007f) AM_READWRITE(mc146818_port32le_r,      mc146818_port32le_w)
359477   AM_RANGE(0x0080, 0x009f) AM_READWRITE(at_page32_r,            at_page32_w)
360478   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)
362480   AM_RANGE(0x00e8, 0x00eb) AM_NOP
363481   AM_RANGE(0x01f0, 0x01f7) AM_READWRITE(ide0_r, ide0_w)
364482   AM_RANGE(0x0300, 0x03af) AM_NOP
r2300r2301
442560{
443561   memory_set_bankptr(1, memory_region(REGION_USER1) + 0x30000);
444562
445   dma8237_reset();
446563   cpunum_set_irq_callback(0, irq_callback);
447564}
448565
r2300r2301
482599   MDRV_DEVICE_ADD( "pit8254", PIT8254 )
483600   MDRV_DEVICE_CONFIG( gamecstl_pit8254_config )
484601
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
485608   MDRV_NVRAM_HANDLER( mc146818 )
486609
487610    /* video hardware */
r2300r2301
541664{
542665   bios_ram = auto_malloc(0x10000);
543666
544   init_pc_common(PCCOMMON_KEYBOARD_AT | PCCOMMON_DMA8237_AT);
667   init_pc_common(PCCOMMON_KEYBOARD_AT);
545668   mc146818_init(MC146818_STANDARD);
546669
547670   intel82439tx_init();
src/emu/machine/8237dma.c
r2300r2301
2323#include "memconv.h"
2424#include "8237dma.h"
2525
26
27typedef struct dma8237   dma8237_t;
28
2629struct dma8237
2730{
2831   const struct dma8237_interface *intf;
r2300r2301
4851   UINT8 status;
4952};
5053
51static struct dma8237 *dma;
52static int dma_count;
5354
54
5555#define DMA_MODE_CHANNEL(mode)      ((mode) & 0x03)
5656#define DMA_MODE_OPERATION(mode)   (((mode) >> 2) & 0x03)
5757#define DMA_MODE_DIRECTION(mode)   (((mode) & 0x20) ? -1 : +1)
r2300r2301
6161
6262static TIMER_CALLBACK( dma8237_timerproc );
6363static TIMER_CALLBACK( dma8237_msbflip_timerproc );
64static void dma8237_update_status(int which);
64static void dma8237_update_status(const device_config *device);
6565
6666/* ----------------------------------------------------------------------- */
6767
68int 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;
68INLINE 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;
8473}
8574
8675
87
88void dma8237_config(int which, const struct dma8237_interface *intf)
89{
90   dma[which].intf = intf;
91}
92
93
94
95void 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
11376/* ----------------------------------------------------------------------- */
11477
11578
116
117static int dma8237_do_operation(int which, int channel)
79static int dma8237_do_operation(const device_config *device, int channel)
11880{
81   dma8237_t   *dma8237 = get_safe_token(device);
11982   int done;
12083   UINT8 data;
12184   UINT8 mode;
12285
123   mode = dma[which].chan[channel].mode;
86   mode = dma8237->chan[channel].mode;
12487
12588   switch(DMA_MODE_OPERATION(mode)) {
12689   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);
12992
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);
13396      break;
13497
13598   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);
138101
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);
142105      break;
143106
144107   default:
r2300r2301
152115
153116static TIMER_CALLBACK( dma8237_timerproc )
154117{
155   int which = param / 4;
118   const device_config *device = ptr;
119   dma8237_t   *dma8237 = get_safe_token(device);
156120   int channel = param % 4;
157121   int done;
158122
159   done = dma8237_do_operation(which, channel);
123   done = dma8237_do_operation(device, channel);
160124
161125   if (done)
162126   {
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);
167131   }
168132}
169133
r2300r2301
171135
172136static TIMER_CALLBACK( dma8237_msbflip_timerproc )
173137{
174   dma[param].msb ^= 1;
138   const device_config *device = ptr;
139   dma8237_t   *dma8237 = get_safe_token(device);
140   dma8237->msb ^= 1;
175141}
176142
177143
178144
179static void dma8237_update_status(int which)
145static void dma8237_update_status(const device_config *device)
180146{
147   dma8237_t   *dma8237 = get_safe_token(device);
181148   UINT16 pending_transfer;
182149   int channel;
183150   UINT32 new_eop;
184151
185   if ((dma[which].status & 0xF0) == 0)
152   if ((dma8237->status & 0xF0) == 0)
186153   {
187154      /* 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;
189156
190157      if (pending_transfer)
191158      {
r2300r2301
193160         for (channel = 3; (pending_transfer & (1 << channel)) == 0; channel--)
194161            ;
195162
196         dma[which].status |= 0x10 << channel;
197         dma[which].status &= ~(0x01 << channel);
163         dma8237->status |= 0x10 << channel;
164         dma8237->status &= ~(0x01 << channel);
198165
199         timer_adjust_periodic(dma[which].timer,
166         timer_adjust_periodic(dma8237->timer,
200167            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));
203170      }
204171      else
205172      {
206173         /* no transfers active right now */
207         timer_reset(dma[which].timer, attotime_never);
174         timer_reset(dma8237->timer, attotime_never);
208175      }
209176
210177      /* set the halt line */
211      if (dma[which].intf && dma[which].intf->cpunum >= 0)
178      if (dma8237->intf && dma8237->intf->cpunum >= 0)
212179      {
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,
214181            pending_transfer ? ASSERT_LINE : CLEAR_LINE);
215182      }
216183
217184      /* 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)
220187      {
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);
224191      }
225192   }
226193}
r2300r2301
229196
230197/* ----------------------------------------------------------------------- */
231198
232static void dma8237_verify(int which)
233{
234}
235199
236
237
238static void prepare_msb_flip(int which)
200INLINE void prepare_msb_flip(const device_config *device)
239201{
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);
241205}
242206
243207
244208
245static UINT8 dma8237_read(int which, offs_t offset)
209READ8_DEVICE_HANDLER( dma8237_r )
246210{
211   dma8237_t   *dma8237 = get_safe_token(device);
247212   UINT8 data = 0xFF;
248213   UINT8 mode;
249214
250   dma8237_verify(which);
251215   offset &= 0x0F;
252216
253217   switch(offset) {
r2300r2301
256220   case 4:
257221   case 6:
258222      /* 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);
261225
262226      /* hack simulating refresh activity for 'ibmxt' BIOS; I do not know
263227         * why this is needed; but in any case, the ibmxt driver does not load
264228         * if this code is not present */
265      mode = dma[which].chan[0].mode;
229      mode = dma8237->chan[0].mode;
266230      if ((DMA_MODE_OPERATION(mode) == 2) && (offset == 0))
267231      {
268         dma[which].chan[0].address++;
269         dma[which].chan[0].count--;
232         dma8237->chan[0].address++;
233         dma8237->chan[0].count--;
270234      }
271235      break;
272236
r2300r2301
275239   case 5:
276240   case 7:
277241      /* 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);
280244      break;
281245
282246   case 8:
283247      /* DMA status register */
284      data = (UINT8) dma[which].status;
248      data = (UINT8) dma8237->status;
285249      break;
286250
287251   case 10:
288252      /* DMA mask register */
289      data = dma[which].mask;
253      data = dma8237->mask;
290254      break;
291255
292256   case 13:
293257      /* DMA master clear */
294      data = dma[which].temp;
258      data = dma8237->temp;
295259      break;
296260
297261   case 9:      /* DMA write request register */
r2300r2301
307271
308272
309273
310static void dma8237_write(int which, offs_t offset, UINT8 data)
274WRITE8_DEVICE_HANDLER( dma8237_w )
311275{
276   dma8237_t   *dma8237 = get_safe_token(device);
312277   int channel;
313278
314   dma8237_verify(which);
315279   offset &= 0x0F;
316280
317281   switch(offset) {
r2300r2301
320284   case 4:
321285   case 6:
322286      /* 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;
325289      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);
328292      break;
329293
330294   case 1:
r2300r2301
332296   case 5:
333297   case 7:
334298      /* 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;
337301      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);
340304      break;
341305
342306   case 8:
343307      /* DMA command register */
344      dma[which].command = data;
308      dma8237->command = data;
345309      break;
346310
347311   case 10:
348312      /* DMA mask register */
349313      channel = DMA_MODE_CHANNEL(data);
350314      if (data & 0x04)
351         dma[which].mask |= 0x11 << channel;
315         dma8237->mask |= 0x11 << channel;
352316      else
353         dma[which].mask &= ~(0x11 << channel);
317         dma8237->mask &= ~(0x11 << channel);
354318      break;
355319
356320   case 11:
357321      /* DMA mode register */
358322      channel = DMA_MODE_CHANNEL(data);
359      dma[which].chan[channel].mode = data;
323      dma8237->chan[channel].mode = data;
360324      break;
361325
362326   case 12:
363327      /* DMA clear byte pointer flip-flop */
364      dma[which].temp = data;
365      dma[which].msb = 0;
328      dma8237->temp = data;
329      dma8237->msb = 0;
366330      break;
367331
368332   case 13:
369333      /* DMA master clear */
370      dma[which].msb = 0;
334      dma8237->msb = 0;
371335      break;
372336
373337   case 14:
374338      /* DMA clear mask register */
375      dma[which].mask &= ~data;
376      dma8237_update_status(which);
339      dma8237->mask &= ~data;
340      dma8237_update_status(device);
377341      break;
378342
379343   case 15:
380344      /* DMA write mask register */
381      dma[which].mask |= data;
345      dma8237->mask |= data;
382346      break;
383347   }
384348}
385349
386350
387351
388static void dma8237_drq_write_callback(int param)
352static void dma8237_drq_write_callback(const device_config *device, int param)
389353{
390   int which = param >> 3;
354   dma8237_t   *dma8237 = get_safe_token(device);
391355   int channel = (param >> 1) & 0x03;
392356   int state = param & 0x01;
393357
394358   /* normalize state */
395359   if (state)
396      dma[which].drq |= 0x01 << channel;
360      dma8237->drq |= 0x01 << channel;
397361   else
398      dma[which].drq &= ~(0x01 << channel);
362      dma8237->drq &= ~(0x01 << channel);
399363
400   dma8237_update_status(which);
364   dma8237_update_status(device);
401365}
402366
403367
404368
405void dma8237_drq_write(int which, int channel, int state)
369void dma8237_drq_write(const device_config *device, int channel, int state)
406370{
407   int param;
408
409   param = (which << 3) | (channel << 1) | (state ? 1 : 0);
371   int param = (channel << 1) | (state ? 1 : 0);
410372   //timer_call_after_resynch(NULL, param, dma8237_drq_write_callback);
411   dma8237_drq_write_callback(param);
373   dma8237_drq_write_callback(device, param);
412374}
413375
414376
415377
416378/******************* Unfortunate hacks *******************/
417379
418void dma8237_run_transfer(int which, int channel)
380void dma8237_run_transfer(const device_config *device, int channel)
419381{
420   dma[which].status |= 0x10 << channel;   /* reset DMA running flag */
382   dma8237_t   *dma8237 = get_safe_token(device);
421383
422   while(!dma8237_do_operation(which, channel))
384   dma8237->status |= 0x10 << channel;   /* reset DMA running flag */
385
386   while(!dma8237_do_operation(device, channel))
423387      ;
424388
425   dma[which].status &= ~(0x10 << channel);
426   dma[which].status |=  (0x01 << channel);
389   dma8237->status &= ~(0x10 << channel);
390   dma8237->status |=  (0x01 << channel);
427391}
428392
429393
430394
431/******************* Standard 8-bit/32-bit/64-bit CPU interfaces *******************/
395static DEVICE_START( dma8237 ) {
396   dma8237_t   *dma8237 = get_safe_token(device);
432397
433READ8_HANDLER( dma8237_0_r )   { return dma8237_read(0, offset); }
434READ8_HANDLER( dma8237_1_r )   { return dma8237_read(1, offset); }
435WRITE8_HANDLER( dma8237_0_w ) { dma8237_write(0, offset, data); }
436WRITE8_HANDLER( dma8237_1_w ) { dma8237_write(1, offset, data); }
398   dma8237->intf = device->static_config;
399}
437400
438READ16_HANDLER( dma8237_16le_0_r ) { return read16le_with_read8_handler(dma8237_0_r, machine, offset, mem_mask); }
439READ16_HANDLER( dma8237_16le_1_r ) { return read16le_with_read8_handler(dma8237_1_r, machine, offset, mem_mask); }
440WRITE16_HANDLER( dma8237_16le_0_w ) { write16le_with_write8_handler(dma8237_0_w, machine, offset, data, mem_mask); }
441WRITE16_HANDLER( dma8237_16le_1_w ) { write16le_with_write8_handler(dma8237_1_w, machine, offset, data, mem_mask); }
442401
443READ32_HANDLER( dma8237_32le_0_r ) { return read32le_with_read8_handler(dma8237_0_r, machine, offset, mem_mask); }
444READ32_HANDLER( dma8237_32le_1_r ) { return read32le_with_read8_handler(dma8237_1_r, machine, offset, mem_mask); }
445WRITE32_HANDLER( dma8237_32le_0_w ) { write32le_with_write8_handler(dma8237_0_w, machine, offset, data, mem_mask); }
446WRITE32_HANDLER( dma8237_32le_1_w ) { write32le_with_write8_handler(dma8237_1_w, machine, offset, data, mem_mask); }
402static DEVICE_RESET( dma8237 ) {
403   dma8237_t   *dma8237 = get_safe_token(device);
447404
448READ64_HANDLER( dma8237_64be_0_r ) { return read64be_with_read8_handler(dma8237_0_r, machine, offset, mem_mask); }
449READ64_HANDLER( dma8237_64be_1_r ) { return read64be_with_read8_handler(dma8237_1_r, machine, offset, mem_mask); }
450WRITE64_HANDLER( dma8237_64be_0_w ) { write64be_with_write8_handler(dma8237_0_w, machine, offset, data, mem_mask); }
451WRITE64_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
421static DEVICE_SET_INFO( dma8237 ) {
422   switch ( state ) {
423      /* no parameters to set */
424   }
425}
426
427
428DEVICE_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
r2300r2301
44
55**********************************************************************/
66
7#ifndef DMA8237_H
8#define DMA8237_H
7#ifndef __DMA8237_H_
8#define __DMA8237_H_
99
10#define DMA8237      DEVICE_GET_INFO_NAME(dma8237)
11
12typedef UINT8 (*dma8237_mem_read_func)(const device_config *device, int channel, offs_t offset);
13typedef void  (*dma8237_mem_write_func)(const device_config *device, int channel, offs_t offset, UINT8 data);
14typedef int   (*dma8237_channel_read_func)(const device_config *device);
15typedef void  (*dma8237_channel_write_func)(const device_config *device, int data);
16typedef 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
1024struct dma8237_interface
1125{
1226   /* CPU to halt when DMA is active */
r2300r2301
1630   double bus_speed;
1731
1832   /* 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;
2135
2236   /* 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];
2539
2640   /* function to call when DMA completes */
27   void    (*out_eop_func)(int state);
41   dma8237_out_eop_func      out_eop_func;
2842};
2943
3044
45/* device interface */
46DEVICE_GET_INFO( dma8237 );
47READ8_DEVICE_HANDLER( dma8237_r );
48WRITE8_DEVICE_HANDLER( dma8237_w );
49void dma8237_drq_write(const device_config *device, int channel, int state);
3150
32int dma8237_init(int count);
33void dma8237_config(int which, const struct dma8237_interface *intf);
34void dma8237_reset(void);
35
36void dma8237_drq_write(int which, int channel, int state);
37
3851/* unfortunate hack for the interim for PC HDC */
39void dma8237_run_transfer(int which, int channel);
52void dma8237_run_transfer(const device_config *device, int channel);
4053
41READ8_HANDLER( dma8237_0_r );
42READ8_HANDLER( dma8237_1_r );
43WRITE8_HANDLER( dma8237_0_w );
44WRITE8_HANDLER( dma8237_1_w );
45
46READ16_HANDLER( dma8237_16le_0_r );
47READ16_HANDLER( dma8237_16le_1_r );
48WRITE16_HANDLER( dma8237_16le_0_w );
49WRITE16_HANDLER( dma8237_16le_1_w );
50
51READ32_HANDLER( dma8237_32le_0_r );
52READ32_HANDLER( dma8237_32le_1_r );
53WRITE32_HANDLER( dma8237_32le_0_w );
54WRITE32_HANDLER( dma8237_32le_1_w );
55
56READ64_HANDLER( dma8237_64be_0_r );
57READ64_HANDLER( dma8237_64be_1_r );
58WRITE64_HANDLER( dma8237_64be_0_w );
59WRITE64_HANDLER( dma8237_64be_1_w );
60
61#endif /* DMA8237_H */
54#endif /* __DMA8237_H_ */

Previous 15994 Revisions Next


© 1998-2018 The MESS Team