src/mess/machine/68901mfp.c
| r2431 | r2432 | |
| 207 | 207 | |
| 208 | 208 | #define LOG (0) |
| 209 | 209 | |
| 210 | | struct _mc68901_t |
| 211 | | { |
| 212 | | int device_type; |
| 213 | | const mc68901_interface *intf; |
| 214 | | |
| 215 | | UINT8 gpip; |
| 216 | | UINT8 aer; |
| 217 | | UINT8 ddr; |
| 218 | | |
| 219 | | UINT16 ier, ipr, isr, imr; |
| 220 | | UINT8 vr; |
| 221 | | int irqlevel; |
| 222 | | |
| 223 | | UINT8 tacr, tbcr, tcdcr; |
| 224 | | UINT8 tdr[MC68901_MAX_TIMERS]; |
| 225 | | UINT8 tmc[MC68901_MAX_TIMERS]; |
| 226 | | int to[MC68901_MAX_TIMERS]; |
| 227 | | int ti[MC68901_MAX_TIMERS]; |
| 228 | | emu_timer *timer[MC68901_MAX_TIMERS]; |
| 229 | | |
| 230 | | UINT8 ucr; |
| 231 | | UINT8 udr; |
| 232 | | UINT8 scr; |
| 233 | | UINT8 tsr, rsr, next_rsr, rsr_read; |
| 234 | | UINT8 rx_buffer, tx_buffer; |
| 235 | | int rx_bits, tx_bits; |
| 236 | | int rx_parity, tx_parity; |
| 237 | | int rx_state, tx_state, xmit_state; |
| 238 | | int rxtx_word, rxtx_start, rxtx_stop; |
| 239 | | } mfp_68901; |
| 240 | | |
| 241 | 210 | static const int MC68901_INT_MASK_GPIO[] = |
| 242 | 211 | { |
| 243 | 212 | MC68901_IR_GPIP_0, MC68901_IR_GPIP_1, MC68901_IR_GPIP_2, MC68901_IR_GPIP_3, |
| r2431 | r2432 | |
| 261 | 230 | |
| 262 | 231 | static const int PRESCALER[] = { 0, 4, 10, 16, 50, 64, 100, 200 }; |
| 263 | 232 | |
| 264 | | static void mc68901_check_interrupts(mc68901_t *chip) |
| 233 | typedef struct _mc68901_t mc68901_t; |
| 234 | struct _mc68901_t |
| 265 | 235 | { |
| 266 | | if (chip->ipr & chip->imr) |
| 236 | int device_type; /* device type */ |
| 237 | const mc68901_interface *intf; /* interface */ |
| 238 | |
| 239 | /* registers */ |
| 240 | UINT8 gpip; /* general purpose I/O register */ |
| 241 | UINT8 aer; /* active edge register */ |
| 242 | UINT8 ddr; /* data direction register */ |
| 243 | |
| 244 | UINT16 ier; /* interrupt enable register */ |
| 245 | UINT16 ipr; /* interrupt pending register */ |
| 246 | UINT16 isr; /* interrupt in-service register */ |
| 247 | UINT16 imr; /* interrupt mask register */ |
| 248 | UINT8 vr; /* vector register */ |
| 249 | |
| 250 | UINT8 tacr; /* timer A control register */ |
| 251 | UINT8 tbcr; /* timer B control register */ |
| 252 | UINT8 tcdcr; /* timers C and D control register */ |
| 253 | UINT8 tdr[MC68901_MAX_TIMERS]; /* timer data registers */ |
| 254 | |
| 255 | UINT8 scr; /* synchronous character register */ |
| 256 | UINT8 ucr; /* USART control register */ |
| 257 | UINT8 tsr; /* transmitter status register */ |
| 258 | UINT8 rsr; /* receiver status register */ |
| 259 | UINT8 udr; /* USART data register */ |
| 260 | |
| 261 | /* counter timer state */ |
| 262 | UINT8 tmc[MC68901_MAX_TIMERS]; /* timer main counters */ |
| 263 | int ti[MC68901_MAX_TIMERS]; /* timer in latch */ |
| 264 | int to[MC68901_MAX_TIMERS]; /* timer out latch */ |
| 265 | |
| 266 | /* interrupt state */ |
| 267 | int irqlevel; /* interrupt level latch */ |
| 268 | |
| 269 | /* serial state */ |
| 270 | UINT8 next_rsr; /* receiver status register latch */ |
| 271 | int rsr_read; /* receiver status register read flag */ |
| 272 | int rxtx_word; /* word length */ |
| 273 | int rxtx_start; /* start bits */ |
| 274 | int rxtx_stop; /* stop bits */ |
| 275 | |
| 276 | /* receive state */ |
| 277 | UINT8 rx_buffer; /* receive buffer */ |
| 278 | int rx_bits; /* receive bit count */ |
| 279 | int rx_parity; /* receive parity bit */ |
| 280 | int rx_state; /* receive state */ |
| 281 | |
| 282 | /* transmit state */ |
| 283 | UINT8 tx_buffer; /* transmit buffer */ |
| 284 | int tx_bits; /* transmit bit count */ |
| 285 | int tx_parity; /* transmit parity bit */ |
| 286 | int tx_state; /* transmit state */ |
| 287 | int xmit_state; /* transmitter state */ |
| 288 | |
| 289 | /* timers */ |
| 290 | emu_timer *timer[MC68901_MAX_TIMERS]; /* counter timers */ |
| 291 | |
| 292 | emu_timer *rx_timer; /* receive timer */ |
| 293 | emu_timer *tx_timer; /* transmit timer */ |
| 294 | |
| 295 | emu_timer *poll_timer; /* general purpose I/O poll timer */ |
| 296 | } mfp_68901; |
| 297 | |
| 298 | INLINE mc68901_t *get_safe_token(const device_config *device) |
| 299 | { |
| 300 | assert(device != NULL); |
| 301 | assert(device->token != NULL); |
| 302 | |
| 303 | return (mc68901_t *)device->token; |
| 304 | } |
| 305 | |
| 306 | static void mc68901_check_interrupts(const device_config *device) |
| 307 | { |
| 308 | mc68901_t *mc68901 = get_safe_token(device); |
| 309 | |
| 310 | if (mc68901->ipr & mc68901->imr) |
| 267 | 311 | { |
| 268 | | chip->intf->irq_callback(chip, ASSERT_LINE); |
| 312 | mc68901->intf->on_irq_changed(device, ASSERT_LINE); |
| 269 | 313 | } |
| 270 | 314 | else |
| 271 | 315 | { |
| 272 | | chip->intf->irq_callback(chip, CLEAR_LINE); |
| 316 | mc68901->intf->on_irq_changed(device, CLEAR_LINE); |
| 273 | 317 | } |
| 274 | 318 | } |
| 275 | 319 | |
| 276 | | static void mc68901_interrupt(mc68901_t *chip, UINT16 mask) |
| 320 | static void mc68901_interrupt(const device_config *device, UINT16 mask) |
| 277 | 321 | { |
| 278 | | chip->ipr |= mask; |
| 322 | mc68901_t *mc68901 = get_safe_token(device); |
| 279 | 323 | |
| 280 | | mc68901_check_interrupts(chip); |
| 324 | mc68901->ipr |= mask; |
| 325 | |
| 326 | mc68901_check_interrupts(device); |
| 281 | 327 | } |
| 282 | 328 | |
| 283 | 329 | static TIMER_CALLBACK( mc68901_gpio_poll_tick ) |
| 284 | 330 | { |
| 285 | | mc68901_t *chip = ptr; |
| 331 | const device_config *device = ptr; |
| 332 | mc68901_t *mc68901 = get_safe_token(device); |
| 286 | 333 | |
| 287 | | UINT8 gpio = chip->intf->gpio_r(machine, 0); |
| 334 | UINT8 gpio = mc68901->intf->gpio_r(device); |
| 288 | 335 | |
| 289 | | UINT8 gpold = (chip->gpip & ~chip->ddr) ^ chip->aer; |
| 290 | | UINT8 gpnew = (gpio & ~chip->ddr) ^ chip->aer; |
| 336 | UINT8 gpold = (mc68901->gpip & ~mc68901->ddr) ^ mc68901->aer; |
| 337 | UINT8 gpnew = (gpio & ~mc68901->ddr) ^ mc68901->aer; |
| 291 | 338 | |
| 292 | 339 | int bit; |
| 293 | 340 | |
| r2431 | r2432 | |
| 297 | 344 | { |
| 298 | 345 | if (LOG) logerror("MC68901 Edge Transition Detected on GPIO%u\n", bit); |
| 299 | 346 | |
| 300 | | if (chip->ier & MC68901_INT_MASK_GPIO[bit]) // AND interrupt enabled bit is set... |
| 347 | if (mc68901->ier & MC68901_INT_MASK_GPIO[bit]) // AND interrupt enabled bit is set... |
| 301 | 348 | { |
| 302 | 349 | if (LOG) logerror("MC68901 Interrupt Pending for GPIO%u\n", bit); |
| 303 | 350 | |
| 304 | | mc68901_interrupt(chip, MC68901_INT_MASK_GPIO[bit]); // set interrupt pending bit |
| 351 | mc68901_interrupt(device, MC68901_INT_MASK_GPIO[bit]); // set interrupt pending bit |
| 305 | 352 | } |
| 306 | 353 | } |
| 307 | 354 | } |
| 308 | 355 | |
| 309 | | chip->gpip = (gpio & ~chip->ddr) | (chip->gpip & chip->ddr); |
| 356 | mc68901->gpip = (gpio & ~mc68901->ddr) | (mc68901->gpip & mc68901->ddr); |
| 310 | 357 | } |
| 311 | 358 | |
| 312 | 359 | /* USART */ |
| 313 | 360 | |
| 314 | | static void mc68901_rx_buffer_full(mc68901_t *chip) |
| 361 | static void mc68901_rx_buffer_full(const device_config *device) |
| 315 | 362 | { |
| 316 | | if (chip->ier & MC68901_IR_RCV_BUFFER_FULL) |
| 363 | mc68901_t *mc68901 = get_safe_token(device); |
| 364 | |
| 365 | if (mc68901->ier & MC68901_IR_RCV_BUFFER_FULL) |
| 317 | 366 | { |
| 318 | | mc68901_interrupt(chip, MC68901_IR_RCV_BUFFER_FULL); |
| 367 | mc68901_interrupt(device, MC68901_IR_RCV_BUFFER_FULL); |
| 319 | 368 | } |
| 320 | 369 | } |
| 321 | 370 | |
| 322 | | static void mc68901_rx_error(mc68901_t *chip) |
| 371 | static void mc68901_rx_error(const device_config *device) |
| 323 | 372 | { |
| 324 | | if (chip->ier & MC68901_IR_RCV_ERROR) |
| 373 | mc68901_t *mc68901 = get_safe_token(device); |
| 374 | |
| 375 | if (mc68901->ier & MC68901_IR_RCV_ERROR) |
| 325 | 376 | { |
| 326 | | mc68901_interrupt(chip, MC68901_IR_RCV_ERROR); |
| 377 | mc68901_interrupt(device, MC68901_IR_RCV_ERROR); |
| 327 | 378 | } |
| 328 | 379 | else |
| 329 | 380 | { |
| 330 | | mc68901_rx_buffer_full(chip); |
| 381 | mc68901_rx_buffer_full(device); |
| 331 | 382 | } |
| 332 | 383 | } |
| 333 | 384 | |
| 334 | | static void mc68901_tx_buffer_empty(mc68901_t *chip) |
| 385 | static void mc68901_tx_buffer_empty(const device_config *device) |
| 335 | 386 | { |
| 336 | | if (chip->ier & MC68901_IR_XMIT_BUFFER_EMPTY) |
| 387 | mc68901_t *mc68901 = get_safe_token(device); |
| 388 | |
| 389 | if (mc68901->ier & MC68901_IR_XMIT_BUFFER_EMPTY) |
| 337 | 390 | { |
| 338 | | mc68901_interrupt(chip, MC68901_IR_XMIT_BUFFER_EMPTY); |
| 391 | mc68901_interrupt(device, MC68901_IR_XMIT_BUFFER_EMPTY); |
| 339 | 392 | } |
| 340 | 393 | } |
| 341 | 394 | |
| 342 | | static void mc68901_tx_error(mc68901_t *chip) |
| 395 | static void mc68901_tx_error(const device_config *device) |
| 343 | 396 | { |
| 344 | | if (chip->ier & MC68901_IR_XMIT_ERROR) |
| 397 | mc68901_t *mc68901 = get_safe_token(device); |
| 398 | |
| 399 | if (mc68901->ier & MC68901_IR_XMIT_ERROR) |
| 345 | 400 | { |
| 346 | | mc68901_interrupt(chip, MC68901_IR_XMIT_ERROR); |
| 401 | mc68901_interrupt(device, MC68901_IR_XMIT_ERROR); |
| 347 | 402 | } |
| 348 | 403 | else |
| 349 | 404 | { |
| 350 | | mc68901_tx_buffer_empty(chip); |
| 405 | mc68901_tx_buffer_empty(device); |
| 351 | 406 | } |
| 352 | 407 | } |
| 353 | 408 | |
| r2431 | r2432 | |
| 359 | 414 | return b & 1; |
| 360 | 415 | } |
| 361 | 416 | |
| 362 | | static void mc68901_serial_rx(mc68901_t *chip) |
| 417 | static void mc68901_serial_rx(const device_config *device) |
| 363 | 418 | { |
| 364 | | if (chip->rsr & MC68901_RSR_RCV_ENABLE) |
| 419 | mc68901_t *mc68901 = get_safe_token(device); |
| 420 | |
| 421 | if (mc68901->rsr & MC68901_RSR_RCV_ENABLE) |
| 365 | 422 | { |
| 366 | | switch (chip->rx_state) |
| 423 | switch (mc68901->rx_state) |
| 367 | 424 | { |
| 368 | 425 | case MC68901_SERIAL_START: |
| 369 | | if (chip->intf->rx_pin == 0) |
| 426 | if (mc68901->intf->rx_pin == 0) |
| 370 | 427 | { |
| 371 | | chip->rsr |= MC68901_RSR_CHAR_IN_PROGRESS; |
| 372 | | chip->rx_bits = 0; |
| 373 | | chip->rx_buffer = 0; |
| 374 | | chip->rx_state = MC68901_SERIAL_DATA; |
| 375 | | chip->next_rsr = MC68901_RSR_BREAK; |
| 428 | mc68901->rsr |= MC68901_RSR_CHAR_IN_PROGRESS; |
| 429 | mc68901->rx_bits = 0; |
| 430 | mc68901->rx_buffer = 0; |
| 431 | mc68901->rx_state = MC68901_SERIAL_DATA; |
| 432 | mc68901->next_rsr = MC68901_RSR_BREAK; |
| 376 | 433 | } |
| 377 | 434 | break; |
| 378 | 435 | |
| 379 | 436 | case MC68901_SERIAL_DATA: |
| 380 | | if ((chip->next_rsr & MC68901_RSR_BREAK) && (*chip->intf->rx_pin == 1) && chip->rsr_read) |
| 437 | if ((mc68901->next_rsr & MC68901_RSR_BREAK) && (*mc68901->intf->rx_pin == 1) && mc68901->rsr_read) |
| 381 | 438 | { |
| 382 | | chip->next_rsr &= ~MC68901_RSR_BREAK; |
| 439 | mc68901->next_rsr &= ~MC68901_RSR_BREAK; |
| 383 | 440 | } |
| 384 | 441 | |
| 385 | | chip->rx_buffer >>= 1; |
| 386 | | chip->rx_buffer |= (*chip->intf->rx_pin << 7); |
| 387 | | chip->rx_bits++; |
| 442 | mc68901->rx_buffer >>= 1; |
| 443 | mc68901->rx_buffer |= (*mc68901->intf->rx_pin << 7); |
| 444 | mc68901->rx_bits++; |
| 388 | 445 | |
| 389 | | if (chip->rx_bits == chip->rxtx_word) |
| 446 | if (mc68901->rx_bits == mc68901->rxtx_word) |
| 390 | 447 | { |
| 391 | | if (chip->rxtx_word < 8) |
| 448 | if (mc68901->rxtx_word < 8) |
| 392 | 449 | { |
| 393 | | chip->rx_buffer >>= (8 - chip->rxtx_word); |
| 450 | mc68901->rx_buffer >>= (8 - mc68901->rxtx_word); |
| 394 | 451 | } |
| 395 | 452 | |
| 396 | | chip->rsr &= ~MC68901_RSR_CHAR_IN_PROGRESS; |
| 453 | mc68901->rsr &= ~MC68901_RSR_CHAR_IN_PROGRESS; |
| 397 | 454 | |
| 398 | | if (chip->ucr & MC68901_UCR_PARITY_ENABLED) |
| 455 | if (mc68901->ucr & MC68901_UCR_PARITY_ENABLED) |
| 399 | 456 | { |
| 400 | | chip->rx_state = MC68901_SERIAL_PARITY; |
| 457 | mc68901->rx_state = MC68901_SERIAL_PARITY; |
| 401 | 458 | } |
| 402 | 459 | else |
| 403 | 460 | { |
| 404 | | chip->rx_state = MC68901_SERIAL_STOP; |
| 461 | mc68901->rx_state = MC68901_SERIAL_STOP; |
| 405 | 462 | } |
| 406 | 463 | } |
| 407 | 464 | break; |
| 408 | 465 | |
| 409 | 466 | case MC68901_SERIAL_PARITY: |
| 410 | | chip->rx_parity = *chip->intf->rx_pin; |
| 467 | mc68901->rx_parity = *mc68901->intf->rx_pin; |
| 411 | 468 | |
| 412 | | if (chip->rx_parity != (mc68901_parity(chip->rx_buffer) ^ ((chip->ucr & MC68901_UCR_PARITY_EVEN) >> 1))) |
| 469 | if (mc68901->rx_parity != (mc68901_parity(mc68901->rx_buffer) ^ ((mc68901->ucr & MC68901_UCR_PARITY_EVEN) >> 1))) |
| 413 | 470 | { |
| 414 | | chip->next_rsr |= MC68901_RSR_PARITY_ERROR; |
| 471 | mc68901->next_rsr |= MC68901_RSR_PARITY_ERROR; |
| 415 | 472 | } |
| 416 | 473 | |
| 417 | | chip->rx_state = MC68901_SERIAL_STOP; |
| 474 | mc68901->rx_state = MC68901_SERIAL_STOP; |
| 418 | 475 | break; |
| 419 | 476 | |
| 420 | 477 | case MC68901_SERIAL_STOP: |
| 421 | | if (*chip->intf->rx_pin == 1) |
| 478 | if (*mc68901->intf->rx_pin == 1) |
| 422 | 479 | { |
| 423 | | if (!((chip->rsr & MC68901_RSR_SYNC_STRIP_ENABLE) && (chip->rx_buffer == chip->scr))) |
| 480 | if (!((mc68901->rsr & MC68901_RSR_SYNC_STRIP_ENABLE) && (mc68901->rx_buffer == mc68901->scr))) |
| 424 | 481 | { |
| 425 | | if (!(chip->rsr & MC68901_RSR_OVERRUN_ERROR)) |
| 482 | if (!(mc68901->rsr & MC68901_RSR_OVERRUN_ERROR)) |
| 426 | 483 | { |
| 427 | | if (chip->rsr & MC68901_RSR_BUFFER_FULL) |
| 484 | if (mc68901->rsr & MC68901_RSR_BUFFER_FULL) |
| 428 | 485 | { |
| 429 | 486 | // incoming word received but last word in receive buffer has not been read |
| 430 | | chip->next_rsr |= MC68901_RSR_OVERRUN_ERROR; |
| 487 | mc68901->next_rsr |= MC68901_RSR_OVERRUN_ERROR; |
| 431 | 488 | } |
| 432 | 489 | else |
| 433 | 490 | { |
| 434 | 491 | // incoming word received and receive buffer is empty |
| 435 | | chip->rsr |= MC68901_RSR_BUFFER_FULL; |
| 436 | | chip->udr = chip->rx_buffer; |
| 437 | | mc68901_rx_buffer_full(chip); |
| 492 | mc68901->rsr |= MC68901_RSR_BUFFER_FULL; |
| 493 | mc68901->udr = mc68901->rx_buffer; |
| 494 | mc68901_rx_buffer_full(device); |
| 438 | 495 | } |
| 439 | 496 | } |
| 440 | 497 | } |
| 441 | 498 | } |
| 442 | 499 | else |
| 443 | 500 | { |
| 444 | | if (chip->rx_buffer) |
| 501 | if (mc68901->rx_buffer) |
| 445 | 502 | { |
| 446 | 503 | // non-zero data word not followed by a stop bit |
| 447 | | chip->next_rsr |= MC68901_RSR_FRAME_ERROR; |
| 504 | mc68901->next_rsr |= MC68901_RSR_FRAME_ERROR; |
| 448 | 505 | } |
| 449 | 506 | } |
| 450 | 507 | |
| 451 | | chip->rx_state = MC68901_SERIAL_START; |
| 508 | mc68901->rx_state = MC68901_SERIAL_START; |
| 452 | 509 | break; |
| 453 | 510 | } |
| 454 | 511 | } |
| r2431 | r2432 | |
| 456 | 513 | |
| 457 | 514 | static TIMER_CALLBACK( rx_tick ) |
| 458 | 515 | { |
| 459 | | mc68901_serial_rx(ptr); |
| 516 | const device_config *device = ptr; |
| 517 | |
| 518 | mc68901_serial_rx(device); |
| 460 | 519 | } |
| 461 | 520 | |
| 462 | | static void mc68901_transmit_disabled(mc68901_t *chip) |
| 521 | static void mc68901_transmit_disabled(const device_config *device) |
| 463 | 522 | { |
| 464 | | switch (chip->tsr & MC68901_TSR_OUTPUT_MASK) |
| 523 | mc68901_t *mc68901 = get_safe_token(device); |
| 524 | |
| 525 | switch (mc68901->tsr & MC68901_TSR_OUTPUT_MASK) |
| 465 | 526 | { |
| 466 | 527 | case MC68901_TSR_OUTPUT_HI_Z: |
| 467 | 528 | // indeterminate |
| 468 | 529 | case MC68901_TSR_OUTPUT_LOW: |
| 469 | | *chip->intf->tx_pin = 0; |
| 530 | *mc68901->intf->tx_pin = 0; |
| 470 | 531 | break; |
| 471 | 532 | |
| 472 | 533 | case MC68901_TSR_OUTPUT_HIGH: |
| 473 | 534 | case MC68901_TSR_OUTPUT_LOOP: |
| 474 | | *chip->intf->tx_pin = 1; |
| 535 | *mc68901->intf->tx_pin = 1; |
| 475 | 536 | break; |
| 476 | 537 | } |
| 477 | 538 | } |
| 478 | 539 | |
| 479 | | static void mc68901_transmit(mc68901_t *chip) |
| 540 | static void mc68901_transmit(const device_config *device) |
| 480 | 541 | { |
| 481 | | switch (chip->tx_state) |
| 542 | mc68901_t *mc68901 = get_safe_token(device); |
| 543 | |
| 544 | switch (mc68901->tx_state) |
| 482 | 545 | { |
| 483 | 546 | case MC68901_SERIAL_START: |
| 484 | | if (chip->tsr & MC68901_TSR_UNDERRUN_ERROR) |
| 547 | if (mc68901->tsr & MC68901_TSR_UNDERRUN_ERROR) |
| 485 | 548 | { |
| 486 | | if (chip->tsr & MC68901_TSR_XMIT_ENABLE) |
| 549 | if (mc68901->tsr & MC68901_TSR_XMIT_ENABLE) |
| 487 | 550 | { |
| 488 | | *chip->intf->tx_pin = 1; |
| 551 | *mc68901->intf->tx_pin = 1; |
| 489 | 552 | } |
| 490 | 553 | else |
| 491 | 554 | { |
| 492 | | mc68901_transmit_disabled(chip); |
| 555 | mc68901_transmit_disabled(device); |
| 493 | 556 | } |
| 494 | 557 | } |
| 495 | 558 | else |
| 496 | 559 | { |
| 497 | | if (chip->tsr & MC68901_TSR_BUFFER_EMPTY) |
| 560 | if (mc68901->tsr & MC68901_TSR_BUFFER_EMPTY) |
| 498 | 561 | { |
| 499 | | chip->tsr |= MC68901_TSR_UNDERRUN_ERROR; |
| 562 | mc68901->tsr |= MC68901_TSR_UNDERRUN_ERROR; |
| 500 | 563 | |
| 501 | | if (chip->tsr & MC68901_TSR_XMIT_ENABLE) |
| 564 | if (mc68901->tsr & MC68901_TSR_XMIT_ENABLE) |
| 502 | 565 | { |
| 503 | | *chip->intf->tx_pin = 1; |
| 566 | *mc68901->intf->tx_pin = 1; |
| 504 | 567 | } |
| 505 | 568 | else |
| 506 | 569 | { |
| 507 | | mc68901_transmit_disabled(chip); |
| 570 | mc68901_transmit_disabled(device); |
| 508 | 571 | } |
| 509 | 572 | } |
| 510 | 573 | else |
| 511 | 574 | { |
| 512 | | *chip->intf->tx_pin = 0; |
| 513 | | chip->tx_buffer = chip->udr; |
| 514 | | chip->tx_bits = 0; |
| 515 | | chip->tx_state = MC68901_SERIAL_DATA; |
| 516 | | chip->tsr |= MC68901_TSR_BUFFER_EMPTY; |
| 517 | | mc68901_tx_buffer_empty(chip); |
| 518 | | chip->tx_parity = mc68901_parity(chip->tx_buffer); |
| 575 | *mc68901->intf->tx_pin = 0; |
| 576 | mc68901->tx_buffer = mc68901->udr; |
| 577 | mc68901->tx_bits = 0; |
| 578 | mc68901->tx_state = MC68901_SERIAL_DATA; |
| 579 | mc68901->tsr |= MC68901_TSR_BUFFER_EMPTY; |
| 580 | mc68901_tx_buffer_empty(device); |
| 581 | mc68901->tx_parity = mc68901_parity(mc68901->tx_buffer); |
| 519 | 582 | } |
| 520 | 583 | } |
| 521 | 584 | break; |
| 522 | 585 | |
| 523 | 586 | case MC68901_SERIAL_DATA: |
| 524 | | *chip->intf->tx_pin = chip->tx_buffer & 0x01; |
| 525 | | chip->tx_buffer >>= 1; |
| 526 | | chip->tx_bits++; |
| 587 | *mc68901->intf->tx_pin = mc68901->tx_buffer & 0x01; |
| 588 | mc68901->tx_buffer >>= 1; |
| 589 | mc68901->tx_bits++; |
| 527 | 590 | |
| 528 | | if (chip->tx_bits == chip->rxtx_word) |
| 591 | if (mc68901->tx_bits == mc68901->rxtx_word) |
| 529 | 592 | { |
| 530 | | if (chip->ucr & MC68901_UCR_PARITY_ENABLED) |
| 593 | if (mc68901->ucr & MC68901_UCR_PARITY_ENABLED) |
| 531 | 594 | { |
| 532 | | chip->tx_state = MC68901_SERIAL_PARITY; |
| 595 | mc68901->tx_state = MC68901_SERIAL_PARITY; |
| 533 | 596 | } |
| 534 | 597 | else |
| 535 | 598 | { |
| 536 | | chip->tx_state = MC68901_SERIAL_STOP; |
| 599 | mc68901->tx_state = MC68901_SERIAL_STOP; |
| 537 | 600 | } |
| 538 | 601 | } |
| 539 | 602 | break; |
| 540 | 603 | |
| 541 | 604 | case MC68901_SERIAL_PARITY: |
| 542 | | if (chip->rxtx_word < 8) |
| 605 | if (mc68901->rxtx_word < 8) |
| 543 | 606 | { |
| 544 | 607 | // highest bit in buffer is user-specified parity bit |
| 545 | 608 | |
| 546 | | *chip->intf->tx_pin = chip->tx_buffer & 0x01; |
| 609 | *mc68901->intf->tx_pin = mc68901->tx_buffer & 0x01; |
| 547 | 610 | } |
| 548 | 611 | else |
| 549 | 612 | { |
| 550 | 613 | // use previously calculated parity |
| 551 | 614 | |
| 552 | | *chip->intf->tx_pin = chip->tx_parity ^ ((chip->ucr & MC68901_UCR_PARITY_EVEN) >> 1); |
| 615 | *mc68901->intf->tx_pin = mc68901->tx_parity ^ ((mc68901->ucr & MC68901_UCR_PARITY_EVEN) >> 1); |
| 553 | 616 | } |
| 554 | 617 | |
| 555 | | chip->tx_state = MC68901_SERIAL_STOP; |
| 618 | mc68901->tx_state = MC68901_SERIAL_STOP; |
| 556 | 619 | break; |
| 557 | 620 | |
| 558 | 621 | case MC68901_SERIAL_STOP: |
| 559 | | *chip->intf->tx_pin = 1; |
| 622 | *mc68901->intf->tx_pin = 1; |
| 560 | 623 | |
| 561 | | if (chip->tsr & MC68901_TSR_XMIT_ENABLE) |
| 624 | if (mc68901->tsr & MC68901_TSR_XMIT_ENABLE) |
| 562 | 625 | { |
| 563 | | chip->tx_state = MC68901_SERIAL_START; |
| 626 | mc68901->tx_state = MC68901_SERIAL_START; |
| 564 | 627 | } |
| 565 | 628 | else |
| 566 | 629 | { |
| 567 | | if (chip->tsr & MC68901_TSR_AUTO_TURNAROUND) |
| 630 | if (mc68901->tsr & MC68901_TSR_AUTO_TURNAROUND) |
| 568 | 631 | { |
| 569 | | chip->tsr |= MC68901_TSR_XMIT_ENABLE; |
| 570 | | chip->tx_state = MC68901_SERIAL_START; |
| 632 | mc68901->tsr |= MC68901_TSR_XMIT_ENABLE; |
| 633 | mc68901->tx_state = MC68901_SERIAL_START; |
| 571 | 634 | } |
| 572 | 635 | else |
| 573 | 636 | { |
| 574 | | chip->xmit_state = MC68901_XMIT_OFF; |
| 575 | | chip->tsr |= MC68901_TSR_END_OF_XMIT; |
| 576 | | mc68901_tx_error(chip); |
| 637 | mc68901->xmit_state = MC68901_XMIT_OFF; |
| 638 | mc68901->tsr |= MC68901_TSR_END_OF_XMIT; |
| 639 | mc68901_tx_error(device); |
| 577 | 640 | } |
| 578 | 641 | } |
| 579 | 642 | break; |
| 580 | 643 | } |
| 581 | 644 | } |
| 582 | 645 | |
| 583 | | static void mc68901_serial_tx(mc68901_t *chip) |
| 646 | static void mc68901_serial_tx(const device_config *device) |
| 584 | 647 | { |
| 585 | | switch (chip->xmit_state) |
| 648 | mc68901_t *mc68901 = get_safe_token(device); |
| 649 | |
| 650 | switch (mc68901->xmit_state) |
| 586 | 651 | { |
| 587 | 652 | case MC68901_XMIT_OFF: |
| 588 | | mc68901_transmit_disabled(chip); |
| 653 | mc68901_transmit_disabled(device); |
| 589 | 654 | break; |
| 590 | 655 | |
| 591 | 656 | case MC68901_XMIT_STARTING: |
| 592 | | if (chip->tsr & MC68901_TSR_XMIT_ENABLE) |
| 657 | if (mc68901->tsr & MC68901_TSR_XMIT_ENABLE) |
| 593 | 658 | { |
| 594 | | *chip->intf->tx_pin = 1; |
| 595 | | chip->xmit_state = MC68901_XMIT_ON; |
| 659 | *mc68901->intf->tx_pin = 1; |
| 660 | mc68901->xmit_state = MC68901_XMIT_ON; |
| 596 | 661 | } |
| 597 | 662 | else |
| 598 | 663 | { |
| 599 | | chip->xmit_state = MC68901_XMIT_OFF; |
| 600 | | chip->tsr |= MC68901_TSR_END_OF_XMIT; |
| 664 | mc68901->xmit_state = MC68901_XMIT_OFF; |
| 665 | mc68901->tsr |= MC68901_TSR_END_OF_XMIT; |
| 601 | 666 | } |
| 602 | 667 | break; |
| 603 | 668 | |
| 604 | 669 | case MC68901_XMIT_BREAK: |
| 605 | | if (chip->tsr & MC68901_TSR_XMIT_ENABLE) |
| 670 | if (mc68901->tsr & MC68901_TSR_XMIT_ENABLE) |
| 606 | 671 | { |
| 607 | | if (chip->tsr & MC68901_TSR_BREAK) |
| 672 | if (mc68901->tsr & MC68901_TSR_BREAK) |
| 608 | 673 | { |
| 609 | | *chip->intf->tx_pin = 1; |
| 674 | *mc68901->intf->tx_pin = 1; |
| 610 | 675 | } |
| 611 | 676 | else |
| 612 | 677 | { |
| 613 | | chip->xmit_state = MC68901_XMIT_ON; |
| 678 | mc68901->xmit_state = MC68901_XMIT_ON; |
| 614 | 679 | } |
| 615 | 680 | } |
| 616 | 681 | else |
| 617 | 682 | { |
| 618 | | chip->xmit_state = MC68901_XMIT_OFF; |
| 619 | | chip->tsr |= MC68901_TSR_END_OF_XMIT; |
| 683 | mc68901->xmit_state = MC68901_XMIT_OFF; |
| 684 | mc68901->tsr |= MC68901_TSR_END_OF_XMIT; |
| 620 | 685 | } |
| 621 | 686 | break; |
| 622 | 687 | |
| 623 | 688 | case MC68901_XMIT_ON: |
| 624 | | mc68901_transmit(chip); |
| 689 | mc68901_transmit(device); |
| 625 | 690 | break; |
| 626 | 691 | } |
| 627 | 692 | } |
| 628 | 693 | |
| 629 | 694 | static TIMER_CALLBACK( tx_tick ) |
| 630 | 695 | { |
| 631 | | mc68901_serial_tx(ptr); |
| 696 | const device_config *device = ptr; |
| 697 | |
| 698 | mc68901_serial_tx(device); |
| 632 | 699 | } |
| 633 | 700 | |
| 634 | | UINT8 mc68901_register_r(mc68901_t *chip, int reg) |
| 701 | /* Register Access */ |
| 702 | |
| 703 | READ8_DEVICE_HANDLER( mc68901_register_r ) |
| 635 | 704 | { |
| 636 | | assert(chip != NULL); |
| 705 | mc68901_t *mc68901 = get_safe_token(device); |
| 637 | 706 | |
| 638 | | switch (reg) |
| 707 | assert(mc68901 != NULL); |
| 708 | |
| 709 | switch (offset) |
| 639 | 710 | { |
| 640 | | case MC68901_REGISTER_GPIP: return chip->gpip; |
| 641 | | case MC68901_REGISTER_AER: return chip->aer; |
| 642 | | case MC68901_REGISTER_DDR: return chip->ddr; |
| 711 | case MC68901_REGISTER_GPIP: return mc68901->gpip; |
| 712 | case MC68901_REGISTER_AER: return mc68901->aer; |
| 713 | case MC68901_REGISTER_DDR: return mc68901->ddr; |
| 643 | 714 | |
| 644 | | case MC68901_REGISTER_IERA: return chip->ier >> 8; |
| 645 | | case MC68901_REGISTER_IERB: return chip->ier & 0xff; |
| 646 | | case MC68901_REGISTER_IPRA: return chip->ipr >> 8; |
| 647 | | case MC68901_REGISTER_IPRB: return chip->ipr & 0xff; |
| 648 | | case MC68901_REGISTER_ISRA: return chip->isr >> 8; |
| 649 | | case MC68901_REGISTER_ISRB: return chip->isr & 0xff; |
| 650 | | case MC68901_REGISTER_IMRA: return chip->imr >> 8; |
| 651 | | case MC68901_REGISTER_IMRB: return chip->imr & 0xff; |
| 652 | | case MC68901_REGISTER_VR: return chip->vr; |
| 715 | case MC68901_REGISTER_IERA: return mc68901->ier >> 8; |
| 716 | case MC68901_REGISTER_IERB: return mc68901->ier & 0xff; |
| 717 | case MC68901_REGISTER_IPRA: return mc68901->ipr >> 8; |
| 718 | case MC68901_REGISTER_IPRB: return mc68901->ipr & 0xff; |
| 719 | case MC68901_REGISTER_ISRA: return mc68901->isr >> 8; |
| 720 | case MC68901_REGISTER_ISRB: return mc68901->isr & 0xff; |
| 721 | case MC68901_REGISTER_IMRA: return mc68901->imr >> 8; |
| 722 | case MC68901_REGISTER_IMRB: return mc68901->imr & 0xff; |
| 723 | case MC68901_REGISTER_VR: return mc68901->vr; |
| 653 | 724 | |
| 654 | | case MC68901_REGISTER_TACR: return chip->tacr; |
| 655 | | case MC68901_REGISTER_TBCR: return chip->tbcr; |
| 656 | | case MC68901_REGISTER_TCDCR: return chip->tcdcr; |
| 657 | | case MC68901_REGISTER_TADR: return chip->tmc[MC68901_TIMER_A]; |
| 658 | | case MC68901_REGISTER_TBDR: return chip->tmc[MC68901_TIMER_B]; |
| 659 | | case MC68901_REGISTER_TCDR: return chip->tmc[MC68901_TIMER_C]; |
| 660 | | case MC68901_REGISTER_TDDR: return chip->tmc[MC68901_TIMER_D]; |
| 725 | case MC68901_REGISTER_TACR: return mc68901->tacr; |
| 726 | case MC68901_REGISTER_TBCR: return mc68901->tbcr; |
| 727 | case MC68901_REGISTER_TCDCR: return mc68901->tcdcr; |
| 728 | case MC68901_REGISTER_TADR: return mc68901->tmc[MC68901_TIMER_A]; |
| 729 | case MC68901_REGISTER_TBDR: return mc68901->tmc[MC68901_TIMER_B]; |
| 730 | case MC68901_REGISTER_TCDR: return mc68901->tmc[MC68901_TIMER_C]; |
| 731 | case MC68901_REGISTER_TDDR: return mc68901->tmc[MC68901_TIMER_D]; |
| 661 | 732 | |
| 662 | | case MC68901_REGISTER_SCR: return chip->scr; |
| 663 | | case MC68901_REGISTER_UCR: return chip->ucr; |
| 733 | case MC68901_REGISTER_SCR: return mc68901->scr; |
| 734 | case MC68901_REGISTER_UCR: return mc68901->ucr; |
| 664 | 735 | case MC68901_REGISTER_RSR: |
| 665 | | chip->rsr_read = 1; |
| 666 | | return chip->rsr; |
| 736 | mc68901->rsr_read = 1; |
| 737 | return mc68901->rsr; |
| 667 | 738 | |
| 668 | 739 | case MC68901_REGISTER_TSR: |
| 669 | 740 | { |
| 670 | 741 | // clear UE bit (in reality, this won't be cleared until one full clock cycle of the transmitter has passed since the bit was set) |
| 671 | 742 | |
| 672 | | UINT8 tsr = chip->tsr; |
| 673 | | chip->tsr &= 0xbf; |
| 743 | UINT8 tsr = mc68901->tsr; |
| 744 | mc68901->tsr &= 0xbf; |
| 674 | 745 | |
| 675 | 746 | return tsr; |
| 676 | 747 | } |
| r2431 | r2432 | |
| 678 | 749 | case MC68901_REGISTER_UDR: |
| 679 | 750 | // load RSR with latched value |
| 680 | 751 | |
| 681 | | chip->rsr = (chip->next_rsr & 0x7c) | (chip->rsr & 0x03); |
| 682 | | chip->next_rsr = 0; |
| 752 | mc68901->rsr = (mc68901->next_rsr & 0x7c) | (mc68901->rsr & 0x03); |
| 753 | mc68901->next_rsr = 0; |
| 683 | 754 | |
| 684 | 755 | // signal receiver error interrupt |
| 685 | 756 | |
| 686 | | if (chip->rsr & 0x78) |
| 757 | if (mc68901->rsr & 0x78) |
| 687 | 758 | { |
| 688 | | mc68901_rx_error(chip); |
| 759 | mc68901_rx_error(device); |
| 689 | 760 | } |
| 690 | 761 | |
| 691 | | return chip->udr; |
| 762 | return mc68901->udr; |
| 692 | 763 | |
| 693 | 764 | default: return 0; |
| 694 | 765 | } |
| r2431 | r2432 | |
| 696 | 767 | |
| 697 | 768 | #define DIVISOR PRESCALER[data & 0x07] |
| 698 | 769 | |
| 699 | | void mc68901_register_w(mc68901_t *chip, int reg, UINT8 data) |
| 770 | WRITE8_DEVICE_HANDLER( mc68901_register_w ) |
| 700 | 771 | { |
| 701 | | assert(chip != NULL); |
| 772 | mc68901_t *mc68901 = get_safe_token(device); |
| 702 | 773 | |
| 703 | | switch (reg) |
| 774 | switch (offset) |
| 704 | 775 | { |
| 705 | 776 | case MC68901_REGISTER_GPIP: |
| 706 | 777 | if (LOG) logerror("MC68901 General Purpose I/O : %x\n", data); |
| 707 | | chip->gpip = data & chip->ddr; |
| 778 | mc68901->gpip = data & mc68901->ddr; |
| 708 | 779 | |
| 709 | | if (chip->intf->gpio_w) |
| 780 | if (mc68901->intf->gpio_w) |
| 710 | 781 | { |
| 711 | | chip->intf->gpio_w(Machine, 0, chip->gpip); |
| 782 | mc68901->intf->gpio_w(device, mc68901->gpip); |
| 712 | 783 | } |
| 713 | 784 | break; |
| 714 | 785 | |
| 715 | 786 | case MC68901_REGISTER_AER: |
| 716 | 787 | if (LOG) logerror("MC68901 Active Edge Register : %x\n", data); |
| 717 | | chip->aer = data; |
| 788 | mc68901->aer = data; |
| 718 | 789 | break; |
| 719 | 790 | |
| 720 | 791 | case MC68901_REGISTER_DDR: |
| 721 | 792 | if (LOG) logerror("MC68901 Data Direction Register : %x\n", data); |
| 722 | | chip->ddr = data; |
| 793 | mc68901->ddr = data; |
| 723 | 794 | break; |
| 724 | 795 | |
| 725 | 796 | case MC68901_REGISTER_IERA: |
| 726 | 797 | if (LOG) logerror("MC68901 Interrupt Enable Register A : %x\n", data); |
| 727 | | chip->ier = (data << 8) | (chip->ier & 0xff); |
| 728 | | chip->ipr &= chip->ier; |
| 729 | | mc68901_check_interrupts(chip); |
| 798 | mc68901->ier = (data << 8) | (mc68901->ier & 0xff); |
| 799 | mc68901->ipr &= mc68901->ier; |
| 800 | mc68901_check_interrupts(device); |
| 730 | 801 | break; |
| 731 | 802 | |
| 732 | 803 | case MC68901_REGISTER_IERB: |
| 733 | 804 | if (LOG) logerror("MC68901 Interrupt Enable Register B : %x\n", data); |
| 734 | | chip->ier = (chip->ier & 0xff00) | data; |
| 735 | | chip->ipr &= chip->ier; |
| 736 | | mc68901_check_interrupts(chip); |
| 805 | mc68901->ier = (mc68901->ier & 0xff00) | data; |
| 806 | mc68901->ipr &= mc68901->ier; |
| 807 | mc68901_check_interrupts(device); |
| 737 | 808 | break; |
| 738 | 809 | |
| 739 | 810 | case MC68901_REGISTER_IPRA: |
| 740 | 811 | if (LOG) logerror("MC68901 Interrupt Pending Register A : %x\n", data); |
| 741 | | chip->ipr &= (data << 8) | (chip->ipr & 0xff); |
| 742 | | mc68901_check_interrupts(chip); |
| 812 | mc68901->ipr &= (data << 8) | (mc68901->ipr & 0xff); |
| 813 | mc68901_check_interrupts(device); |
| 743 | 814 | break; |
| 744 | 815 | |
| 745 | 816 | case MC68901_REGISTER_IPRB: |
| 746 | 817 | if (LOG) logerror("MC68901 Interrupt Pending Register B : %x\n", data); |
| 747 | | chip->ipr &= (chip->ipr & 0xff00) | data; |
| 748 | | mc68901_check_interrupts(chip); |
| 818 | mc68901->ipr &= (mc68901->ipr & 0xff00) | data; |
| 819 | mc68901_check_interrupts(device); |
| 749 | 820 | break; |
| 750 | 821 | |
| 751 | 822 | case MC68901_REGISTER_ISRA: |
| 752 | 823 | if (LOG) logerror("MC68901 Interrupt In-Service Register A : %x\n", data); |
| 753 | | chip->isr &= (data << 8) | (chip->isr & 0xff); |
| 824 | mc68901->isr &= (data << 8) | (mc68901->isr & 0xff); |
| 754 | 825 | break; |
| 755 | 826 | |
| 756 | 827 | case MC68901_REGISTER_ISRB: |
| 757 | 828 | if (LOG) logerror("MC68901 Interrupt In-Service Register B : %x\n", data); |
| 758 | | chip->isr &= (chip->isr & 0xff00) | data; |
| 829 | mc68901->isr &= (mc68901->isr & 0xff00) | data; |
| 759 | 830 | break; |
| 760 | 831 | |
| 761 | 832 | case MC68901_REGISTER_IMRA: |
| 762 | 833 | if (LOG) logerror("MC68901 Interrupt Mask Register A : %x\n", data); |
| 763 | | chip->imr = (data << 8) | (chip->imr & 0xff); |
| 764 | | chip->isr &= chip->imr; |
| 765 | | mc68901_check_interrupts(chip); |
| 834 | mc68901->imr = (data << 8) | (mc68901->imr & 0xff); |
| 835 | mc68901->isr &= mc68901->imr; |
| 836 | mc68901_check_interrupts(device); |
| 766 | 837 | break; |
| 767 | 838 | |
| 768 | 839 | case MC68901_REGISTER_IMRB: |
| 769 | 840 | if (LOG) logerror("MC68901 Interrupt Mask Register B : %x\n", data); |
| 770 | | chip->imr = (chip->imr & 0xff00) | data; |
| 771 | | chip->isr &= chip->imr; |
| 772 | | mc68901_check_interrupts(chip); |
| 841 | mc68901->imr = (mc68901->imr & 0xff00) | data; |
| 842 | mc68901->isr &= mc68901->imr; |
| 843 | mc68901_check_interrupts(device); |
| 773 | 844 | break; |
| 774 | 845 | |
| 775 | 846 | case MC68901_REGISTER_VR: |
| 776 | 847 | if (LOG) logerror("MC68901 Interrupt Vector : %x\n", data & 0xf0); |
| 777 | 848 | |
| 778 | | chip->vr = data & 0xf8; |
| 849 | mc68901->vr = data & 0xf8; |
| 779 | 850 | |
| 780 | | if (chip->vr & MC68901_VR_S) |
| 851 | if (mc68901->vr & MC68901_VR_S) |
| 781 | 852 | { |
| 782 | 853 | if (LOG) logerror("MC68901 Software End-Of-Interrupt Mode\n"); |
| 783 | 854 | } |
| r2431 | r2432 | |
| 785 | 856 | { |
| 786 | 857 | if (LOG) logerror("MC68901 Automatic End-Of-Interrupt Mode\n"); |
| 787 | 858 | |
| 788 | | chip->isr = 0; |
| 859 | mc68901->isr = 0; |
| 789 | 860 | } |
| 790 | 861 | break; |
| 791 | 862 | |
| 792 | 863 | case MC68901_REGISTER_TACR: |
| 793 | | chip->tacr = data & 0x1f; |
| 864 | mc68901->tacr = data & 0x1f; |
| 794 | 865 | |
| 795 | | switch (chip->tacr & 0x0f) |
| 866 | switch (mc68901->tacr & 0x0f) |
| 796 | 867 | { |
| 797 | 868 | case MC68901_TCR_TIMER_STOPPED: |
| 798 | 869 | if (LOG) logerror("MC68901 Timer A Stopped\n"); |
| 799 | | timer_enable(chip->timer[MC68901_TIMER_A], 0); |
| 870 | timer_enable(mc68901->timer[MC68901_TIMER_A], 0); |
| 800 | 871 | break; |
| 801 | 872 | |
| 802 | 873 | case MC68901_TCR_TIMER_DELAY_4: |
| r2431 | r2432 | |
| 807 | 878 | case MC68901_TCR_TIMER_DELAY_100: |
| 808 | 879 | case MC68901_TCR_TIMER_DELAY_200: |
| 809 | 880 | { |
| 810 | | int divisor = PRESCALER[chip->tacr & 0x07]; |
| 881 | int divisor = PRESCALER[mc68901->tacr & 0x07]; |
| 811 | 882 | if (LOG) logerror("MC68901 Timer A Delay Mode : %u Prescale\n", divisor); |
| 812 | | timer_adjust_periodic(chip->timer[MC68901_TIMER_A], ATTOTIME_IN_HZ(chip->intf->timer_clock / divisor), 0, ATTOTIME_IN_HZ(chip->intf->timer_clock / divisor)); |
| 883 | timer_adjust_periodic(mc68901->timer[MC68901_TIMER_A], ATTOTIME_IN_HZ(mc68901->intf->timer_clock / divisor), 0, ATTOTIME_IN_HZ(mc68901->intf->timer_clock / divisor)); |
| 813 | 884 | } |
| 814 | 885 | break; |
| 815 | 886 | |
| 816 | 887 | case MC68901_TCR_TIMER_EVENT: |
| 817 | 888 | if (LOG) logerror("MC68901 Timer A Event Count Mode\n"); |
| 818 | | timer_enable(chip->timer[MC68901_TIMER_A], 0); |
| 889 | timer_enable(mc68901->timer[MC68901_TIMER_A], 0); |
| 819 | 890 | break; |
| 820 | 891 | |
| 821 | 892 | case MC68901_TCR_TIMER_PULSE_4: |
| r2431 | r2432 | |
| 826 | 897 | case MC68901_TCR_TIMER_PULSE_100: |
| 827 | 898 | case MC68901_TCR_TIMER_PULSE_200: |
| 828 | 899 | { |
| 829 | | int divisor = PRESCALER[chip->tacr & 0x07]; |
| 900 | int divisor = PRESCALER[mc68901->tacr & 0x07]; |
| 830 | 901 | if (LOG) logerror("MC68901 Timer A Pulse Width Mode : %u Prescale\n", divisor); |
| 831 | | timer_adjust_periodic(chip->timer[MC68901_TIMER_A], attotime_never, 0, ATTOTIME_IN_HZ(chip->intf->timer_clock / divisor)); |
| 832 | | timer_enable(chip->timer[MC68901_TIMER_A], 0); |
| 902 | timer_adjust_periodic(mc68901->timer[MC68901_TIMER_A], attotime_never, 0, ATTOTIME_IN_HZ(mc68901->intf->timer_clock / divisor)); |
| 903 | timer_enable(mc68901->timer[MC68901_TIMER_A], 0); |
| 833 | 904 | } |
| 834 | 905 | break; |
| 835 | 906 | } |
| 836 | 907 | |
| 837 | | if (chip->tacr & MC68901_TCR_TIMER_RESET) |
| 908 | if (mc68901->tacr & MC68901_TCR_TIMER_RESET) |
| 838 | 909 | { |
| 839 | 910 | if (LOG) logerror("MC68901 Timer A Reset\n"); |
| 840 | 911 | |
| 841 | | chip->to[MC68901_TIMER_A] = 0; |
| 912 | mc68901->to[MC68901_TIMER_A] = 0; |
| 842 | 913 | |
| 843 | | if (chip->intf->to_w) |
| 914 | if (mc68901->intf->on_to_changed) |
| 844 | 915 | { |
| 845 | | chip->intf->to_w(chip, MC68901_TIMER_A, chip->to[MC68901_TIMER_A]); |
| 916 | mc68901->intf->on_to_changed(device, MC68901_TIMER_A, mc68901->to[MC68901_TIMER_A]); |
| 846 | 917 | } |
| 847 | 918 | } |
| 848 | 919 | break; |
| 849 | 920 | |
| 850 | 921 | case MC68901_REGISTER_TBCR: |
| 851 | | chip->tbcr = data & 0x1f; |
| 922 | mc68901->tbcr = data & 0x1f; |
| 852 | 923 | |
| 853 | | switch (chip->tbcr & 0x0f) |
| 924 | switch (mc68901->tbcr & 0x0f) |
| 854 | 925 | { |
| 855 | 926 | case MC68901_TCR_TIMER_STOPPED: |
| 856 | 927 | if (LOG) logerror("MC68901 Timer B Stopped\n"); |
| 857 | | timer_enable(chip->timer[MC68901_TIMER_B], 0); |
| 928 | timer_enable(mc68901->timer[MC68901_TIMER_B], 0); |
| 858 | 929 | break; |
| 859 | 930 | |
| 860 | 931 | case MC68901_TCR_TIMER_DELAY_4: |
| r2431 | r2432 | |
| 865 | 936 | case MC68901_TCR_TIMER_DELAY_100: |
| 866 | 937 | case MC68901_TCR_TIMER_DELAY_200: |
| 867 | 938 | { |
| 868 | | int divisor = PRESCALER[chip->tbcr & 0x07]; |
| 939 | int divisor = PRESCALER[mc68901->tbcr & 0x07]; |
| 869 | 940 | if (LOG) logerror("MC68901 Timer B Delay Mode : %u Prescale\n", divisor); |
| 870 | | timer_adjust_periodic(chip->timer[MC68901_TIMER_B], ATTOTIME_IN_HZ(chip->intf->timer_clock / divisor), 0, ATTOTIME_IN_HZ(chip->intf->timer_clock / divisor)); |
| 941 | timer_adjust_periodic(mc68901->timer[MC68901_TIMER_B], ATTOTIME_IN_HZ(mc68901->intf->timer_clock / divisor), 0, ATTOTIME_IN_HZ(mc68901->intf->timer_clock / divisor)); |
| 871 | 942 | } |
| 872 | 943 | break; |
| 873 | 944 | |
| 874 | 945 | case MC68901_TCR_TIMER_EVENT: |
| 875 | 946 | if (LOG) logerror("MC68901 Timer B Event Count Mode\n"); |
| 876 | | timer_enable(chip->timer[MC68901_TIMER_B], 0); |
| 947 | timer_enable(mc68901->timer[MC68901_TIMER_B], 0); |
| 877 | 948 | break; |
| 878 | 949 | |
| 879 | 950 | case MC68901_TCR_TIMER_PULSE_4: |
| r2431 | r2432 | |
| 884 | 955 | case MC68901_TCR_TIMER_PULSE_100: |
| 885 | 956 | case MC68901_TCR_TIMER_PULSE_200: |
| 886 | 957 | { |
| 887 | | int divisor = PRESCALER[chip->tbcr & 0x07]; |
| 958 | int divisor = PRESCALER[mc68901->tbcr & 0x07]; |
| 888 | 959 | if (LOG) logerror("MC68901 Timer B Pulse Width Mode : %u Prescale\n", DIVISOR); |
| 889 | | timer_adjust_periodic(chip->timer[MC68901_TIMER_B], attotime_never, 0, ATTOTIME_IN_HZ(chip->intf->timer_clock / divisor)); |
| 890 | | timer_enable(chip->timer[MC68901_TIMER_B], 0); |
| 960 | timer_adjust_periodic(mc68901->timer[MC68901_TIMER_B], attotime_never, 0, ATTOTIME_IN_HZ(mc68901->intf->timer_clock / divisor)); |
| 961 | timer_enable(mc68901->timer[MC68901_TIMER_B], 0); |
| 891 | 962 | } |
| 892 | 963 | break; |
| 893 | 964 | } |
| 894 | 965 | |
| 895 | | if (chip->tacr & MC68901_TCR_TIMER_RESET) |
| 966 | if (mc68901->tacr & MC68901_TCR_TIMER_RESET) |
| 896 | 967 | { |
| 897 | 968 | if (LOG) logerror("MC68901 Timer B Reset\n"); |
| 898 | 969 | |
| 899 | | chip->to[MC68901_TIMER_B] = 0; |
| 970 | mc68901->to[MC68901_TIMER_B] = 0; |
| 900 | 971 | |
| 901 | | if (chip->intf->to_w) |
| 972 | if (mc68901->intf->on_to_changed) |
| 902 | 973 | { |
| 903 | | chip->intf->to_w(chip, MC68901_TIMER_B, chip->to[MC68901_TIMER_B]); |
| 974 | mc68901->intf->on_to_changed(device, MC68901_TIMER_B, mc68901->to[MC68901_TIMER_B]); |
| 904 | 975 | } |
| 905 | 976 | } |
| 906 | 977 | break; |
| 907 | 978 | |
| 908 | 979 | case MC68901_REGISTER_TCDCR: |
| 909 | | chip->tcdcr = data & 0x6f; |
| 980 | mc68901->tcdcr = data & 0x6f; |
| 910 | 981 | |
| 911 | | switch (chip->tcdcr & 0x07) |
| 982 | switch (mc68901->tcdcr & 0x07) |
| 912 | 983 | { |
| 913 | 984 | case MC68901_TCR_TIMER_STOPPED: |
| 914 | 985 | if (LOG) logerror("MC68901 Timer D Stopped\n"); |
| 915 | | timer_enable(chip->timer[MC68901_TIMER_D], 0); |
| 986 | timer_enable(mc68901->timer[MC68901_TIMER_D], 0); |
| 916 | 987 | break; |
| 917 | 988 | |
| 918 | 989 | case MC68901_TCR_TIMER_DELAY_4: |
| r2431 | r2432 | |
| 923 | 994 | case MC68901_TCR_TIMER_DELAY_100: |
| 924 | 995 | case MC68901_TCR_TIMER_DELAY_200: |
| 925 | 996 | { |
| 926 | | int divisor = PRESCALER[chip->tcdcr & 0x07]; |
| 997 | int divisor = PRESCALER[mc68901->tcdcr & 0x07]; |
| 927 | 998 | if (LOG) logerror("MC68901 Timer D Delay Mode : %u Prescale\n", divisor); |
| 928 | | timer_adjust_periodic(chip->timer[MC68901_TIMER_D], ATTOTIME_IN_HZ(chip->intf->timer_clock / divisor), 0, ATTOTIME_IN_HZ(chip->intf->timer_clock / divisor)); |
| 999 | timer_adjust_periodic(mc68901->timer[MC68901_TIMER_D], ATTOTIME_IN_HZ(mc68901->intf->timer_clock / divisor), 0, ATTOTIME_IN_HZ(mc68901->intf->timer_clock / divisor)); |
| 929 | 1000 | } |
| 930 | 1001 | break; |
| 931 | 1002 | } |
| 932 | 1003 | |
| 933 | | switch ((chip->tcdcr >> 4) & 0x07) |
| 1004 | switch ((mc68901->tcdcr >> 4) & 0x07) |
| 934 | 1005 | { |
| 935 | 1006 | case MC68901_TCR_TIMER_STOPPED: |
| 936 | 1007 | if (LOG) logerror("MC68901 Timer C Stopped\n"); |
| 937 | | timer_enable(chip->timer[MC68901_TIMER_C], 0); |
| 1008 | timer_enable(mc68901->timer[MC68901_TIMER_C], 0); |
| 938 | 1009 | break; |
| 939 | 1010 | |
| 940 | 1011 | case MC68901_TCR_TIMER_DELAY_4: |
| r2431 | r2432 | |
| 945 | 1016 | case MC68901_TCR_TIMER_DELAY_100: |
| 946 | 1017 | case MC68901_TCR_TIMER_DELAY_200: |
| 947 | 1018 | { |
| 948 | | int divisor = PRESCALER[(chip->tcdcr >> 4) & 0x07]; |
| 1019 | int divisor = PRESCALER[(mc68901->tcdcr >> 4) & 0x07]; |
| 949 | 1020 | if (LOG) logerror("MC68901 Timer C Delay Mode : %u Prescale\n", divisor); |
| 950 | | timer_adjust_periodic(chip->timer[MC68901_TIMER_C], ATTOTIME_IN_HZ(chip->intf->timer_clock / divisor), 0, ATTOTIME_IN_HZ(chip->intf->timer_clock / divisor)); |
| 1021 | timer_adjust_periodic(mc68901->timer[MC68901_TIMER_C], ATTOTIME_IN_HZ(mc68901->intf->timer_clock / divisor), 0, ATTOTIME_IN_HZ(mc68901->intf->timer_clock / divisor)); |
| 951 | 1022 | } |
| 952 | 1023 | break; |
| 953 | 1024 | } |
| r2431 | r2432 | |
| 956 | 1027 | case MC68901_REGISTER_TADR: |
| 957 | 1028 | if (LOG) logerror("MC68901 Timer A Data Register : %x\n", data); |
| 958 | 1029 | |
| 959 | | chip->tdr[MC68901_TIMER_A] = data; |
| 1030 | mc68901->tdr[MC68901_TIMER_A] = data; |
| 960 | 1031 | |
| 961 | | if (!timer_enabled(chip->timer[MC68901_TIMER_A])) |
| 1032 | if (!timer_enabled(mc68901->timer[MC68901_TIMER_A])) |
| 962 | 1033 | { |
| 963 | | chip->tmc[MC68901_TIMER_A] = data; |
| 1034 | mc68901->tmc[MC68901_TIMER_A] = data; |
| 964 | 1035 | } |
| 965 | 1036 | break; |
| 966 | 1037 | |
| 967 | 1038 | case MC68901_REGISTER_TBDR: |
| 968 | 1039 | if (LOG) logerror("MC68901 Timer B Data Register : %x\n", data); |
| 969 | 1040 | |
| 970 | | chip->tdr[MC68901_TIMER_B] = data; |
| 1041 | mc68901->tdr[MC68901_TIMER_B] = data; |
| 971 | 1042 | |
| 972 | | if (!timer_enabled(chip->timer[MC68901_TIMER_B])) |
| 1043 | if (!timer_enabled(mc68901->timer[MC68901_TIMER_B])) |
| 973 | 1044 | { |
| 974 | | chip->tmc[MC68901_TIMER_B] = data; |
| 1045 | mc68901->tmc[MC68901_TIMER_B] = data; |
| 975 | 1046 | } |
| 976 | 1047 | break; |
| 977 | 1048 | |
| 978 | 1049 | case MC68901_REGISTER_TCDR: |
| 979 | 1050 | if (LOG) logerror("MC68901 Timer C Data Register : %x\n", data); |
| 980 | 1051 | |
| 981 | | chip->tdr[MC68901_TIMER_C] = data; |
| 1052 | mc68901->tdr[MC68901_TIMER_C] = data; |
| 982 | 1053 | |
| 983 | | if (!timer_enabled(chip->timer[MC68901_TIMER_C])) |
| 1054 | if (!timer_enabled(mc68901->timer[MC68901_TIMER_C])) |
| 984 | 1055 | { |
| 985 | | chip->tmc[MC68901_TIMER_C] = data; |
| 1056 | mc68901->tmc[MC68901_TIMER_C] = data; |
| 986 | 1057 | } |
| 987 | 1058 | break; |
| 988 | 1059 | |
| 989 | 1060 | case MC68901_REGISTER_TDDR: |
| 990 | 1061 | if (LOG) logerror("MC68901 Timer D Data Register : %x\n", data); |
| 991 | 1062 | |
| 992 | | chip->tdr[MC68901_TIMER_D] = data; |
| 1063 | mc68901->tdr[MC68901_TIMER_D] = data; |
| 993 | 1064 | |
| 994 | | if (!timer_enabled(chip->timer[MC68901_TIMER_D])) |
| 1065 | if (!timer_enabled(mc68901->timer[MC68901_TIMER_D])) |
| 995 | 1066 | { |
| 996 | | chip->tmc[MC68901_TIMER_D] = data; |
| 1067 | mc68901->tmc[MC68901_TIMER_D] = data; |
| 997 | 1068 | } |
| 998 | 1069 | break; |
| 999 | 1070 | |
| 1000 | 1071 | case MC68901_REGISTER_SCR: |
| 1001 | 1072 | if (LOG) logerror("MC68901 Sync Character : %x\n", data); |
| 1002 | 1073 | |
| 1003 | | chip->scr = data; |
| 1074 | mc68901->scr = data; |
| 1004 | 1075 | break; |
| 1005 | 1076 | |
| 1006 | 1077 | case MC68901_REGISTER_UCR: |
| r2431 | r2432 | |
| 1023 | 1094 | switch (data & 0x60) |
| 1024 | 1095 | { |
| 1025 | 1096 | case MC68901_UCR_WORD_LENGTH_8: |
| 1026 | | chip->rxtx_word = 8; |
| 1097 | mc68901->rxtx_word = 8; |
| 1027 | 1098 | if (LOG) logerror("MC68901 Word Length : 8 bits\n"); |
| 1028 | 1099 | break; |
| 1029 | 1100 | case MC68901_UCR_WORD_LENGTH_7: |
| 1030 | | chip->rxtx_word = 7; |
| 1101 | mc68901->rxtx_word = 7; |
| 1031 | 1102 | if (LOG) logerror("MC68901 Word Length : 7 bits\n"); |
| 1032 | 1103 | break; |
| 1033 | 1104 | case MC68901_UCR_WORD_LENGTH_6: |
| 1034 | | chip->rxtx_word = 6; |
| 1105 | mc68901->rxtx_word = 6; |
| 1035 | 1106 | if (LOG) logerror("MC68901 Word Length : 6 bits\n"); |
| 1036 | 1107 | break; |
| 1037 | 1108 | case MC68901_UCR_WORD_LENGTH_5: |
| 1038 | | chip->rxtx_word = 5; |
| 1109 | mc68901->rxtx_word = 5; |
| 1039 | 1110 | if (LOG) logerror("MC68901 Word Length : 5 bits\n"); |
| 1040 | 1111 | break; |
| 1041 | 1112 | } |
| r2431 | r2432 | |
| 1043 | 1114 | switch (data & 0x18) |
| 1044 | 1115 | { |
| 1045 | 1116 | case MC68901_UCR_START_STOP_0_0: |
| 1046 | | chip->rxtx_start = 0; |
| 1047 | | chip->rxtx_stop = 0; |
| 1117 | mc68901->rxtx_start = 0; |
| 1118 | mc68901->rxtx_stop = 0; |
| 1048 | 1119 | if (LOG) logerror("MC68901 Start Bits : 0, Stop Bits : 0, Format : synchronous\n"); |
| 1049 | 1120 | break; |
| 1050 | 1121 | case MC68901_UCR_START_STOP_1_1: |
| 1051 | | chip->rxtx_start = 1; |
| 1052 | | chip->rxtx_stop = 1; |
| 1122 | mc68901->rxtx_start = 1; |
| 1123 | mc68901->rxtx_stop = 1; |
| 1053 | 1124 | if (LOG) logerror("MC68901 Start Bits : 1, Stop Bits : 1, Format : asynchronous\n"); |
| 1054 | 1125 | break; |
| 1055 | 1126 | case MC68901_UCR_START_STOP_1_15: |
| 1056 | | chip->rxtx_start = 1; |
| 1057 | | chip->rxtx_stop = 1; |
| 1127 | mc68901->rxtx_start = 1; |
| 1128 | mc68901->rxtx_stop = 1; |
| 1058 | 1129 | if (LOG) logerror("MC68901 Start Bits : 1, Stop Bits : 1½, Format : asynchronous\n"); |
| 1059 | 1130 | break; |
| 1060 | 1131 | case MC68901_UCR_START_STOP_1_2: |
| 1061 | | chip->rxtx_start = 1; |
| 1062 | | chip->rxtx_stop = 2; |
| 1132 | mc68901->rxtx_start = 1; |
| 1133 | mc68901->rxtx_stop = 2; |
| 1063 | 1134 | if (LOG) logerror("MC68901 Start Bits : 1, Stop Bits : 2, Format : asynchronous\n"); |
| 1064 | 1135 | break; |
| 1065 | 1136 | } |
| r2431 | r2432 | |
| 1073 | 1144 | if (LOG) logerror("MC68901 Rx/Tx Clock Divisor : 1\n"); |
| 1074 | 1145 | } |
| 1075 | 1146 | |
| 1076 | | chip->ucr = data; |
| 1147 | mc68901->ucr = data; |
| 1077 | 1148 | break; |
| 1078 | 1149 | |
| 1079 | 1150 | case MC68901_REGISTER_RSR: |
| 1080 | 1151 | if ((data & MC68901_RSR_RCV_ENABLE) == 0) |
| 1081 | 1152 | { |
| 1082 | 1153 | if (LOG) logerror("MC68901 Receiver Disabled\n"); |
| 1083 | | chip->rsr = 0; |
| 1154 | mc68901->rsr = 0; |
| 1084 | 1155 | } |
| 1085 | 1156 | else |
| 1086 | 1157 | { |
| r2431 | r2432 | |
| 1098 | 1169 | if (data & MC68901_RSR_FOUND_SEARCH) |
| 1099 | 1170 | if (LOG) logerror("MC68901 Receiver Search Mode Enabled\n"); |
| 1100 | 1171 | |
| 1101 | | chip->rsr = data & 0x0b; |
| 1172 | mc68901->rsr = data & 0x0b; |
| 1102 | 1173 | } |
| 1103 | 1174 | break; |
| 1104 | 1175 | |
| r2431 | r2432 | |
| 1107 | 1178 | { |
| 1108 | 1179 | if (LOG) logerror("MC68901 Transmitter Disabled\n"); |
| 1109 | 1180 | |
| 1110 | | chip->tsr = data & 0x27; |
| 1181 | mc68901->tsr = data & 0x27; |
| 1111 | 1182 | } |
| 1112 | 1183 | else |
| 1113 | 1184 | { |
| r2431 | r2432 | |
| 1147 | 1218 | if (LOG) logerror("MC68901 Transmitter Auto Turnaround Disabled\n"); |
| 1148 | 1219 | } |
| 1149 | 1220 | |
| 1150 | | chip->tsr = data & 0x2f; |
| 1151 | | chip->tsr |= MC68901_TSR_BUFFER_EMPTY; // x68000 expects the buffer to be empty, so this will do for now |
| 1221 | mc68901->tsr = data & 0x2f; |
| 1222 | mc68901->tsr |= MC68901_TSR_BUFFER_EMPTY; // x68000 expects the buffer to be empty, so this will do for now |
| 1152 | 1223 | } |
| 1153 | 1224 | break; |
| 1154 | 1225 | |
| 1155 | 1226 | case MC68901_REGISTER_UDR: |
| 1156 | 1227 | if (LOG) logerror("MC68901 UDR %x\n", data); |
| 1157 | | chip->udr = data; |
| 1158 | | //chip->tsr &= ~MC68901_TSR_BUFFER_EMPTY; |
| 1228 | mc68901->udr = data; |
| 1229 | //mc68901->tsr &= ~MC68901_TSR_BUFFER_EMPTY; |
| 1159 | 1230 | break; |
| 1160 | 1231 | } |
| 1161 | 1232 | } |
| 1162 | 1233 | |
| 1163 | | static void mc68901_timer_count(mc68901_t *chip, int index) |
| 1234 | static void mc68901_timer_count(const device_config *device, int index) |
| 1164 | 1235 | { |
| 1165 | | if (chip->tmc[index] == 0x01) |
| 1236 | mc68901_t *mc68901 = get_safe_token(device); |
| 1237 | |
| 1238 | if (mc68901->tmc[index] == 0x01) |
| 1166 | 1239 | { |
| 1167 | | chip->to[index] = chip->to[index] ? 0 : 1; |
| 1240 | mc68901->to[index] = mc68901->to[index] ? 0 : 1; |
| 1168 | 1241 | |
| 1169 | | if (chip->to[index]) |
| 1242 | if (mc68901->to[index]) |
| 1170 | 1243 | { |
| 1171 | | if (chip->intf->rx_clock == MC68901_LOOPBACK_TIMER[index]) |
| 1244 | if (mc68901->intf->rx_clock == MC68901_LOOPBACK_TIMER[index]) |
| 1172 | 1245 | { |
| 1173 | | mc68901_serial_rx(chip); |
| 1246 | mc68901_serial_rx(device); |
| 1174 | 1247 | } |
| 1175 | 1248 | |
| 1176 | | if (chip->intf->tx_clock == MC68901_LOOPBACK_TIMER[index]) |
| 1249 | if (mc68901->intf->tx_clock == MC68901_LOOPBACK_TIMER[index]) |
| 1177 | 1250 | { |
| 1178 | | mc68901_serial_tx(chip); |
| 1251 | mc68901_serial_tx(device); |
| 1179 | 1252 | } |
| 1180 | 1253 | } |
| 1181 | 1254 | |
| 1182 | | if (chip->intf->to_w) |
| 1255 | if (mc68901->intf->on_to_changed) |
| 1183 | 1256 | { |
| 1184 | | chip->intf->to_w(chip, index, chip->to[index]); |
| 1257 | mc68901->intf->on_to_changed(device, index, mc68901->to[index]); |
| 1185 | 1258 | } |
| 1186 | 1259 | |
| 1187 | | if (chip->ier & MC68901_INT_MASK_TIMER[index]) |
| 1260 | if (mc68901->ier & MC68901_INT_MASK_TIMER[index]) |
| 1188 | 1261 | { |
| 1189 | | mc68901_interrupt(chip, MC68901_INT_MASK_TIMER[index]); |
| 1262 | mc68901_interrupt(device, MC68901_INT_MASK_TIMER[index]); |
| 1190 | 1263 | } |
| 1191 | 1264 | |
| 1192 | | chip->tmc[index] = chip->tdr[index]; |
| 1265 | mc68901->tmc[index] = mc68901->tdr[index]; |
| 1193 | 1266 | } |
| 1194 | 1267 | else |
| 1195 | 1268 | { |
| 1196 | | chip->tmc[index]--; |
| 1269 | mc68901->tmc[index]--; |
| 1197 | 1270 | } |
| 1198 | 1271 | } |
| 1199 | 1272 | |
| 1200 | | static void mc68901_ti_w(mc68901_t *chip, int index, int value) |
| 1273 | static void mc68901_ti_w(const device_config *device, int index, int value) |
| 1201 | 1274 | { |
| 1275 | mc68901_t *mc68901 = get_safe_token(device); |
| 1276 | |
| 1202 | 1277 | int bit = MC68901_GPIO_TIMER[index]; |
| 1203 | | int aer = BIT(chip->aer, bit); |
| 1204 | | int cr = index ? chip->tbcr : chip->tacr; |
| 1278 | int aer = BIT(mc68901->aer, bit); |
| 1279 | int cr = index ? mc68901->tbcr : mc68901->tacr; |
| 1205 | 1280 | |
| 1206 | 1281 | switch (cr & 0x0f) |
| 1207 | 1282 | { |
| 1208 | 1283 | case MC68901_TCR_TIMER_EVENT: |
| 1209 | | if (((chip->ti[index] ^ aer) == 1) && ((value ^ aer) == 0)) |
| 1284 | if (((mc68901->ti[index] ^ aer) == 1) && ((value ^ aer) == 0)) |
| 1210 | 1285 | { |
| 1211 | | mc68901_timer_count(chip, index); |
| 1286 | mc68901_timer_count(device, index); |
| 1212 | 1287 | } |
| 1213 | 1288 | |
| 1214 | | chip->ti[index] = value; |
| 1289 | mc68901->ti[index] = value; |
| 1215 | 1290 | break; |
| 1216 | 1291 | |
| 1217 | 1292 | case MC68901_TCR_TIMER_PULSE_4: |
| r2431 | r2432 | |
| 1221 | 1296 | case MC68901_TCR_TIMER_PULSE_64: |
| 1222 | 1297 | case MC68901_TCR_TIMER_PULSE_100: |
| 1223 | 1298 | case MC68901_TCR_TIMER_PULSE_200: |
| 1224 | | timer_enable(chip->timer[index], (value == aer)); |
| 1299 | timer_enable(mc68901->timer[index], (value == aer)); |
| 1225 | 1300 | |
| 1226 | | if (((chip->ti[index] ^ aer) == 0) && ((value ^ aer) == 1)) |
| 1301 | if (((mc68901->ti[index] ^ aer) == 0) && ((value ^ aer) == 1)) |
| 1227 | 1302 | { |
| 1228 | | if (chip->ier & MC68901_INT_MASK_GPIO[bit]) |
| 1303 | if (mc68901->ier & MC68901_INT_MASK_GPIO[bit]) |
| 1229 | 1304 | { |
| 1230 | | mc68901_interrupt(chip, MC68901_INT_MASK_GPIO[bit]); |
| 1305 | mc68901_interrupt(device, MC68901_INT_MASK_GPIO[bit]); |
| 1231 | 1306 | } |
| 1232 | 1307 | } |
| 1233 | 1308 | |
| 1234 | | chip->ti[index] = value; |
| 1309 | mc68901->ti[index] = value; |
| 1235 | 1310 | break; |
| 1236 | 1311 | } |
| 1237 | 1312 | } |
| r2431 | r2432 | |
| 1258 | 1333 | |
| 1259 | 1334 | /* External Interface */ |
| 1260 | 1335 | |
| 1261 | | void mc68901_tai_w(mc68901_t *chip, int value) |
| 1336 | void mc68901_tai_w(const device_config *device, int value) |
| 1262 | 1337 | { |
| 1263 | | assert(chip != NULL); |
| 1338 | mc68901_t *mc68901 = get_safe_token(device); |
| 1264 | 1339 | |
| 1265 | | mc68901_ti_w(chip, MC68901_TIMER_A, value); |
| 1340 | assert(mc68901 != NULL); |
| 1341 | |
| 1342 | mc68901_ti_w(device, MC68901_TIMER_A, value); |
| 1266 | 1343 | } |
| 1267 | 1344 | |
| 1268 | | void mc68901_tbi_w(mc68901_t *chip, int value) |
| 1345 | void mc68901_tbi_w(const device_config *device, int value) |
| 1269 | 1346 | { |
| 1270 | | assert(chip != NULL); |
| 1347 | mc68901_t *mc68901 = get_safe_token(device); |
| 1271 | 1348 | |
| 1272 | | mc68901_ti_w(chip, MC68901_TIMER_B, value); |
| 1349 | assert(mc68901 != NULL); |
| 1350 | |
| 1351 | mc68901_ti_w(device, MC68901_TIMER_B, value); |
| 1273 | 1352 | } |
| 1274 | 1353 | |
| 1275 | | int mc68901_get_vector(mc68901_t *chip) |
| 1354 | int mc68901_get_vector(const device_config *device) |
| 1276 | 1355 | { |
| 1356 | mc68901_t *mc68901 = get_safe_token(device); |
| 1357 | |
| 1277 | 1358 | int ch; |
| 1278 | 1359 | |
| 1279 | | assert(chip != NULL); |
| 1360 | assert(mc68901 != NULL); |
| 1280 | 1361 | |
| 1281 | 1362 | for (ch = 15; ch >= 0; ch--) |
| 1282 | 1363 | { |
| 1283 | | if (BIT(chip->imr, ch) && BIT(chip->ipr, ch)) |
| 1364 | if (BIT(mc68901->imr, ch) && BIT(mc68901->ipr, ch)) |
| 1284 | 1365 | { |
| 1285 | | if (chip->vr & MC68901_VR_S) |
| 1366 | if (mc68901->vr & MC68901_VR_S) |
| 1286 | 1367 | { |
| 1287 | | chip->isr |= (1 << ch); |
| 1368 | mc68901->isr |= (1 << ch); |
| 1288 | 1369 | } |
| 1289 | 1370 | |
| 1290 | | chip->ipr &= ~(1 << ch); |
| 1371 | mc68901->ipr &= ~(1 << ch); |
| 1291 | 1372 | |
| 1292 | | mc68901_check_interrupts(chip); |
| 1373 | mc68901_check_interrupts(device); |
| 1293 | 1374 | |
| 1294 | | return (chip->vr & 0xf0) | ch; |
| 1375 | return (mc68901->vr & 0xf0) | ch; |
| 1295 | 1376 | } |
| 1296 | 1377 | } |
| 1297 | 1378 | |
| r2431 | r2432 | |
| 1305 | 1386 | mc68901_t *mc68901 = device->token; |
| 1306 | 1387 | char unique_tag[30]; |
| 1307 | 1388 | |
| 1389 | /* validate arguments */ |
| 1308 | 1390 | assert(device->machine != NULL); |
| 1309 | 1391 | assert(device->tag != NULL); |
| 1310 | 1392 | assert(strlen(device->tag) < 20); |
| 1311 | | |
| 1312 | | //mc68901->device_type = device_type; |
| 1313 | 1393 | mc68901->intf = device->static_config; |
| 1314 | 1394 | |
| 1315 | | // initial settings |
| 1316 | | |
| 1395 | /* set initial values */ |
| 1317 | 1396 | mc68901->tsr = MC68901_TSR_BUFFER_EMPTY; |
| 1318 | 1397 | |
| 1319 | | // counter timers |
| 1398 | /* create the timers */ |
| 1399 | mc68901->timer[MC68901_TIMER_A] = timer_alloc(timer_a, (void *)device); |
| 1400 | mc68901->timer[MC68901_TIMER_B] = timer_alloc(timer_b, (void *)device); |
| 1401 | mc68901->timer[MC68901_TIMER_C] = timer_alloc(timer_c, (void *)device); |
| 1402 | mc68901->timer[MC68901_TIMER_D] = timer_alloc(timer_d, (void *)device); |
| 1320 | 1403 | |
| 1321 | | mc68901->timer[MC68901_TIMER_A] = timer_alloc(timer_a, mc68901); |
| 1322 | | mc68901->timer[MC68901_TIMER_B] = timer_alloc(timer_b, mc68901); |
| 1323 | | mc68901->timer[MC68901_TIMER_C] = timer_alloc(timer_c, mc68901); |
| 1324 | | mc68901->timer[MC68901_TIMER_D] = timer_alloc(timer_d, mc68901); |
| 1325 | | |
| 1326 | | // serial receive timer |
| 1327 | | |
| 1328 | 1404 | if (mc68901->intf->rx_clock > 0) |
| 1329 | 1405 | { |
| 1330 | | timer_pulse(ATTOTIME_IN_HZ(mc68901->intf->rx_clock), mc68901, 0, rx_tick); |
| 1406 | mc68901->rx_timer = timer_alloc(rx_tick, (void *)device); |
| 1407 | timer_adjust_periodic(mc68901->rx_timer, attotime_zero, 0, ATTOTIME_IN_HZ(mc68901->intf->rx_clock)); |
| 1331 | 1408 | } |
| 1332 | 1409 | |
| 1333 | | // serial transmit timer |
| 1334 | | |
| 1335 | 1410 | if (mc68901->intf->tx_clock > 0) |
| 1336 | 1411 | { |
| 1337 | | timer_pulse(ATTOTIME_IN_HZ(mc68901->intf->tx_clock), mc68901, 0, tx_tick); |
| 1412 | mc68901->tx_timer = timer_alloc(tx_tick, (void *)device); |
| 1413 | timer_adjust_periodic(mc68901->tx_timer, attotime_zero, 0, ATTOTIME_IN_HZ(mc68901->intf->tx_clock)); |
| 1338 | 1414 | } |
| 1339 | 1415 | |
| 1340 | | // general purpose I/O poll timer |
| 1341 | | |
| 1342 | 1416 | if (mc68901->intf->gpio_r) |
| 1343 | 1417 | { |
| 1344 | | timer_pulse(ATTOTIME_IN_HZ(mc68901->intf->chip_clock / 4), mc68901, 0, mc68901_gpio_poll_tick); |
| 1418 | mc68901->poll_timer = timer_alloc(mc68901_gpio_poll_tick, (void *)device); |
| 1419 | timer_adjust_periodic(mc68901->poll_timer, attotime_zero, 0, ATTOTIME_IN_HZ(mc68901->intf->chip_clock / 4)); |
| 1345 | 1420 | } |
| 1346 | 1421 | |
| 1347 | | // register save state support |
| 1348 | | |
| 1422 | /* register for state saving */ |
| 1349 | 1423 | state_save_combine_module_and_tag(unique_tag, "MC68901", device->tag); |
| 1350 | 1424 | |
| 1351 | 1425 | state_save_register_item(unique_tag, 0, mc68901->gpip); |
| r2431 | r2432 | |
| 1386 | 1460 | |
| 1387 | 1461 | static DEVICE_RESET( mc68901 ) |
| 1388 | 1462 | { |
| 1389 | | mc68901_t *mc68901 = device->token; |
| 1390 | | |
| 1391 | | mc68901_register_w(mc68901, MC68901_REGISTER_GPIP, 0); |
| 1392 | | mc68901_register_w(mc68901, MC68901_REGISTER_AER, 0); |
| 1393 | | mc68901_register_w(mc68901, MC68901_REGISTER_DDR, 0); |
| 1394 | | mc68901_register_w(mc68901, MC68901_REGISTER_IERA, 0); |
| 1395 | | mc68901_register_w(mc68901, MC68901_REGISTER_IERB, 0); |
| 1396 | | mc68901_register_w(mc68901, MC68901_REGISTER_IPRA, 0); |
| 1397 | | mc68901_register_w(mc68901, MC68901_REGISTER_IPRB, 0); |
| 1398 | | mc68901_register_w(mc68901, MC68901_REGISTER_ISRA, 0); |
| 1399 | | mc68901_register_w(mc68901, MC68901_REGISTER_ISRB, 0); |
| 1400 | | mc68901_register_w(mc68901, MC68901_REGISTER_IMRA, 0); |
| 1401 | | mc68901_register_w(mc68901, MC68901_REGISTER_IMRB, 0); |
| 1402 | | mc68901_register_w(mc68901, MC68901_REGISTER_VR, 0); |
| 1403 | | mc68901_register_w(mc68901, MC68901_REGISTER_TACR, 0); |
| 1404 | | mc68901_register_w(mc68901, MC68901_REGISTER_TBCR, 0); |
| 1405 | | mc68901_register_w(mc68901, MC68901_REGISTER_TCDCR, 0); |
| 1406 | | mc68901_register_w(mc68901, MC68901_REGISTER_SCR, 0); |
| 1407 | | mc68901_register_w(mc68901, MC68901_REGISTER_UCR, 0); |
| 1408 | | mc68901_register_w(mc68901, MC68901_REGISTER_RSR, 0); |
| 1463 | mc68901_register_w(device, MC68901_REGISTER_GPIP, 0); |
| 1464 | mc68901_register_w(device, MC68901_REGISTER_AER, 0); |
| 1465 | mc68901_register_w(device, MC68901_REGISTER_DDR, 0); |
| 1466 | mc68901_register_w(device, MC68901_REGISTER_IERA, 0); |
| 1467 | mc68901_register_w(device, MC68901_REGISTER_IERB, 0); |
| 1468 | mc68901_register_w(device, MC68901_REGISTER_IPRA, 0); |
| 1469 | mc68901_register_w(device, MC68901_REGISTER_IPRB, 0); |
| 1470 | mc68901_register_w(device, MC68901_REGISTER_ISRA, 0); |
| 1471 | mc68901_register_w(device, MC68901_REGISTER_ISRB, 0); |
| 1472 | mc68901_register_w(device, MC68901_REGISTER_IMRA, 0); |
| 1473 | mc68901_register_w(device, MC68901_REGISTER_IMRB, 0); |
| 1474 | mc68901_register_w(device, MC68901_REGISTER_VR, 0); |
| 1475 | mc68901_register_w(device, MC68901_REGISTER_TACR, 0); |
| 1476 | mc68901_register_w(device, MC68901_REGISTER_TBCR, 0); |
| 1477 | mc68901_register_w(device, MC68901_REGISTER_TCDCR, 0); |
| 1478 | mc68901_register_w(device, MC68901_REGISTER_SCR, 0); |
| 1479 | mc68901_register_w(device, MC68901_REGISTER_UCR, 0); |
| 1480 | mc68901_register_w(device, MC68901_REGISTER_RSR, 0); |
| 1409 | 1481 | } |
| 1410 | 1482 | |
| 1411 | 1483 | static DEVICE_SET_INFO( mc68901 ) |
| r2431 | r2432 | |
| 1432 | 1504 | case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(mc68901); break; |
| 1433 | 1505 | |
| 1434 | 1506 | /* --- the following bits of info are returned as NULL-terminated strings --- */ |
| 1435 | | case DEVINFO_STR_NAME: info->s = "Motorola 68901"; break; |
| 1507 | case DEVINFO_STR_NAME: info->s = "Motorola MC68901"; break; |
| 1436 | 1508 | case DEVINFO_STR_FAMILY: info->s = "MC68901 MFP"; break; |
| 1437 | 1509 | case DEVINFO_STR_VERSION: info->s = "1.0"; break; |
| 1438 | 1510 | case DEVINFO_STR_SOURCE_FILE: info->s = __FILE__; break; |
| 1439 | 1511 | case DEVINFO_STR_CREDITS: info->s = "Copyright the MESS Team"; break; |
| 1440 | 1512 | } |
| 1441 | 1513 | } |
| 1514 | |
| 1515 | DEVICE_GET_INFO( mk68901 ) |
| 1516 | { |
| 1517 | switch (state) |
| 1518 | { |
| 1519 | /* --- the following bits of info are returned as 64-bit signed integers --- */ |
| 1520 | case DEVINFO_INT_INLINE_CONFIG_BYTES: info->i = 0; break; |
| 1521 | case DEVINFO_INT_CLASS: info->i = DEVICE_CLASS_PERIPHERAL; break; |
| 1522 | case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(mc68901_t); break; |
| 1523 | |
| 1524 | /* --- the following bits of info are returned as pointers to data or functions --- */ |
| 1525 | case DEVINFO_FCT_SET_INFO: info->set_info = DEVICE_SET_INFO_NAME(mc68901); break; |
| 1526 | case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(mc68901); break; |
| 1527 | case DEVINFO_FCT_STOP: /* Nothing */ break; |
| 1528 | case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(mc68901); break; |
| 1529 | |
| 1530 | /* --- the following bits of info are returned as NULL-terminated strings --- */ |
| 1531 | case DEVINFO_STR_NAME: info->s = "Mostek MK68901"; break; |
| 1532 | case DEVINFO_STR_FAMILY: info->s = "MK68901 MFP"; break; |
| 1533 | case DEVINFO_STR_VERSION: info->s = "1.0"; break; |
| 1534 | case DEVINFO_STR_SOURCE_FILE: info->s = __FILE__; break; |
| 1535 | case DEVINFO_STR_CREDITS: info->s = "Copyright the MESS Team"; break; |
| 1536 | } |
| 1537 | } |
src/mess/drivers/atarist.c
| r2431 | r2432 | |
| 37 | 37 | |
| 38 | 38 | */ |
| 39 | 39 | |
| 40 | | // Atari ST |
| 41 | | |
| 42 | | #define Y1 XTAL_2_4576MHz |
| 43 | | |
| 44 | | // STBook |
| 45 | | |
| 46 | | #define U517 XTAL_16MHz |
| 47 | | #define Y200 XTAL_2_4576MHz |
| 48 | | #define Y700 XTAL_10MHz |
| 49 | | |
| 50 | | /* Multi Function Peripheral */ |
| 51 | | |
| 52 | | static READ16_HANDLER( atarist_mfp_r ) |
| 53 | | { |
| 54 | | atarist_state *state = machine->driver_data; |
| 55 | | |
| 56 | | return mc68901_register_r(state->mfp, offset); |
| 57 | | } |
| 58 | | |
| 59 | | static WRITE16_HANDLER( atarist_mfp_w ) |
| 60 | | { |
| 61 | | atarist_state *state = machine->driver_data; |
| 62 | | |
| 63 | | if (ACCESSING_BITS_0_7) mc68901_register_w(state->mfp, offset, data & 0xff); |
| 64 | | } |
| 65 | | |
| 66 | 40 | /* Floppy Disk Controller */ |
| 67 | 41 | |
| 68 | 42 | #define ATARIST_FLOPPY_STATUS_FDC_DATA_REQUEST 0x04 |
| r2431 | r2432 | |
| 489 | 463 | |
| 490 | 464 | static void atariste_dmasound_set_state(running_machine *machine, int level) |
| 491 | 465 | { |
| 492 | | atarist_state *state = machine->driver_data; |
| 466 | const device_config *mc68901 = device_list_find_by_tag(machine->config->devicelist, MC68901, MC68901_TAG); |
| 493 | 467 | |
| 494 | 468 | dmasound.active = level; |
| 495 | | mc68901_tai_w(state->mfp, level); |
| 469 | mc68901_tai_w(mc68901, level); |
| 496 | 470 | |
| 497 | | if (state == 0) |
| 471 | if (level == 0) |
| 498 | 472 | { |
| 499 | 473 | dmasound.baselatch = dmasound.base; |
| 500 | 474 | dmasound.endlatch = dmasound.end; |
| r2431 | r2432 | |
| 748 | 722 | } |
| 749 | 723 | } |
| 750 | 724 | |
| 751 | | /* SCC8530 */ |
| 752 | | |
| 753 | | static READ16_HANDLER( megaste_scc8530_r ) |
| 754 | | { |
| 755 | | if (ACCESSING_BITS_8_15) |
| 756 | | { |
| 757 | | return scc_r(machine, offset); |
| 758 | | } |
| 759 | | else |
| 760 | | { |
| 761 | | return 0; |
| 762 | | } |
| 763 | | } |
| 764 | | |
| 765 | | static WRITE16_HANDLER( megaste_scc8530_w ) |
| 766 | | { |
| 767 | | if (ACCESSING_BITS_8_15) |
| 768 | | { |
| 769 | | scc_w(machine, offset, data); |
| 770 | | } |
| 771 | | } |
| 772 | | |
| 773 | 725 | /* Mega STe Cache */ |
| 774 | 726 | |
| 775 | 727 | static UINT16 megaste_cache; |
| r2431 | r2432 | |
| 857 | 809 | AM_RANGE(0xff8000, 0xff8001) AM_READWRITE(atarist_mmu_r, atarist_mmu_w) |
| 858 | 810 | AM_RANGE(0xff8200, 0xff8203) AM_READWRITE(atarist_shifter_base_r, atarist_shifter_base_w) |
| 859 | 811 | AM_RANGE(0xff8204, 0xff8209) AM_READ(atarist_shifter_counter_r) |
| 860 | | AM_RANGE(0xff820a, 0xff820b) AM_READWRITE(atarist_shifter_sync_r, atarist_shifter_sync_w) |
| 812 | AM_RANGE(0xff820a, 0xff820b) AM_READWRITE8(atarist_shifter_sync_r, atarist_shifter_sync_w, 0xff00) |
| 861 | 813 | AM_RANGE(0xff8240, 0xff825f) AM_READWRITE(atarist_shifter_palette_r, atarist_shifter_palette_w) |
| 862 | | AM_RANGE(0xff8260, 0xff8261) AM_READWRITE(atarist_shifter_mode_r, atarist_shifter_mode_w) |
| 814 | AM_RANGE(0xff8260, 0xff8261) AM_READWRITE8(atarist_shifter_mode_r, atarist_shifter_mode_w, 0xff00) |
| 863 | 815 | AM_RANGE(0xff8604, 0xff8605) AM_READWRITE(atarist_fdc_data_r, atarist_fdc_data_w) |
| 864 | 816 | AM_RANGE(0xff8606, 0xff8607) AM_READWRITE(atarist_fdc_dma_status_r, atarist_fdc_dma_mode_w) |
| 865 | 817 | AM_RANGE(0xff8608, 0xff860d) AM_READWRITE(atarist_fdc_dma_base_r, atarist_fdc_dma_base_w) |
| 866 | | AM_RANGE(0xff8800, 0xff8801) AM_READWRITE(AY8910_read_port_0_msb_r, AY8910_control_port_0_msb_w) |
| 867 | | AM_RANGE(0xff8802, 0xff8803) AM_WRITE(AY8910_write_port_0_msb_w) |
| 868 | | AM_RANGE(0xfffa00, 0xfffa2f) AM_READWRITE(atarist_mfp_r, atarist_mfp_w) |
| 869 | | AM_RANGE(0xfffc00, 0xfffc01) AM_READWRITE(acia6850_0_stat_msb_r, acia6850_0_ctrl_msb_w) |
| 870 | | AM_RANGE(0xfffc02, 0xfffc03) AM_READWRITE(acia6850_0_data_msb_r, acia6850_0_data_msb_w) |
| 871 | | AM_RANGE(0xfffc04, 0xfffc05) AM_READWRITE(acia6850_1_stat_msb_r, acia6850_1_ctrl_msb_w) |
| 872 | | AM_RANGE(0xfffc06, 0xfffc07) AM_READWRITE(acia6850_1_data_msb_r, acia6850_1_data_msb_w) |
| 818 | AM_RANGE(0xff8800, 0xff8801) AM_READWRITE8(AY8910_read_port_0_r, AY8910_control_port_0_w, 0xff00) |
| 819 | AM_RANGE(0xff8802, 0xff8803) AM_WRITE8(AY8910_write_port_0_w, 0xff00) |
| 820 | AM_RANGE(0xfffa00, 0xfffa2f) AM_DEVREADWRITE8(MC68901, MC68901_TAG, mc68901_register_r, mc68901_register_w, 0xff) |
| 821 | AM_RANGE(0xfffc00, 0xfffc01) AM_READWRITE8(acia6850_0_stat_r, acia6850_0_ctrl_w, 0xff00) |
| 822 | AM_RANGE(0xfffc02, 0xfffc03) AM_READWRITE8(acia6850_0_data_r, acia6850_0_data_w, 0xff00) |
| 823 | AM_RANGE(0xfffc04, 0xfffc05) AM_READWRITE8(acia6850_1_stat_r, acia6850_1_ctrl_w, 0xff00) |
| 824 | AM_RANGE(0xfffc06, 0xfffc07) AM_READWRITE8(acia6850_1_data_r, acia6850_1_data_w, 0xff00) |
| 873 | 825 | ADDRESS_MAP_END |
| 874 | 826 | |
| 875 | 827 | static ADDRESS_MAP_START( megast_map, ADDRESS_SPACE_PROGRAM, 16 ) |
| r2431 | r2432 | |
| 882 | 834 | AM_RANGE(0xff8000, 0xff8007) AM_READWRITE(atarist_mmu_r, atarist_mmu_w) |
| 883 | 835 | AM_RANGE(0xff8200, 0xff8203) AM_READWRITE(atarist_shifter_base_r, atarist_shifter_base_w) |
| 884 | 836 | AM_RANGE(0xff8204, 0xff8209) AM_READ(atarist_shifter_counter_r) |
| 885 | | AM_RANGE(0xff820a, 0xff820b) AM_READWRITE(atarist_shifter_sync_r, atarist_shifter_sync_w) |
| 837 | AM_RANGE(0xff820a, 0xff820b) AM_READWRITE8(atarist_shifter_sync_r, atarist_shifter_sync_w, 0xff00) |
| 886 | 838 | AM_RANGE(0xff8240, 0xff825f) AM_READWRITE(atarist_shifter_palette_r, atarist_shifter_palette_w) |
| 887 | | AM_RANGE(0xff8260, 0xff8261) AM_READWRITE(atarist_shifter_mode_r, atarist_shifter_mode_w) |
| 839 | AM_RANGE(0xff8260, 0xff8261) AM_READWRITE8(atarist_shifter_mode_r, atarist_shifter_mode_w, 0xff00) |
| 888 | 840 | AM_RANGE(0xff8604, 0xff8605) AM_READWRITE(atarist_fdc_data_r, atarist_fdc_data_w) |
| 889 | 841 | AM_RANGE(0xff8606, 0xff8607) AM_READWRITE(atarist_fdc_dma_status_r, atarist_fdc_dma_mode_w) |
| 890 | 842 | AM_RANGE(0xff8608, 0xff860d) AM_READWRITE(atarist_fdc_dma_base_r, atarist_fdc_dma_base_w) |
| 891 | | AM_RANGE(0xff8800, 0xff8801) AM_READWRITE(AY8910_read_port_0_msb_r, AY8910_control_port_0_msb_w) |
| 892 | | AM_RANGE(0xff8802, 0xff8803) AM_WRITE(AY8910_write_port_0_msb_w) |
| 843 | AM_RANGE(0xff8800, 0xff8801) AM_READWRITE8(AY8910_read_port_0_r, AY8910_control_port_0_w, 0xff00) |
| 844 | AM_RANGE(0xff8802, 0xff8803) AM_WRITE8(AY8910_write_port_0_w, 0xff00) |
| 893 | 845 | AM_RANGE(0xff8a00, 0xff8a1f) AM_READWRITE(atarist_blitter_halftone_r, atarist_blitter_halftone_w) |
| 894 | 846 | AM_RANGE(0xff8a20, 0xff8a21) AM_READWRITE(atarist_blitter_src_inc_x_r, atarist_blitter_src_inc_x_w) |
| 895 | 847 | AM_RANGE(0xff8a22, 0xff8a23) AM_READWRITE(atarist_blitter_src_inc_y_r, atarist_blitter_src_inc_y_w) |
| r2431 | r2432 | |
| 902 | 854 | AM_RANGE(0xff8a38, 0xff8a39) AM_READWRITE(atarist_blitter_count_y_r, atarist_blitter_count_y_w) |
| 903 | 855 | AM_RANGE(0xff8a3a, 0xff8a3b) AM_READWRITE(atarist_blitter_op_r, atarist_blitter_op_w) |
| 904 | 856 | AM_RANGE(0xff8a3c, 0xff8a3d) AM_READWRITE(atarist_blitter_ctrl_r, atarist_blitter_ctrl_w) |
| 905 | | AM_RANGE(0xfffa00, 0xfffa3f) AM_READWRITE(atarist_mfp_r, atarist_mfp_w) |
| 857 | AM_RANGE(0xfffa00, 0xfffa3f) AM_DEVREADWRITE8(MC68901, MC68901_TAG, mc68901_register_r, mc68901_register_w, 0xff) |
| 906 | 858 | // AM_RANGE(0xfffa40, 0xfffa57) AM_READWRITE(megast_fpu_r, megast_fpu_w) |
| 907 | | AM_RANGE(0xfffc00, 0xfffc01) AM_READWRITE(acia6850_0_stat_msb_r, acia6850_0_ctrl_msb_w) |
| 908 | | AM_RANGE(0xfffc02, 0xfffc03) AM_READWRITE(acia6850_0_data_msb_r, acia6850_0_data_msb_w) |
| 909 | | AM_RANGE(0xfffc04, 0xfffc05) AM_READWRITE(acia6850_1_stat_msb_r, acia6850_1_ctrl_msb_w) |
| 910 | | AM_RANGE(0xfffc06, 0xfffc07) AM_READWRITE(acia6850_1_data_msb_r, acia6850_1_data_msb_w) |
| 859 | AM_RANGE(0xfffc00, 0xfffc01) AM_READWRITE8(acia6850_0_stat_r, acia6850_0_ctrl_w, 0xff00) |
| 860 | AM_RANGE(0xfffc02, 0xfffc03) AM_READWRITE8(acia6850_0_data_r, acia6850_0_data_w, 0xff00) |
| 861 | AM_RANGE(0xfffc04, 0xfffc05) AM_READWRITE8(acia6850_1_stat_r, acia6850_1_ctrl_w, 0xff00) |
| 862 | AM_RANGE(0xfffc06, 0xfffc07) AM_READWRITE8(acia6850_1_data_r, acia6850_1_data_w, 0xff00) |
| 911 | 863 | AM_RANGE(0xfffc20, 0xfffc3f) AM_READWRITE(rp5c15_r, rp5c15_w) |
| 912 | 864 | ADDRESS_MAP_END |
| 913 | 865 | |
| 914 | | |
| 915 | 866 | static ADDRESS_MAP_START( ste_map, ADDRESS_SPACE_PROGRAM, 16 ) |
| 916 | 867 | AM_RANGE(0x000000, 0x000007) AM_ROM |
| 917 | 868 | AM_RANGE(0x000008, 0x1fffff) AM_RAMBANK(1) |
| r2431 | r2432 | |
| 922 | 873 | AM_RANGE(0xff8000, 0xff8001) AM_READWRITE(atarist_mmu_r, atarist_mmu_w) |
| 923 | 874 | AM_RANGE(0xff8200, 0xff8203) AM_READWRITE(atarist_shifter_base_r, atarist_shifter_base_w) |
| 924 | 875 | AM_RANGE(0xff8204, 0xff8209) AM_READWRITE(atariste_shifter_counter_r, atariste_shifter_counter_w) |
| 925 | | AM_RANGE(0xff820a, 0xff820b) AM_READWRITE(atarist_shifter_sync_r, atarist_shifter_sync_w) |
| 876 | AM_RANGE(0xff820a, 0xff820b) AM_READWRITE8(atarist_shifter_sync_r, atarist_shifter_sync_w, 0xff00) |
| 926 | 877 | AM_RANGE(0xff820c, 0xff820d) AM_READWRITE(atariste_shifter_base_low_r, atariste_shifter_base_low_w) |
| 927 | 878 | AM_RANGE(0xff820e, 0xff820f) AM_READWRITE(atariste_shifter_lineofs_r, atariste_shifter_lineofs_w) |
| 928 | 879 | AM_RANGE(0xff8240, 0xff825f) AM_READWRITE(atarist_shifter_palette_r, atariste_shifter_palette_w) |
| 929 | | AM_RANGE(0xff8260, 0xff8261) AM_READWRITE(atarist_shifter_mode_r, atarist_shifter_mode_w) |
| 880 | AM_RANGE(0xff8260, 0xff8261) AM_READWRITE8(atarist_shifter_mode_r, atarist_shifter_mode_w, 0xff00) |
| 930 | 881 | AM_RANGE(0xff8264, 0xff8265) AM_READWRITE(atariste_shifter_pixelofs_r, atariste_shifter_pixelofs_w) |
| 931 | 882 | AM_RANGE(0xff8604, 0xff8605) AM_READWRITE(atarist_fdc_data_r, atarist_fdc_data_w) |
| 932 | 883 | AM_RANGE(0xff8606, 0xff8607) AM_READWRITE(atarist_fdc_dma_status_r, atarist_fdc_dma_mode_w) |
| 933 | 884 | AM_RANGE(0xff8608, 0xff860d) AM_READWRITE(atarist_fdc_dma_base_r, atarist_fdc_dma_base_w) |
| 934 | | AM_RANGE(0xff8800, 0xff8801) AM_READWRITE(AY8910_read_port_0_msb_r, AY8910_control_port_0_msb_w) |
| 935 | | AM_RANGE(0xff8802, 0xff8803) AM_WRITE(AY8910_write_port_0_msb_w) |
| 885 | AM_RANGE(0xff8800, 0xff8801) AM_READWRITE8(AY8910_read_port_0_r, AY8910_control_port_0_w, 0xff00) |
| 886 | AM_RANGE(0xff8802, 0xff8803) AM_WRITE8(AY8910_write_port_0_w, 0xff00) |
| 936 | 887 | AM_RANGE(0xff8900, 0xff8901) AM_READWRITE(atariste_sound_dma_control_r, atariste_sound_dma_control_w) |
| 937 | 888 | AM_RANGE(0xff8902, 0xff8907) AM_READWRITE(atariste_sound_dma_base_r, atariste_sound_dma_base_w) |
| 938 | 889 | AM_RANGE(0xff8908, 0xff890d) AM_READ(atariste_sound_dma_counter_r) |
| r2431 | r2432 | |
| 960 | 911 | AM_RANGE(0xff9216, 0xff9217) AM_READ_PORT("PADDLE1Y") |
| 961 | 912 | AM_RANGE(0xff9220, 0xff9221) AM_READ_PORT("GUNX") |
| 962 | 913 | AM_RANGE(0xff9222, 0xff9223) AM_READ_PORT("GUNY") |
| 963 | | AM_RANGE(0xfffa00, 0xfffa2f) AM_READWRITE(atarist_mfp_r, atarist_mfp_w) |
| 964 | | AM_RANGE(0xfffc00, 0xfffc01) AM_READWRITE(acia6850_0_stat_msb_r, acia6850_0_ctrl_msb_w) |
| 965 | | AM_RANGE(0xfffc02, 0xfffc03) AM_READWRITE(acia6850_0_data_msb_r, acia6850_0_data_msb_w) |
| 966 | | AM_RANGE(0xfffc04, 0xfffc05) AM_READWRITE(acia6850_1_stat_msb_r, acia6850_1_ctrl_msb_w) |
| 967 | | AM_RANGE(0xfffc06, 0xfffc07) AM_READWRITE(acia6850_1_data_msb_r, acia6850_1_data_msb_w) |
| 914 | AM_RANGE(0xfffa00, 0xfffa2f) AM_DEVREADWRITE8(MC68901, MC68901_TAG, mc68901_register_r, mc68901_register_w, 0xff) |
| 915 | AM_RANGE(0xfffc00, 0xfffc01) AM_READWRITE8(acia6850_0_stat_r, acia6850_0_ctrl_w, 0xff00) |
| 916 | AM_RANGE(0xfffc02, 0xfffc03) AM_READWRITE8(acia6850_0_data_r, acia6850_0_data_w, 0xff00) |
| 917 | AM_RANGE(0xfffc04, 0xfffc05) AM_READWRITE8(acia6850_1_stat_r, acia6850_1_ctrl_w, 0xff00) |
| 918 | AM_RANGE(0xfffc06, 0xfffc07) AM_READWRITE8(acia6850_1_data_r, acia6850_1_data_w, 0xff00) |
| 968 | 919 | ADDRESS_MAP_END |
| 969 | 920 | |
| 970 | 921 | static ADDRESS_MAP_START( megaste_map, ADDRESS_SPACE_PROGRAM, 16 ) |
| r2431 | r2432 | |
| 977 | 928 | AM_RANGE(0xff8000, 0xff8007) AM_READWRITE(atarist_mmu_r, atarist_mmu_w) |
| 978 | 929 | AM_RANGE(0xff8200, 0xff8203) AM_READWRITE(atarist_shifter_base_r, atarist_shifter_base_w) |
| 979 | 930 | AM_RANGE(0xff8204, 0xff8209) AM_READWRITE(atariste_shifter_counter_r, atariste_shifter_counter_w) |
| 980 | | AM_RANGE(0xff820a, 0xff820b) AM_READWRITE(atarist_shifter_sync_r, atarist_shifter_sync_w) |
| 931 | AM_RANGE(0xff820a, 0xff820b) AM_READWRITE8(atarist_shifter_sync_r, atarist_shifter_sync_w, 0xff00) |
| 981 | 932 | AM_RANGE(0xff820c, 0xff820d) AM_READWRITE(atariste_shifter_base_low_r, atariste_shifter_base_low_w) |
| 982 | 933 | AM_RANGE(0xff820e, 0xff820f) AM_READWRITE(atariste_shifter_lineofs_r, atariste_shifter_lineofs_w) |
| 983 | 934 | AM_RANGE(0xff8240, 0xff825f) AM_READWRITE(atarist_shifter_palette_r, atariste_shifter_palette_w) |
| 984 | | AM_RANGE(0xff8260, 0xff8261) AM_READWRITE(atarist_shifter_mode_r, atarist_shifter_mode_w) |
| 935 | AM_RANGE(0xff8260, 0xff8261) AM_READWRITE8(atarist_shifter_mode_r, atarist_shifter_mode_w, 0xff00) |
| 985 | 936 | AM_RANGE(0xff8264, 0xff8265) AM_READWRITE(atariste_shifter_pixelofs_r, atariste_shifter_pixelofs_w) |
| 986 | 937 | AM_RANGE(0xff8604, 0xff8605) AM_READWRITE(atarist_fdc_data_r, atarist_fdc_data_w) |
| 987 | 938 | AM_RANGE(0xff8606, 0xff8607) AM_READWRITE(atarist_fdc_dma_status_r, atarist_fdc_dma_mode_w) |
| 988 | 939 | AM_RANGE(0xff8608, 0xff860d) AM_READWRITE(atarist_fdc_dma_base_r, atarist_fdc_dma_base_w) |
| 989 | | AM_RANGE(0xff8800, 0xff8801) AM_READWRITE(AY8910_read_port_0_msb_r, AY8910_control_port_0_msb_w) |
| 990 | | AM_RANGE(0xff8802, 0xff8803) AM_WRITE(AY8910_write_port_0_msb_w) |
| 940 | AM_RANGE(0xff8800, 0xff8801) AM_READWRITE8(AY8910_read_port_0_r, AY8910_control_port_0_w, 0xff00) |
| 941 | AM_RANGE(0xff8802, 0xff8803) AM_WRITE8(AY8910_write_port_0_w, 0xff00) |
| 991 | 942 | AM_RANGE(0xff8900, 0xff8901) AM_READWRITE(atariste_sound_dma_control_r, atariste_sound_dma_control_w) |
| 992 | 943 | AM_RANGE(0xff8902, 0xff8907) AM_READWRITE(atariste_sound_dma_base_r, atariste_sound_dma_base_w) |
| 993 | 944 | AM_RANGE(0xff8908, 0xff890d) AM_READ(atariste_sound_dma_counter_r) |
| r2431 | r2432 | |
| 1008 | 959 | AM_RANGE(0xff8a3a, 0xff8a3b) AM_READWRITE(atarist_blitter_op_r, atarist_blitter_op_w) |
| 1009 | 960 | AM_RANGE(0xff8a3c, 0xff8a3d) AM_READWRITE(atarist_blitter_ctrl_r, atarist_blitter_ctrl_w) |
| 1010 | 961 | AM_RANGE(0xff8e20, 0xff8e21) AM_READWRITE(megaste_cache_r, megaste_cache_w) |
| 1011 | | AM_RANGE(0xfffa00, 0xfffa3f) AM_READWRITE(atarist_mfp_r, atarist_mfp_w) |
| 962 | AM_RANGE(0xfffa00, 0xfffa3f) AM_DEVREADWRITE8(MC68901, MC68901_TAG, mc68901_register_r, mc68901_register_w, 0xff) |
| 1012 | 963 | // AM_RANGE(0xfffa40, 0xfffa5f) AM_READWRITE(megast_fpu_r, megast_fpu_w) |
| 1013 | | AM_RANGE(0xff8c80, 0xff8c87) AM_READWRITE(megaste_scc8530_r, megaste_scc8530_w) |
| 1014 | | AM_RANGE(0xfffc00, 0xfffc01) AM_READWRITE(acia6850_0_stat_msb_r, acia6850_0_ctrl_msb_w) |
| 1015 | | AM_RANGE(0xfffc02, 0xfffc03) AM_READWRITE(acia6850_0_data_msb_r, acia6850_0_data_msb_w) |
| 1016 | | AM_RANGE(0xfffc04, 0xfffc05) AM_READWRITE(acia6850_1_stat_msb_r, acia6850_1_ctrl_msb_w) |
| 1017 | | AM_RANGE(0xfffc06, 0xfffc07) AM_READWRITE(acia6850_1_data_msb_r, acia6850_1_data_msb_w) |
| 964 | AM_RANGE(0xff8c80, 0xff8c87) AM_READWRITE8(scc_r, scc_w, 0xff00) |
| 965 | AM_RANGE(0xfffc00, 0xfffc01) AM_READWRITE8(acia6850_0_stat_r, acia6850_0_ctrl_w, 0xff00) |
| 966 | AM_RANGE(0xfffc02, 0xfffc03) AM_READWRITE8(acia6850_0_data_r, acia6850_0_data_w, 0xff00) |
| 967 | AM_RANGE(0xfffc04, 0xfffc05) AM_READWRITE8(acia6850_1_stat_r, acia6850_1_ctrl_w, 0xff00) |
| 968 | AM_RANGE(0xfffc06, 0xfffc07) AM_READWRITE8(acia6850_1_data_r, acia6850_1_data_w, 0xff00) |
| 1018 | 969 | AM_RANGE(0xfffc20, 0xfffc3f) AM_READWRITE(rp5c15_r, rp5c15_w) |
| 1019 | 970 | ADDRESS_MAP_END |
| 1020 | 971 | |
| r2431 | r2432 | |
| 1031 | 982 | /* AM_RANGE(0xff8000, 0xff8001) AM_READWRITE(stbook_mmu_r, stbook_mmu_w) |
| 1032 | 983 | AM_RANGE(0xff8200, 0xff8203) AM_READWRITE(stbook_shifter_base_r, stbook_shifter_base_w) |
| 1033 | 984 | AM_RANGE(0xff8204, 0xff8209) AM_READWRITE(stbook_shifter_counter_r, stbook_shifter_counter_w) |
| 1034 | | AM_RANGE(0xff820a, 0xff820b) AM_READWRITE(stbook_shifter_sync_r, stbook_shifter_sync_w) |
| 985 | AM_RANGE(0xff820a, 0xff820b) AM_READWRITE8(stbook_shifter_sync_r, stbook_shifter_sync_w, 0xff00) |
| 1035 | 986 | AM_RANGE(0xff820c, 0xff820d) AM_READWRITE(stbook_shifter_base_low_r, stbook_shifter_base_low_w) |
| 1036 | 987 | AM_RANGE(0xff820e, 0xff820f) AM_READWRITE(stbook_shifter_lineofs_r, stbook_shifter_lineofs_w) |
| 1037 | 988 | AM_RANGE(0xff8240, 0xff8241) AM_READWRITE(stbook_shifter_palette_r, stbook_shifter_palette_w) |
| 1038 | | AM_RANGE(0xff8260, 0xff8261) AM_READWRITE(stbook_shifter_mode_r, stbook_shifter_mode_w) |
| 989 | AM_RANGE(0xff8260, 0xff8261) AM_READWRITE8(stbook_shifter_mode_r, stbook_shifter_mode_w, 0xff00) |
| 1039 | 990 | AM_RANGE(0xff8264, 0xff8265) AM_READWRITE(stbook_shifter_pixelofs_r, stbook_shifter_pixelofs_w)*/ |
| 1040 | 991 | AM_RANGE(0xff827e, 0xff827f) AM_WRITE(stbook_lcd_control_w) |
| 1041 | 992 | AM_RANGE(0xff8604, 0xff8605) AM_READWRITE(atarist_fdc_data_r, atarist_fdc_data_w) |
| 1042 | 993 | AM_RANGE(0xff8606, 0xff8607) AM_READWRITE(atarist_fdc_dma_status_r, atarist_fdc_dma_mode_w) |
| 1043 | 994 | AM_RANGE(0xff8608, 0xff860d) AM_READWRITE(atarist_fdc_dma_base_r, atarist_fdc_dma_base_w) |
| 1044 | | AM_RANGE(0xff8800, 0xff8801) AM_READWRITE(AY8910_read_port_0_msb_r, AY8910_control_port_0_msb_w) |
| 1045 | | AM_RANGE(0xff8802, 0xff8803) AM_WRITE(AY8910_write_port_0_msb_w) |
| 995 | AM_RANGE(0xff8800, 0xff8801) AM_READWRITE8(AY8910_read_port_0_r, AY8910_control_port_0_w, 0xff00) |
| 996 | AM_RANGE(0xff8802, 0xff8803) AM_WRITE8(AY8910_write_port_0_w, 0xff00) |
| 1046 | 997 | AM_RANGE(0xff8900, 0xff8901) AM_READWRITE(atariste_sound_dma_control_r, atariste_sound_dma_control_w) |
| 1047 | 998 | AM_RANGE(0xff8902, 0xff8907) AM_READWRITE(atariste_sound_dma_base_r, atariste_sound_dma_base_w) |
| 1048 | 999 | AM_RANGE(0xff8908, 0xff890d) AM_READ(atariste_sound_dma_counter_r) |
| r2431 | r2432 | |
| 1066 | 1017 | /* AM_RANGE(0xff9202, 0xff9203) AM_READWRITE(stbook_lcd_contrast_r, stbook_lcd_contrast_w) |
| 1067 | 1018 | AM_RANGE(0xff9210, 0xff9211) AM_READWRITE(stbook_power_r, stbook_power_w) |
| 1068 | 1019 | AM_RANGE(0xff9214, 0xff9215) AM_READWRITE(stbook_reference_r, stbook_reference_w)*/ |
| 1069 | | AM_RANGE(0xfffa00, 0xfffa2f) AM_READWRITE(atarist_mfp_r, atarist_mfp_w) |
| 1070 | | AM_RANGE(0xfffc00, 0xfffc01) AM_READWRITE(acia6850_0_stat_msb_r, acia6850_0_ctrl_msb_w) |
| 1071 | | AM_RANGE(0xfffc02, 0xfffc03) AM_READWRITE(acia6850_0_data_msb_r, acia6850_0_data_msb_w) |
| 1072 | | AM_RANGE(0xfffc04, 0xfffc05) AM_READWRITE(acia6850_1_stat_msb_r, acia6850_1_ctrl_msb_w) |
| 1073 | | AM_RANGE(0xfffc06, 0xfffc07) AM_READWRITE(acia6850_1_data_msb_r, acia6850_1_data_msb_w) |
| 1020 | AM_RANGE(0xfffa00, 0xfffa2f) AM_DEVREADWRITE8(MC68901, MC68901_TAG, mc68901_register_r, mc68901_register_w, 0xff) |
| 1021 | AM_RANGE(0xfffc00, 0xfffc01) AM_READWRITE8(acia6850_0_stat_r, acia6850_0_ctrl_w, 0xff00) |
| 1022 | AM_RANGE(0xfffc02, 0xfffc03) AM_READWRITE8(acia6850_0_data_r, acia6850_0_data_w, 0xff00) |
| 1023 | AM_RANGE(0xfffc04, 0xfffc05) AM_READWRITE8(acia6850_1_stat_r, acia6850_1_ctrl_w, 0xff00) |
| 1024 | AM_RANGE(0xfffc06, 0xfffc07) AM_READWRITE8(acia6850_1_data_r, acia6850_1_data_w, 0xff00) |
| 1074 | 1025 | ADDRESS_MAP_END |
| 1075 | 1026 | |
| 1076 | 1027 | /* Input Ports */ |
| r2431 | r2432 | |
| 1380 | 1331 | acia_interrupt |
| 1381 | 1332 | }; |
| 1382 | 1333 | |
| 1383 | | static READ8_HANDLER( mfp_gpio_r ) |
| 1334 | static MC68901_GPIO_READ( mfp_gpio_r ) |
| 1384 | 1335 | { |
| 1385 | 1336 | /* |
| 1386 | 1337 | |
| r2431 | r2432 | |
| 1397 | 1348 | |
| 1398 | 1349 | */ |
| 1399 | 1350 | |
| 1400 | | atarist_state *state = machine->driver_data; |
| 1401 | | |
| 1402 | 1351 | UINT8 data = (centronics_read_handshake(0) & CENTRONICS_NOT_BUSY) >> 7; |
| 1403 | 1352 | |
| 1404 | | mc68901_tai_w(state->mfp, data & 0x01); |
| 1353 | mc68901_tai_w(device, data & 0x01); |
| 1405 | 1354 | |
| 1406 | 1355 | data |= (acia_irq << 4); |
| 1407 | 1356 | data |= (fdc.irq << 5); |
| 1408 | | data |= (input_port_read(machine, "config") & 0x80); |
| 1357 | data |= (input_port_read(device->machine, "config") & 0x80); |
| 1409 | 1358 | |
| 1410 | 1359 | return data; |
| 1411 | 1360 | } |
| 1412 | 1361 | |
| 1413 | | static IRQ_CALLBACK(atarist_int_ack) |
| 1362 | static IRQ_CALLBACK( atarist_int_ack ) |
| 1414 | 1363 | { |
| 1415 | | atarist_state *state = machine->driver_data; |
| 1364 | const device_config *mc68901 = device_list_find_by_tag(machine->config->devicelist, MC68901, MC68901_TAG); |
| 1416 | 1365 | |
| 1417 | 1366 | if (irqline == MC68000_IRQ_6) |
| 1418 | 1367 | { |
| 1419 | | return mc68901_get_vector(state->mfp); |
| 1368 | return mc68901_get_vector(mc68901); |
| 1420 | 1369 | } |
| 1421 | 1370 | |
| 1422 | 1371 | return MC68000_INT_ACK_AUTOVECTOR; |
| 1423 | 1372 | } |
| 1424 | 1373 | |
| 1425 | | static void mfp_interrupt(mc68901_t *chip, int state) |
| 1374 | static MC68901_ON_IRQ_CHANGED( mfp_interrupt ) |
| 1426 | 1375 | { |
| 1427 | | cpunum_set_input_line(Machine, 0, MC68000_IRQ_6, state); |
| 1376 | cpunum_set_input_line(device->machine, 0, MC68000_IRQ_6, level); |
| 1428 | 1377 | } |
| 1429 | 1378 | |
| 1430 | 1379 | static UINT8 mfp_rx, mfp_tx; |
| 1431 | 1380 | |
| 1432 | | static const mc68901_interface mfp_intf = |
| 1381 | static MC68901_INTERFACE( mfp_intf ) |
| 1433 | 1382 | { |
| 1434 | 1383 | Y2/8, |
| 1435 | 1384 | Y1, |
| r2431 | r2432 | |
| 1521 | 1470 | |
| 1522 | 1471 | static MACHINE_START( atarist ) |
| 1523 | 1472 | { |
| 1524 | | atarist_state *state = machine->driver_data; |
| 1525 | | |
| 1526 | 1473 | atarist_configure_memory(machine); |
| 1527 | 1474 | atarist_state_save(); |
| 1528 | 1475 | |
| r2431 | r2432 | |
| 1530 | 1477 | wd17xx_init(machine, WD_TYPE_1772, atarist_fdc_callback, NULL); |
| 1531 | 1478 | acia6850_config(0, &acia_ikbd_intf); |
| 1532 | 1479 | acia6850_config(1, &acia_midi_intf); |
| 1533 | | state->mfp = devtag_get_token(machine, MC68901, "mfp"); |
| 1534 | 1480 | |
| 1535 | 1481 | cpunum_set_irq_callback(0, atarist_int_ack); |
| 1536 | 1482 | } |
| r2431 | r2432 | |
| 1546 | 1492 | rp5c15_init(machine, &rtc_intf); |
| 1547 | 1493 | } |
| 1548 | 1494 | |
| 1549 | | static READ8_HANDLER( atariste_mfp_gpio_r ) |
| 1495 | static MC68901_GPIO_READ( atariste_mfp_gpio_r ) |
| 1550 | 1496 | { |
| 1551 | 1497 | /* |
| 1552 | 1498 | |
| r2431 | r2432 | |
| 1567 | 1513 | |
| 1568 | 1514 | data |= (acia_irq << 4); |
| 1569 | 1515 | data |= (fdc.irq << 5); |
| 1570 | | data |= (input_port_read(machine, "config") & 0x80) ^ (dmasound.active << 7); |
| 1516 | data |= (input_port_read(device->machine, "config") & 0x80) ^ (dmasound.active << 7); |
| 1571 | 1517 | |
| 1572 | 1518 | return data; |
| 1573 | 1519 | } |
| 1574 | 1520 | |
| 1575 | | static const mc68901_interface atariste_mfp_intf = |
| 1521 | static MC68901_INTERFACE( atariste_mfp_intf ) |
| 1576 | 1522 | { |
| 1577 | 1523 | Y2/8, |
| 1578 | 1524 | Y1, |
| r2431 | r2432 | |
| 1611 | 1557 | |
| 1612 | 1558 | static MACHINE_START( atariste ) |
| 1613 | 1559 | { |
| 1614 | | atarist_state *state = machine->driver_data; |
| 1615 | | |
| 1616 | 1560 | atarist_configure_memory(machine); |
| 1617 | 1561 | atariste_state_save(); |
| 1618 | 1562 | |
| r2431 | r2432 | |
| 1620 | 1564 | wd17xx_init(machine, WD_TYPE_1772, atarist_fdc_callback, NULL); |
| 1621 | 1565 | acia6850_config(0, &acia_ikbd_intf); |
| 1622 | 1566 | acia6850_config(1, &acia_midi_intf); |
| 1623 | | state->mfp = devtag_get_token(machine, MC68901, "mfp"); |
| 1624 | 1567 | |
| 1625 | 1568 | cpunum_set_irq_callback(0, atarist_int_ack); |
| 1626 | 1569 | |
| r2431 | r2432 | |
| 1706 | 1649 | acia_interrupt |
| 1707 | 1650 | }; |
| 1708 | 1651 | |
| 1709 | | static READ8_HANDLER( stbook_mfp_gpio_r ) |
| 1652 | static MC68901_GPIO_READ( stbook_mfp_gpio_r ) |
| 1710 | 1653 | { |
| 1711 | 1654 | /* |
| 1712 | 1655 | |
| r2431 | r2432 | |
| 1731 | 1674 | return data; |
| 1732 | 1675 | } |
| 1733 | 1676 | |
| 1734 | | static const mc68901_interface stbook_mfp_intf = |
| 1677 | static MC68901_INTERFACE( stbook_mfp_intf ) |
| 1735 | 1678 | { |
| 1736 | 1679 | Y2/8, |
| 1737 | 1680 | Y1, |
| r2431 | r2432 | |
| 1747 | 1690 | |
| 1748 | 1691 | static MACHINE_START( stbook ) |
| 1749 | 1692 | { |
| 1750 | | atarist_state *state = machine->driver_data; |
| 1751 | | |
| 1752 | 1693 | stbook_configure_memory(machine); |
| 1753 | 1694 | atariste_state_save(); |
| 1754 | 1695 | |
| r2431 | r2432 | |
| 1759 | 1700 | wd17xx_init(machine, WD_TYPE_1772, atarist_fdc_callback, NULL); |
| 1760 | 1701 | acia6850_config(0, &stbook_acia_ikbd_intf); |
| 1761 | 1702 | acia6850_config(1, &acia_midi_intf); |
| 1762 | | state->mfp = devtag_get_token(machine, MC68901, "mfp"); |
| 1763 | 1703 | rp5c15_init(machine, &rtc_intf); |
| 1764 | 1704 | |
| 1765 | 1705 | cpunum_set_irq_callback(0, atarist_int_ack); |
| r2431 | r2432 | |
| 1780 | 1720 | |
| 1781 | 1721 | // device hardware |
| 1782 | 1722 | |
| 1783 | | MDRV_DEVICE_ADD("mfp", MC68901) |
| 1723 | MDRV_DEVICE_ADD(MC68901_TAG, MC68901) |
| 1784 | 1724 | MDRV_DEVICE_CONFIG(mfp_intf) |
| 1785 | 1725 | |
| 1786 | 1726 | // video hardware |
| r2431 | r2432 | |
| 1826 | 1766 | |
| 1827 | 1767 | // device hardware |
| 1828 | 1768 | |
| 1829 | | MDRV_DEVICE_ADD("mfp", MC68901) |
| 1769 | MDRV_DEVICE_ADD(MC68901_TAG, MC68901) |
| 1830 | 1770 | MDRV_DEVICE_CONFIG(atariste_mfp_intf) |
| 1831 | 1771 | |
| 1832 | 1772 | // video hardware |
| r2431 | r2432 | |
| 1877 | 1817 | |
| 1878 | 1818 | // device hardware |
| 1879 | 1819 | |
| 1880 | | MDRV_DEVICE_ADD("mfp", MC68901) |
| 1820 | MDRV_DEVICE_ADD(MC68901_TAG, MC68901) |
| 1881 | 1821 | MDRV_DEVICE_CONFIG(stbook_mfp_intf) |
| 1882 | 1822 | |
| 1883 | 1823 | // video hardware |