src/emu/machine/8237dma.c
| r5012 | r5013 | |
| 23 | 23 | #include "8237dma.h" |
| 24 | 24 | |
| 25 | 25 | |
| 26 | /* States that the dma8237 device can be in */ |
| 27 | typedef enum { |
| 28 | DMA8237_SI, /* Idle state */ |
| 29 | DMA8237_S0, /* HRQ has been triggered, waiting to receive HLDA */ |
| 30 | // DMA8237_SW, /* Wait state */ |
| 31 | |
| 32 | /* Normal transfer states */ |
| 33 | DMA8237_S1, /* Output A8-A15; only used when A8-A15 really needs to be output */ |
| 34 | DMA8237_S2, /* Output A0-A7 */ |
| 35 | DMA8237_S3, /* Initiate read; skipped in compressed timing. On the S2->S3 transition DACK is set. */ |
| 36 | DMA8237_S4, /* Perform read/write */ |
| 37 | |
| 38 | /* Memory to memory transfer states */ |
| 39 | DMA8237_S11, /* Output A8-A15 */ |
| 40 | // DMA8237_S12, /* Output A0-A7 */ |
| 41 | // DMA8237_S13, /* Initiate read */ |
| 42 | // DMA8237_S14, /* Perform read/write */ |
| 43 | // DMA8237_S21, /* Output A8-A15 */ |
| 44 | // DMA8237_S22, /* Output A0-A7 */ |
| 45 | // DMA8237_S23, /* Initiate read */ |
| 46 | // DMA8237_S24, /* Perform read/write */ |
| 47 | } dma8237_state; |
| 48 | |
| 49 | |
| 26 | 50 | typedef struct dma8237 dma8237_t; |
| 27 | 51 | |
| 28 | 52 | struct dma8237 |
| 29 | 53 | { |
| 30 | 54 | const struct dma8237_interface *intf; |
| 31 | 55 | emu_timer *timer; |
| 32 | | emu_timer *msbflip_timer; |
| 33 | 56 | |
| 34 | 57 | struct |
| 35 | 58 | { |
| 59 | UINT16 base_address; |
| 60 | UINT16 base_count; |
| 36 | 61 | UINT16 address; |
| 37 | 62 | UINT16 count; |
| 38 | 63 | UINT8 mode; |
| 64 | int high_address_changed; |
| 39 | 65 | } chan[4]; |
| 40 | 66 | |
| 41 | 67 | UINT32 msb : 1; |
| 42 | 68 | UINT32 eop : 1; |
| 43 | 69 | UINT8 temp; |
| 70 | UINT8 temporary_data; |
| 44 | 71 | UINT8 command; |
| 45 | 72 | UINT8 drq; |
| 46 | 73 | UINT8 mask; |
| 74 | UINT8 hrq; |
| 75 | UINT8 hlda; |
| 47 | 76 | |
| 48 | 77 | /* bits 0- 3 : Terminal count for channels 0-3 |
| 49 | 78 | * bits 4- 7 : Transfer in progress for channels 0-3 */ |
| 50 | 79 | UINT8 status; |
| 80 | |
| 81 | dma8237_state state; /* State the device is currently in */ |
| 82 | int service_channel; /* Channel we will be servicing */ |
| 83 | int last_service_channel; /* Previous channel we serviced; used to determine channel priority. */ |
| 51 | 84 | }; |
| 52 | 85 | |
| 53 | 86 | |
| 54 | 87 | #define DMA_MODE_CHANNEL(mode) ((mode) & 0x03) |
| 55 | | #define DMA_MODE_OPERATION(mode) (((mode) >> 2) & 0x03) |
| 56 | | #define DMA_MODE_DIRECTION(mode) (((mode) & 0x20) ? -1 : +1) |
| 57 | | #define DMA_MODE_TRANSFERMODE(mode) (((mode) >> 6) & 0x03) |
| 88 | #define DMA_MODE_OPERATION(mode) ((mode) & 0x0c) |
| 89 | #define DMA_MODE_AUTO_INIT(mode) ((mode) & 0x10) |
| 90 | #define DMA_MODE_DIRECTION(mode) ((mode) & 0x20) |
| 91 | #define DMA_MODE_TRANSFERMODE(mode) ((mode) & 0xc0) |
| 58 | 92 | |
| 93 | #define DMA8237_VERIFY_TRANSFER 0x00 |
| 94 | #define DMA8237_WRITE_TRANSFER 0x04 |
| 95 | #define DMA8237_READ_TRANSFER 0x08 |
| 96 | #define DMA8237_ILLEGAL_TRANSFER 0x0c |
| 59 | 97 | |
| 98 | #define DMA8237_DEMAND_MODE 0x00 |
| 99 | #define DMA8237_SINGLE_MODE 0x40 |
| 100 | #define DMA8237_BLOCK_MODE 0x80 |
| 101 | #define DMA8237_CASCADE_MODE 0xc0 |
| 60 | 102 | |
| 61 | | static TIMER_CALLBACK( dma8237_timerproc ); |
| 62 | | static TIMER_CALLBACK( dma8237_msbflip_timerproc ); |
| 63 | | static void dma8237_update_status(const device_config *device); |
| 64 | 103 | |
| 65 | 104 | /* ----------------------------------------------------------------------- */ |
| 66 | 105 | |
| r5012 | r5013 | |
| 75 | 114 | /* ----------------------------------------------------------------------- */ |
| 76 | 115 | |
| 77 | 116 | |
| 78 | | static int dma8237_do_operation(const device_config *device, int channel) |
| 117 | INLINE void dma8237_do_read( const device_config *device ) |
| 79 | 118 | { |
| 80 | | dma8237_t *dma8237 = get_safe_token(device); |
| 81 | | int done; |
| 82 | | UINT8 data; |
| 83 | | UINT8 mode; |
| 119 | dma8237_t *dma8237 = get_safe_token( device ); |
| 120 | int channel = dma8237->service_channel; |
| 84 | 121 | |
| 85 | | mode = dma8237->chan[channel].mode; |
| 86 | | |
| 87 | | switch(DMA_MODE_OPERATION(mode)) { |
| 88 | | case 1: |
| 89 | | data = dma8237->intf->channel_read_func[channel](device); |
| 90 | | dma8237->intf->memory_write_func(device, channel, dma8237->chan[channel].address, data); |
| 91 | | |
| 92 | | dma8237->chan[channel].address += DMA_MODE_DIRECTION(mode); |
| 93 | | dma8237->chan[channel].count--; |
| 94 | | done = (dma8237->chan[channel].count == 0xFFFF); |
| 122 | switch( DMA_MODE_OPERATION( dma8237->chan[ channel ].mode ) ) |
| 123 | { |
| 124 | case DMA8237_WRITE_TRANSFER: |
| 125 | dma8237->temporary_data = dma8237->intf->channel_read_func[ channel ]( device ); |
| 95 | 126 | break; |
| 127 | case DMA8237_READ_TRANSFER: |
| 128 | dma8237->temporary_data = dma8237->intf->memory_read_func( device, channel, dma8237->chan[ channel ].address ); |
| 129 | break; |
| 130 | case DMA8237_VERIFY_TRANSFER: |
| 131 | case DMA8237_ILLEGAL_TRANSFER: |
| 132 | break; |
| 133 | } |
| 134 | } |
| 96 | 135 | |
| 97 | | case 2: |
| 98 | | data = dma8237->intf->memory_read_func(device, channel, dma8237->chan[channel].address); |
| 99 | | dma8237->intf->channel_write_func[channel](device, data); |
| 100 | 136 | |
| 101 | | dma8237->chan[channel].address += DMA_MODE_DIRECTION(mode); |
| 102 | | dma8237->chan[channel].count--; |
| 103 | | done = (dma8237->chan[channel].count == 0xFFFF); |
| 104 | | break; |
| 137 | INLINE void dma8237_do_write( const device_config *device ) |
| 138 | { |
| 139 | dma8237_t *dma8237 = get_safe_token( device ); |
| 140 | int channel = dma8237->service_channel; |
| 105 | 141 | |
| 106 | | default: |
| 107 | | done = TRUE; |
| 142 | switch( DMA_MODE_OPERATION( dma8237->chan[ channel ].mode ) ) |
| 143 | { |
| 144 | case DMA8237_WRITE_TRANSFER: |
| 145 | dma8237->intf->memory_write_func( device, channel, dma8237->chan[ channel ].address, dma8237->temporary_data ); |
| 108 | 146 | break; |
| 147 | case DMA8237_READ_TRANSFER: |
| 148 | dma8237->intf->channel_write_func[channel]( device, dma8237->temporary_data ); |
| 149 | break; |
| 150 | case DMA8237_VERIFY_TRANSFER: |
| 151 | case DMA8237_ILLEGAL_TRANSFER: |
| 152 | break; |
| 109 | 153 | } |
| 110 | | return done; |
| 111 | 154 | } |
| 112 | 155 | |
| 113 | 156 | |
| 114 | | |
| 115 | | static TIMER_CALLBACK( dma8237_timerproc ) |
| 157 | INLINE void dma8237_advance( const device_config *device ) |
| 116 | 158 | { |
| 117 | | const device_config *device = (const device_config *)ptr; |
| 118 | | dma8237_t *dma8237 = get_safe_token(device); |
| 119 | | int channel = param % 4; |
| 120 | | int done; |
| 159 | dma8237_t *dma8237 = get_safe_token( device ); |
| 160 | int channel = dma8237->service_channel; |
| 161 | int mode = dma8237->chan[channel].mode; |
| 121 | 162 | |
| 122 | | done = dma8237_do_operation(device, channel); |
| 163 | switch ( DMA_MODE_OPERATION( mode ) ) |
| 164 | { |
| 165 | case DMA8237_VERIFY_TRANSFER: |
| 166 | case DMA8237_WRITE_TRANSFER: |
| 167 | case DMA8237_READ_TRANSFER: |
| 168 | dma8237->chan[channel].high_address_changed = 0; |
| 123 | 169 | |
| 124 | | if (done) |
| 125 | | { |
| 126 | | dma8237->status &= ~(0x10 << channel); |
| 127 | | dma8237->status |= (0x01 << channel); |
| 128 | | dma8237->drq &= ~(0x01 << channel); |
| 129 | | dma8237_update_status(device); |
| 170 | if ( DMA_MODE_DIRECTION( mode ) ) |
| 171 | { |
| 172 | dma8237->chan[channel].address -= 1; |
| 173 | if ( ( dma8237->chan[channel].address & 0xFF ) == 0xFF ) |
| 174 | dma8237->chan[channel].high_address_changed = 1; |
| 175 | } |
| 176 | else |
| 177 | { |
| 178 | dma8237->chan[channel].address += 1; |
| 179 | if ( ( dma8237->chan[channel].address & 0xFF ) == 0x00 ) |
| 180 | dma8237->chan[channel].high_address_changed = 1; |
| 181 | } |
| 182 | |
| 183 | dma8237->chan[channel].count--; |
| 184 | |
| 185 | if ( dma8237->chan[channel].count == 0xFFFF ) |
| 186 | { |
| 187 | /* Set TC bit for this channel */ |
| 188 | dma8237->status |= ( 0x01 << channel ); |
| 189 | |
| 190 | if ( DMA_MODE_AUTO_INIT( mode ) ) |
| 191 | { |
| 192 | dma8237->chan[channel].address = dma8237->chan[channel].base_address; |
| 193 | dma8237->chan[channel].count = dma8237->chan[channel].base_count; |
| 194 | dma8237->chan[channel].high_address_changed = 1; |
| 195 | } |
| 196 | else |
| 197 | { |
| 198 | dma8237->mask |= ( 0x01 << channel ); |
| 199 | } |
| 200 | } |
| 201 | break; |
| 202 | case DMA8237_ILLEGAL_TRANSFER: |
| 203 | break; |
| 130 | 204 | } |
| 205 | |
| 131 | 206 | } |
| 132 | 207 | |
| 133 | 208 | |
| 134 | | |
| 135 | | static TIMER_CALLBACK( dma8237_msbflip_timerproc ) |
| 209 | static TIMER_CALLBACK( dma8237_timerproc ) |
| 136 | 210 | { |
| 137 | 211 | const device_config *device = (const device_config *)ptr; |
| 138 | 212 | dma8237_t *dma8237 = get_safe_token(device); |
| 139 | | dma8237->msb ^= 1; |
| 140 | | } |
| 141 | 213 | |
| 214 | /* Check if operation is disabled */ |
| 215 | if ( dma8237->command & 0x04 ) |
| 216 | return; |
| 142 | 217 | |
| 218 | switch ( dma8237->state ) { |
| 143 | 219 | |
| 144 | | static void dma8237_update_status(const device_config *device) |
| 145 | | { |
| 146 | | dma8237_t *dma8237 = get_safe_token(device); |
| 147 | | UINT16 pending_transfer; |
| 148 | | int channel; |
| 149 | | UINT32 new_eop; |
| 220 | case DMA8237_SI: |
| 221 | /* Make sure EOP is high */ |
| 222 | if ( ! dma8237->eop ) |
| 223 | { |
| 224 | dma8237->eop = 1; |
| 225 | if ( dma8237->intf->out_eop_func ) |
| 226 | dma8237->intf->out_eop_func( device, 0, dma8237->eop ? ASSERT_LINE : CLEAR_LINE ); |
| 227 | } |
| 150 | 228 | |
| 151 | | if ((dma8237->status & 0xF0) == 0) |
| 152 | | { |
| 153 | | /* no transfer is active right now; is there a transfer pending right now? */ |
| 154 | | pending_transfer = dma8237->drq & ~dma8237->mask; |
| 155 | | |
| 156 | | if (pending_transfer) |
| 229 | /* Check if a new DMA request has been received. */ |
| 157 | 230 | { |
| 158 | | /* we do have a transfer in progress */ |
| 159 | | for (channel = 3; (pending_transfer & (1 << channel)) == 0; channel--) |
| 160 | | ; |
| 231 | /* Bit 6 of the command register determines whether the DREQ signals are active |
| 232 | high or active low. */ |
| 233 | UINT16 pending_request = ( ( dma8237->command & 0x40 ) ? ~dma8237->drq : dma8237->drq ) & ~dma8237->mask; |
| 161 | 234 | |
| 162 | | dma8237->status |= 0x10 << channel; |
| 163 | | dma8237->status &= ~(0x01 << channel); |
| 235 | if ( pending_request & 0x0f ) |
| 236 | { |
| 237 | int i, channel, prio_channel = 0; |
| 164 | 238 | |
| 165 | | timer_adjust_periodic(dma8237->timer, |
| 166 | | attotime_zero, |
| 167 | | channel, |
| 168 | | double_to_attotime(dma8237->intf->bus_speed)); |
| 239 | /* Determine the channel that should be serviced */ |
| 240 | channel = ( dma8237->command & 0x10 ) ? dma8237->last_service_channel : 3; |
| 241 | for ( i = 0; i < 4; i++ ) |
| 242 | { |
| 243 | if ( pending_request & ( 1 << channel ) ) |
| 244 | prio_channel = channel; |
| 245 | channel = ( channel - 1 ) & 0x03; |
| 246 | } |
| 247 | |
| 248 | /* Store the channel we will be servicing and go to the next state */ |
| 249 | dma8237->service_channel = prio_channel; |
| 250 | dma8237->last_service_channel = prio_channel; |
| 251 | dma8237->hrq = 1; |
| 252 | dma8237->intf->hrq_changed( device, dma8237->hrq ); |
| 253 | dma8237->state = DMA8237_S0; |
| 254 | |
| 255 | timer_enable( dma8237->timer, 1 ); |
| 256 | } |
| 257 | else |
| 258 | { |
| 259 | timer_enable( dma8237->timer, 0 ); |
| 260 | } |
| 169 | 261 | } |
| 170 | | else |
| 171 | | { |
| 172 | | /* no transfers active right now */ |
| 173 | | timer_reset(dma8237->timer, attotime_never); |
| 174 | | } |
| 262 | break; |
| 175 | 263 | |
| 176 | | /* set the halt line */ |
| 177 | | if (dma8237->intf && dma8237->intf->cputag != NULL) |
| 264 | case DMA8237_S0: |
| 265 | /* S0 is the first of the DMA service. We have requested a hold but are waiting |
| 266 | for confirmation. */ |
| 267 | if ( dma8237->hlda ) |
| 178 | 268 | { |
| 179 | | cputag_set_input_line(device->machine, dma8237->intf->cputag, INPUT_LINE_HALT, |
| 180 | | pending_transfer ? ASSERT_LINE : CLEAR_LINE); |
| 269 | if ( dma8237->command & 0x01 ) |
| 270 | { |
| 271 | /* Memory-to-memory transfers */ |
| 272 | dma8237->state = DMA8237_S11; |
| 273 | } |
| 274 | else |
| 275 | { |
| 276 | /* Regular transfers */ |
| 277 | dma8237->state = DMA8237_S1; |
| 278 | } |
| 181 | 279 | } |
| 280 | break; |
| 182 | 281 | |
| 183 | | /* set the eop line, if it has changed */ |
| 184 | | new_eop = (dma8237->status & 0x0F) == 0x0F ? 1 : 0; |
| 185 | | if (dma8237->eop != new_eop) |
| 282 | case DMA8237_S1: /* Output A8-A15 */ |
| 283 | dma8237->state = DMA8237_S2; |
| 284 | break; |
| 285 | |
| 286 | case DMA8237_S2: /* Output A7-A0 */ |
| 287 | /* Check for compressed timing */ |
| 288 | if ( dma8237->command & 0x08 ) |
| 289 | dma8237->state = DMA8237_S4; |
| 290 | else |
| 291 | dma8237->state = DMA8237_S3; |
| 292 | break; |
| 293 | |
| 294 | case DMA8237_S3: /* Initiate read */ |
| 295 | dma8237_do_read( device ); |
| 296 | dma8237->state = DMA8237_S4; |
| 297 | break; |
| 298 | |
| 299 | case DMA8237_S4: /* Perform read/write */ |
| 300 | /* Perform read when in compressed timing mode */ |
| 301 | if ( dma8237->command & 0x08 ) |
| 302 | dma8237_do_read( device ); |
| 303 | |
| 304 | /* Perform write */ |
| 305 | dma8237_do_write( device ); |
| 306 | |
| 307 | /* Advance */ |
| 308 | dma8237_advance( device ); |
| 309 | |
| 186 | 310 | { |
| 187 | | dma8237->eop = new_eop; |
| 188 | | if (dma8237->intf->out_eop_func) |
| 189 | | dma8237->intf->out_eop_func(device, new_eop ? ASSERT_LINE : CLEAR_LINE); |
| 190 | | } |
| 191 | | } |
| 192 | | } |
| 311 | int channel = dma8237->service_channel; |
| 193 | 312 | |
| 313 | switch( DMA_MODE_TRANSFERMODE( dma8237->chan[channel].mode ) ) |
| 314 | { |
| 315 | case DMA8237_DEMAND_MODE: |
| 316 | /* Check for terminal count or EOP signal or DREQ begin de-asserted */ |
| 317 | if ( ( dma8237->status & ( 0x01 << channel ) ) || ! dma8237->eop || ! ( dma8237->drq & ( 0x01 << channel ) ) ) |
| 318 | { |
| 319 | dma8237->hrq = 0; |
| 320 | dma8237->hlda = 0; |
| 321 | dma8237->intf->hrq_changed( device, dma8237->hrq ); |
| 322 | dma8237->state = DMA8237_SI; |
| 323 | } |
| 324 | else |
| 325 | { |
| 326 | dma8237->state = dma8237->chan[channel].high_address_changed ? DMA8237_S1 : DMA8237_S2; |
| 327 | } |
| 328 | break; |
| 194 | 329 | |
| 330 | case DMA8237_SINGLE_MODE: |
| 331 | dma8237->hrq = 0; |
| 332 | dma8237->hlda = 0; |
| 333 | dma8237->intf->hrq_changed( device, dma8237->hrq ); |
| 334 | dma8237->state = DMA8237_SI; |
| 335 | break; |
| 195 | 336 | |
| 196 | | /* ----------------------------------------------------------------------- */ |
| 337 | case DMA8237_BLOCK_MODE: |
| 338 | /* Check for terminal count or EOP signal */ |
| 339 | if ( ( dma8237->status & ( 0x01 << channel ) ) || ! dma8237->eop ) |
| 340 | { |
| 341 | dma8237->hrq = 0; |
| 342 | dma8237->hlda = 0; |
| 343 | dma8237->intf->hrq_changed( device, dma8237->hrq ); |
| 344 | dma8237->state = DMA8237_SI; |
| 345 | } |
| 346 | else |
| 347 | { |
| 348 | dma8237->state = dma8237->chan[channel].high_address_changed ? DMA8237_S1 : DMA8237_S2; |
| 349 | } |
| 350 | break; |
| 197 | 351 | |
| 352 | case DMA8237_CASCADE_MODE: |
| 353 | if ( ! ( dma8237->drq & ( 0x01 << channel ) ) ) |
| 354 | { |
| 355 | dma8237->hrq = 0; |
| 356 | dma8237->hlda = 0; |
| 357 | dma8237->intf->hrq_changed( device, dma8237->hrq ); |
| 358 | dma8237->state = DMA8237_SI; |
| 359 | } |
| 360 | break; |
| 361 | } |
| 198 | 362 | |
| 199 | | INLINE void prepare_msb_flip(const device_config *device) |
| 200 | | { |
| 201 | | dma8237_t *dma8237 = get_safe_token(device); |
| 363 | /* Check if EOP output needs to be asserted */ |
| 364 | if ( dma8237->status & ( 0x01 << channel ) ) |
| 365 | { |
| 366 | dma8237->eop = 0; |
| 367 | if ( dma8237->intf->out_eop_func ) |
| 368 | dma8237->intf->out_eop_func( device, channel, dma8237->eop ? ASSERT_LINE : CLEAR_LINE ); |
| 369 | } |
| 370 | } |
| 371 | break; |
| 202 | 372 | |
| 203 | | timer_adjust_oneshot(dma8237->msbflip_timer, attotime_zero, 0); |
| 373 | case DMA8237_S11: /* Output A8-A15 */ |
| 374 | break; |
| 375 | } |
| 204 | 376 | } |
| 205 | 377 | |
| 206 | 378 | |
| 207 | 379 | |
| 380 | |
| 381 | /* ----------------------------------------------------------------------- */ |
| 382 | |
| 383 | |
| 208 | 384 | READ8_DEVICE_HANDLER( dma8237_r ) |
| 209 | 385 | { |
| 210 | 386 | dma8237_t *dma8237 = get_safe_token(device); |
| 211 | 387 | UINT8 data = 0xFF; |
| 212 | | UINT8 mode; |
| 213 | 388 | |
| 214 | 389 | offset &= 0x0F; |
| 215 | 390 | |
| r5012 | r5013 | |
| 220 | 395 | case 6: |
| 221 | 396 | /* DMA address register */ |
| 222 | 397 | data = dma8237->chan[offset / 2].address >> (dma8237->msb ? 8 : 0); |
| 223 | | prepare_msb_flip(device); |
| 224 | | |
| 225 | | /* hack simulating refresh activity for 'ibmxt' BIOS; I do not know |
| 226 | | * why this is needed; but in any case, the ibmxt driver does not load |
| 227 | | * if this code is not present */ |
| 228 | | mode = dma8237->chan[0].mode; |
| 229 | | if ((DMA_MODE_OPERATION(mode) == 2) && (offset == 0)) |
| 230 | | { |
| 231 | | dma8237->chan[0].address++; |
| 232 | | dma8237->chan[0].count--; |
| 233 | | } |
| 398 | dma8237->msb ^= 1; |
| 234 | 399 | break; |
| 235 | 400 | |
| 236 | 401 | case 1: |
| r5012 | r5013 | |
| 239 | 404 | case 7: |
| 240 | 405 | /* DMA count register */ |
| 241 | 406 | data = dma8237->chan[offset / 2].count >> (dma8237->msb ? 8 : 0); |
| 242 | | prepare_msb_flip(device); |
| 407 | dma8237->msb ^= 1; |
| 243 | 408 | break; |
| 244 | 409 | |
| 245 | 410 | case 8: |
| 246 | 411 | /* DMA status register */ |
| 247 | 412 | data = (UINT8) dma8237->status; |
| 413 | |
| 414 | /* TC bits are cleared on a status read */ |
| 415 | dma8237->status &= 0xF0; |
| 248 | 416 | break; |
| 249 | 417 | |
| 250 | 418 | case 10: |
| r5012 | r5013 | |
| 265 | 433 | data = 0xFF; |
| 266 | 434 | break; |
| 267 | 435 | } |
| 436 | |
| 268 | 437 | return data; |
| 269 | 438 | } |
| 270 | 439 | |
| r5012 | r5013 | |
| 277 | 446 | |
| 278 | 447 | offset &= 0x0F; |
| 279 | 448 | |
| 449 | logerror("dma8237_w: offset = %02x, data = %02x\n", offset, data ); |
| 450 | |
| 280 | 451 | switch(offset) { |
| 281 | 452 | case 0: |
| 282 | 453 | case 2: |
| 283 | 454 | case 4: |
| 284 | 455 | case 6: |
| 285 | 456 | /* DMA address register */ |
| 457 | channel = offset / 2; |
| 286 | 458 | if (dma8237->msb) |
| 287 | | dma8237->chan[offset / 2].address |= ((UINT16) data) << 8; |
| 459 | { |
| 460 | dma8237->chan[channel].base_address = ( dma8237->chan[channel].base_address & 0x00FF ) | ( data << 8 ); |
| 461 | dma8237->chan[channel].address = ( dma8237->chan[channel].address & 0x00FF ) | ( data << 8 ); |
| 462 | } |
| 288 | 463 | else |
| 289 | | dma8237->chan[offset / 2].address = data; |
| 290 | | prepare_msb_flip(device); |
| 464 | { |
| 465 | dma8237->chan[channel].base_address = ( dma8237->chan[channel].base_address & 0xFF00 ) | data; |
| 466 | dma8237->chan[channel].address = ( dma8237->chan[channel].address & 0xFF00 ) | data; |
| 467 | } |
| 468 | dma8237->msb ^= 1; |
| 291 | 469 | break; |
| 292 | 470 | |
| 293 | 471 | case 1: |
| r5012 | r5013 | |
| 295 | 473 | case 5: |
| 296 | 474 | case 7: |
| 297 | 475 | /* DMA count register */ |
| 476 | channel = offset / 2; |
| 298 | 477 | if (dma8237->msb) |
| 299 | | dma8237->chan[offset / 2].count |= ((UINT16) data) << 8; |
| 478 | { |
| 479 | dma8237->chan[channel].base_count = ( dma8237->chan[channel].base_count & 0x00FF ) | ( data << 8 ); |
| 480 | dma8237->chan[channel].count = ( dma8237->chan[channel].count & 0x00FF ) | ( data << 8 ); |
| 481 | } |
| 300 | 482 | else |
| 301 | | dma8237->chan[offset / 2].count = data; |
| 302 | | prepare_msb_flip(device); |
| 483 | { |
| 484 | dma8237->chan[channel].base_count = ( dma8237->chan[channel].base_count & 0xFF00 ) | data; |
| 485 | dma8237->chan[channel].count = ( dma8237->chan[channel].count & 0xFF00 ) | data; |
| 486 | } |
| 487 | dma8237->msb ^= 1; |
| 303 | 488 | break; |
| 304 | 489 | |
| 305 | 490 | case 8: |
| 306 | 491 | /* DMA command register */ |
| 307 | 492 | dma8237->command = data; |
| 493 | timer_enable( dma8237->timer, ( dma8237->command & 0x04 ) ? 0 : 1 ); |
| 308 | 494 | break; |
| 309 | 495 | |
| 496 | case 9: |
| 497 | /* DMA request register */ |
| 498 | channel = DMA_MODE_CHANNEL(data); |
| 499 | if ( data & 0x04 ) |
| 500 | { |
| 501 | dma8237->drq |= 0x01 << channel; |
| 502 | timer_enable( dma8237->timer, ( dma8237->command & 0x04 ) ? 0 : 1 ); |
| 503 | } |
| 504 | else |
| 505 | { |
| 506 | dma8237->status &= ~ ( 0x10 << channel ); |
| 507 | dma8237->drq &= ~ ( 0x01 << channel ); |
| 508 | } |
| 509 | break; |
| 510 | |
| 310 | 511 | case 10: |
| 311 | 512 | /* DMA mask register */ |
| 312 | 513 | channel = DMA_MODE_CHANNEL(data); |
| r5012 | r5013 | |
| 320 | 521 | /* DMA mode register */ |
| 321 | 522 | channel = DMA_MODE_CHANNEL(data); |
| 322 | 523 | dma8237->chan[channel].mode = data; |
| 524 | /* Apparently mode writes also clear the TC bit(?) */ |
| 525 | dma8237->status &= ~ ( 1 << channel ); |
| 323 | 526 | break; |
| 324 | 527 | |
| 325 | 528 | case 12: |
| r5012 | r5013 | |
| 331 | 534 | case 13: |
| 332 | 535 | /* DMA master clear */ |
| 333 | 536 | dma8237->msb = 0; |
| 537 | dma8237->mask = 0x0f; |
| 538 | dma8237->state = DMA8237_SI; |
| 539 | dma8237->status &= 0xF0; |
| 334 | 540 | break; |
| 335 | 541 | |
| 336 | 542 | case 14: |
| 337 | 543 | /* DMA clear mask register */ |
| 338 | 544 | dma8237->mask &= ~data; |
| 339 | | dma8237_update_status(device); |
| 545 | dma8237->mask = 0; |
| 340 | 546 | break; |
| 341 | 547 | |
| 342 | 548 | case 15: |
| r5012 | r5013 | |
| 348 | 554 | |
| 349 | 555 | |
| 350 | 556 | |
| 351 | | static void dma8237_drq_write_callback(const device_config *device, int param) |
| 557 | void dma8237_drq_write(const device_config *device, int channel, int state) |
| 352 | 558 | { |
| 353 | | dma8237_t *dma8237 = get_safe_token(device); |
| 354 | | int channel = (param >> 1) & 0x03; |
| 355 | | int state = param & 0x01; |
| 559 | dma8237_t *dma8237 = get_safe_token( device ); |
| 356 | 560 | |
| 357 | | /* normalize state */ |
| 358 | 561 | if (state) |
| 359 | | dma8237->drq |= 0x01 << channel; |
| 562 | dma8237->drq |= ( 0x01 << channel ); |
| 360 | 563 | else |
| 361 | | dma8237->drq &= ~(0x01 << channel); |
| 564 | dma8237->drq &= ~( 0x01 << channel ); |
| 362 | 565 | |
| 363 | | dma8237_update_status(device); |
| 566 | timer_enable( dma8237->timer, ( dma8237->command & 0x04 ) ? 0 : 1 ); |
| 364 | 567 | } |
| 365 | 568 | |
| 366 | 569 | |
| 570 | void dma8237_set_hlda(const device_config *device, int state) |
| 571 | { |
| 572 | dma8237_t *dma8237 = get_safe_token( device ); |
| 367 | 573 | |
| 368 | | void dma8237_drq_write(const device_config *device, int channel, int state) |
| 369 | | { |
| 370 | | int param = (channel << 1) | (state ? 1 : 0); |
| 371 | | //timer_call_after_resynch(device->machine, NULL, param, dma8237_drq_write_callback); |
| 372 | | dma8237_drq_write_callback(device, param); |
| 574 | dma8237->hlda = state; |
| 373 | 575 | } |
| 374 | 576 | |
| 375 | 577 | |
| 376 | | |
| 377 | 578 | /******************* Unfortunate hacks *******************/ |
| 378 | 579 | |
| 379 | 580 | void dma8237_run_transfer(const device_config *device, int channel) |
| r5012 | r5013 | |
| 382 | 583 | |
| 383 | 584 | dma8237->status |= 0x10 << channel; /* reset DMA running flag */ |
| 384 | 585 | |
| 385 | | while(!dma8237_do_operation(device, channel)) |
| 386 | | ; |
| 586 | popmessage("dma8237_run_transfer(): please do not use me anymore\n"); |
| 387 | 587 | |
| 388 | 588 | dma8237->status &= ~(0x10 << channel); |
| 389 | 589 | dma8237->status |= (0x01 << channel); |
| r5012 | r5013 | |
| 403 | 603 | |
| 404 | 604 | dma8237->status = 0x0F; |
| 405 | 605 | dma8237->timer = timer_alloc(device->machine, dma8237_timerproc, (void *)device); |
| 406 | | dma8237->msbflip_timer = timer_alloc(device->machine, dma8237_msbflip_timerproc, (void *)device); |
| 407 | 606 | dma8237->eop = 1; |
| 607 | dma8237->state = DMA8237_SI; |
| 608 | dma8237->last_service_channel = 3; |
| 408 | 609 | |
| 409 | 610 | dma8237->mask = 0x00; |
| 410 | 611 | dma8237->status = 0x0F; |
| 612 | dma8237->hrq = 0; |
| 613 | dma8237->hlda = 0; |
| 411 | 614 | dma8237->chan[0].mode = 0; |
| 412 | 615 | dma8237->chan[1].mode = 0; |
| 413 | 616 | dma8237->chan[2].mode = 0; |
| 414 | 617 | dma8237->chan[3].mode = 0; |
| 415 | 618 | |
| 416 | | dma8237_update_status(device); |
| 619 | timer_adjust_periodic(dma8237->timer, |
| 620 | ATTOTIME_IN_HZ(dma8237->intf->bus_speed), |
| 621 | 0, |
| 622 | ATTOTIME_IN_HZ(dma8237->intf->bus_speed)); |
| 417 | 623 | } |
| 418 | 624 | |
| 419 | 625 | |
| r5012 | r5013 | |
| 432 | 638 | /* --- the following bits of info are returned as NULL-terminated strings --- */ |
| 433 | 639 | case DEVINFO_STR_NAME: strcpy(info->s, "Intel DMA8237"); break; |
| 434 | 640 | case DEVINFO_STR_FAMILY: strcpy(info->s, "DMA8237"); break; |
| 435 | | case DEVINFO_STR_VERSION: strcpy(info->s, "1.00"); break; |
| 641 | case DEVINFO_STR_VERSION: strcpy(info->s, "1.01"); break; |
| 436 | 642 | case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break; |
| 437 | 643 | case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright the MAME and MESS Teams"); break; |
| 438 | 644 | } |