src/emu/machine/z80pio.c
| r3596 | r3597 | |
| 1 | 1 | /*************************************************************************** |
| 2 | 2 | |
| 3 | | Z80 PIO implementation |
| 3 | Z80 PIO Parallel Input/Output Controller emulation |
| 4 | 4 | |
| 5 | | based on original version (c) 1997, Tatsuyuki Satoh |
| 6 | | |
| 7 | 5 | Copyright Nicola Salmoria and the MAME Team. |
| 8 | 6 | Visit http://mamedev.org for licensing and usage restrictions. |
| 9 | 7 | |
| r3596 | r3597 | |
| 14 | 12 | #include "cpu/z80/z80.h" |
| 15 | 13 | #include "cpu/z80/z80daisy.h" |
| 16 | 14 | |
| 17 | | |
| 18 | | |
| 19 | 15 | /*************************************************************************** |
| 20 | 16 | DEBUGGING |
| 21 | 17 | ***************************************************************************/ |
| 22 | 18 | |
| 23 | | #define VERBOSE |
| 19 | #define VERBOSE |
| 24 | 20 | |
| 25 | | #define VPRINTF(x) do { if (VERBOSE) logerror x; } while (0) |
| 21 | #define LOGERROR if (VERBOSE) logerror |
| 26 | 22 | |
| 27 | | |
| 28 | | |
| 29 | 23 | /*************************************************************************** |
| 30 | 24 | CONSTANTS |
| 31 | 25 | ***************************************************************************/ |
| 32 | 26 | |
| 33 | | #define PIO_MODE0 0x00 /* output mode */ |
| 34 | | #define PIO_MODE1 0x01 /* input mode */ |
| 35 | | #define PIO_MODE2 0x02 /* i/o mode */ |
| 36 | | #define PIO_MODE3 0x03 /* bit mode */ |
| 27 | enum |
| 28 | { |
| 29 | PIO_MODE_OUTPUT = 0, |
| 30 | PIO_MODE_INPUT, |
| 31 | PIO_MODE_BIDIRECTIONAL, |
| 32 | PIO_MODE_CONTROL |
| 33 | }; |
| 37 | 34 | |
| 38 | | /* pio controll port operation (bit 0-3) */ |
| 39 | | #define PIO_OP_MODE 0x0f /* mode select */ |
| 40 | | #define PIO_OP_INTC 0x07 /* interrupt controll */ |
| 41 | | #define PIO_OP_INTE 0x03 /* interrupt enable */ |
| 35 | enum |
| 36 | { |
| 37 | PIO_STATE_NORMAL = 0, |
| 38 | PIO_STATE_DDR, |
| 39 | PIO_STATE_MASK |
| 40 | }; |
| 42 | 41 | |
| 43 | | /* pio interrupt controll nit */ |
| 44 | | #define PIO_INT_ENABLE 0x80 /* ENABLE : 0=disable , 1=enable */ |
| 45 | | #define PIO_INT_AND 0x40 /* LOGIC : 0=OR , 1=AND */ |
| 46 | | #define PIO_INT_HIGH 0x20 /* LEVEL : 0=low , 1=high */ |
| 47 | | #define PIO_INT_MASK 0x10 /* MASK : 0=off , 1=on */ |
| 42 | enum |
| 43 | { |
| 44 | PIO_PORT_A = 0, |
| 45 | PIO_PORT_B, |
| 46 | PIO_PORT_COUNT |
| 47 | }; |
| 48 | 48 | |
| 49 | #define PIO_MODE_CONTROL_WORD 0x0f |
| 50 | #define PIO_IRQ_CONTROL_WORD 0x07 |
| 51 | #define PIO_IRQ_DISABLE_WORD 0x03 |
| 49 | 52 | |
| 53 | #define PIO_IRQ_MASK_FOLLOWS 0x10 |
| 54 | #define PIO_IRQ_ACTIVE_HIGH 0x20 |
| 55 | #define PIO_IRQ_AND 0x40 |
| 56 | #define PIO_IRQ_ENABLE 0x80 |
| 50 | 57 | |
| 51 | 58 | /*************************************************************************** |
| 52 | 59 | TYPE DEFINITIONS |
| r3596 | r3597 | |
| 55 | 62 | typedef struct _z80pio z80pio_t; |
| 56 | 63 | struct _z80pio |
| 57 | 64 | { |
| 58 | | UINT8 vector[2]; /* interrupt vector */ |
| 59 | | void (*intr)(const device_config *, int which); /* interrupt callbacks */ |
| 60 | | void (*rdyr[2])(int data); /* RDY active callback */ |
| 61 | | read8_device_func port_read[2]; /* port read callbacks */ |
| 62 | | write8_device_func port_write[2]; /* port write callbacks */ |
| 63 | | UINT8 mode[2]; /* mode 00=in,01=out,02=i/o,03=bit*/ |
| 64 | | UINT8 enable[2]; /* interrupt enable */ |
| 65 | | UINT8 mask[2]; /* mask folowers */ |
| 66 | | UINT8 dir[2]; /* direction (bit mode) */ |
| 67 | | UINT8 rdy[2]; /* ready pin level */ |
| 68 | | UINT8 in[2]; /* input port data */ |
| 69 | | UINT8 out[2]; /* output port */ |
| 70 | | UINT8 strobe[2]; /* strobe inputs */ |
| 71 | | UINT8 int_state[2]; /* interrupt status (daisy chain) */ |
| 72 | | }; |
| 65 | const z80pio_interface *intf; /* interface */ |
| 73 | 66 | |
| 67 | int clock; /* clock frequency */ |
| 74 | 68 | |
| 69 | int state[PIO_PORT_COUNT]; /* control register state */ |
| 70 | int mode[PIO_PORT_COUNT]; /* mode control register */ |
| 71 | int irq_enable[PIO_PORT_COUNT]; /* interrupt enable flag */ |
| 72 | int irq_pending[PIO_PORT_COUNT]; /* interrupt pending flag */ |
| 73 | int int_state[PIO_PORT_COUNT]; /* interrupt status */ |
| 74 | UINT8 enable[PIO_PORT_COUNT]; /* interrupt control word */ |
| 75 | UINT8 input[PIO_PORT_COUNT]; /* data input register */ |
| 76 | UINT8 output[PIO_PORT_COUNT]; /* data output register */ |
| 77 | UINT8 vector[PIO_PORT_COUNT]; /* interrupt vector */ |
| 78 | UINT8 mask[PIO_PORT_COUNT]; /* mask register */ |
| 79 | UINT8 ddr[PIO_PORT_COUNT]; /* input/output select register */ |
| 80 | int strobe[PIO_PORT_COUNT]; /* strobe pulse */ |
| 81 | int match[PIO_PORT_COUNT]; /* control mode bit logic equation match */ |
| 75 | 82 | |
| 83 | /* timers */ |
| 84 | emu_timer *poll_timer; /* mode 3 poll timer */ |
| 85 | emu_timer *irq_timer; /* interrupt enable timer */ |
| 86 | }; |
| 87 | |
| 76 | 88 | /*************************************************************************** |
| 77 | 89 | FUNCTION PROTOTYPES |
| 78 | 90 | ***************************************************************************/ |
| r3596 | r3597 | |
| 81 | 93 | static int z80pio_irq_ack(const device_config *device); |
| 82 | 94 | static void z80pio_irq_reti(const device_config *device); |
| 83 | 95 | |
| 84 | | |
| 85 | | |
| 86 | 96 | /*************************************************************************** |
| 87 | 97 | INLINE FUNCTIONS |
| 88 | 98 | ***************************************************************************/ |
| r3596 | r3597 | |
| 92 | 102 | assert(device != NULL); |
| 93 | 103 | assert(device->token != NULL); |
| 94 | 104 | assert(device->type == Z80PIO); |
| 105 | |
| 95 | 106 | return (z80pio_t *)device->token; |
| 96 | 107 | } |
| 97 | 108 | |
| 98 | | |
| 99 | 109 | /*************************************************************************** |
| 100 | 110 | INTERNAL STATE MANAGEMENT |
| 101 | 111 | ***************************************************************************/ |
| 102 | 112 | |
| 103 | | INLINE void set_rdy(const device_config *device, int ch, int state) |
| 113 | static void z80pio_check_interrupt(const device_config *device) |
| 104 | 114 | { |
| 105 | | z80pio_t *z80pio = get_safe_token( device ); |
| 106 | | /* set state */ |
| 107 | | z80pio->rdy[ch] = state; |
| 115 | z80pio_t *z80pio = get_safe_token(device); |
| 116 | int channel; |
| 108 | 117 | |
| 109 | | /* call callback with state */ |
| 110 | | if (z80pio->rdyr[ch]) |
| 111 | | z80pio->rdyr[ch](z80pio->rdy[ch]); |
| 118 | for (channel = PIO_PORT_A; channel < PIO_PORT_COUNT; channel++) |
| 119 | { |
| 120 | if (z80pio->irq_enable[channel]) |
| 121 | { |
| 122 | if (z80pio->irq_pending[channel]) |
| 123 | { |
| 124 | /* trigger interrupt request */ |
| 125 | z80pio->int_state[channel] |= Z80_DAISY_INT; |
| 126 | |
| 127 | /* reset interrupt pending */ |
| 128 | z80pio->irq_pending[channel] = 0; |
| 129 | |
| 130 | LOGERROR("Z80PIO \"%s\" Port %c : Interrupt Request\n", device->tag, 'A' + channel); |
| 131 | } |
| 132 | } |
| 133 | else |
| 134 | { |
| 135 | /* clear interrupt request */ |
| 136 | z80pio->int_state[channel] &= ~Z80_DAISY_INT; |
| 137 | } |
| 138 | } |
| 139 | |
| 140 | if (z80pio->intf->on_int_changed) |
| 141 | { |
| 142 | z80pio->intf->on_int_changed(device, (z80pio_irq_state(device) & Z80_DAISY_INT) ? ASSERT_LINE : CLEAR_LINE); |
| 143 | } |
| 112 | 144 | } |
| 113 | 145 | |
| 146 | static void z80pio_trigger_interrupt(const device_config *device, int channel) |
| 147 | { |
| 148 | z80pio_t *z80pio = get_safe_token(device); |
| 114 | 149 | |
| 115 | | INLINE void interrupt_check(const device_config *device) |
| 150 | if (z80pio->irq_enable[channel]) |
| 151 | { |
| 152 | z80pio->int_state[channel] |= Z80_DAISY_INT; |
| 153 | z80pio_check_interrupt(device); |
| 154 | |
| 155 | LOGERROR("Z80PIO \"%s\" Port %c : Interrupt Request\n", device->tag, 'A' + channel); |
| 156 | } |
| 157 | else |
| 158 | { |
| 159 | /* set interrupt pending */ |
| 160 | z80pio->irq_pending[channel] = 1; |
| 161 | z80pio_check_interrupt(device); |
| 162 | |
| 163 | LOGERROR("Z80PIO \"%s\" Port %c : Interrupt Pending\n", device->tag, 'A' + channel); |
| 164 | } |
| 165 | } |
| 166 | |
| 167 | static TIMER_CALLBACK( z80pio_irq_tick ) |
| 116 | 168 | { |
| 117 | | z80pio_t *z80pio = get_safe_token( device ); |
| 169 | const device_config *device = (device_config *) ptr; |
| 170 | z80pio_t *z80pio = get_safe_token(device); |
| 118 | 171 | |
| 119 | | /* if we have a callback, update it with the current state */ |
| 120 | | if (z80pio->intr) |
| 121 | | z80pio->intr(device, (z80pio_irq_state(device) & Z80_DAISY_INT) ? ASSERT_LINE : CLEAR_LINE); |
| 172 | int channel = BIT(param, 1); |
| 173 | int state = BIT(param, 0); |
| 174 | |
| 175 | /* set interrupt enable */ |
| 176 | z80pio->irq_enable[channel] = state; |
| 177 | |
| 178 | LOGERROR("Z80PIO \"%s\" Port %c : Interrupt Enable %u\n", device->tag, 'A' + channel, state); |
| 179 | |
| 180 | /* check interrupt status */ |
| 181 | z80pio_check_interrupt(device); |
| 122 | 182 | } |
| 123 | 183 | |
| 184 | static void z80pio_set_irq_enable(const device_config *device, int channel, int state) |
| 185 | { |
| 186 | z80pio_t *z80pio = get_safe_token(device); |
| 124 | 187 | |
| 125 | | static void update_irq_state(const device_config *device, int ch) |
| 188 | if (state) |
| 189 | { |
| 190 | /* enable interrupt on next _M1 */ |
| 191 | int param = (channel << 1) | state; |
| 192 | |
| 193 | timer_adjust_oneshot(z80pio->irq_timer, ATTOTIME_IN_HZ(z80pio->clock * 4), param); |
| 194 | } |
| 195 | else |
| 196 | { |
| 197 | /* disable interrupt immediately */ |
| 198 | z80pio->irq_enable[channel] = state; |
| 199 | |
| 200 | LOGERROR("Z80PIO \"%s\" Port %c : Interrupt Enable %u\n", device->tag, 'A' + channel, state); |
| 201 | } |
| 202 | } |
| 203 | |
| 204 | static void z80pio_ready_w(const device_config *device, int channel, int state) |
| 126 | 205 | { |
| 127 | | z80pio_t *z80pio = get_safe_token( device ); |
| 128 | | int old_state = z80pio->int_state[ch]; |
| 129 | | int irq = 0; |
| 130 | | int data; |
| 131 | | if (z80pio->mode[ch] == 0x13 || (z80pio->enable[ch] & PIO_INT_MASK)) return; |
| 206 | z80pio_t *z80pio = get_safe_token(device); |
| 132 | 207 | |
| 133 | | /* only check if interrupts are enabled */ |
| 134 | | if (z80pio->enable[ch] & PIO_INT_ENABLE) |
| 208 | LOGERROR("Z80PIO \"%s\" Port %c : Ready %u\n", device->tag, 'A' + channel, state); |
| 209 | |
| 210 | if (channel == PIO_PORT_A) |
| 135 | 211 | { |
| 136 | | /* in mode 3, interrupts are tricky */ |
| 137 | | if (z80pio->mode[ch] == PIO_MODE3) |
| 212 | if (z80pio->intf->on_ardy_changed) |
| 138 | 213 | { |
| 139 | | /* fetch input data (ignore output lines) */ |
| 140 | | data = z80pio->in[ch] & z80pio->dir[ch]; |
| 214 | z80pio->intf->on_ardy_changed(device, state); |
| 215 | } |
| 216 | } |
| 217 | else |
| 218 | { |
| 219 | if (z80pio->intf->on_brdy_changed) |
| 220 | { |
| 221 | z80pio->intf->on_brdy_changed(device, state); |
| 222 | } |
| 223 | } |
| 224 | } |
| 141 | 225 | |
| 142 | | /* keep only relevant bits */ |
| 143 | | data &= ~z80pio->mask[ch]; |
| 226 | static UINT8 z80pio_port_r(const device_config *device, int channel) |
| 227 | { |
| 228 | z80pio_t *z80pio = get_safe_token(device); |
| 229 | UINT8 data = 0; |
| 144 | 230 | |
| 145 | | /* if active low, invert the bits */ |
| 146 | | if (!(z80pio->enable[ch] & PIO_INT_HIGH)) |
| 147 | | data ^= z80pio->mask[ch]; |
| 231 | if (channel == PIO_PORT_A) |
| 232 | { |
| 233 | if (z80pio->intf->port_a_r) |
| 234 | { |
| 235 | data = z80pio->intf->port_a_r(device, 0); |
| 236 | } |
| 237 | } |
| 238 | else |
| 239 | { |
| 240 | if (z80pio->intf->port_b_r) |
| 241 | { |
| 242 | data = z80pio->intf->port_b_r(device, 0); |
| 243 | } |
| 244 | } |
| 148 | 245 | |
| 149 | | /* if AND logic, interrupt if all bits are set */ |
| 150 | | if (z80pio->enable[ch] & PIO_INT_AND) |
| 151 | | irq = (data == z80pio->mask[ch]); |
| 246 | //LOGERROR("Z80PIO \"%s\" Port %c : Input Data '%02x'\n", device->tag, 'A' + channel, data); |
| 152 | 247 | |
| 153 | | /* otherwise, interrupt if at least one bit is set */ |
| 154 | | else |
| 155 | | irq = (data != 0); |
| 248 | return data; |
| 249 | } |
| 156 | 250 | |
| 157 | | /* if portB, portA mode 2 check */ |
| 158 | | if (ch && (z80pio->mode[0] == PIO_MODE2)) |
| 159 | | { |
| 160 | | if (z80pio->rdy[ch] == 0) |
| 161 | | irq = 1; |
| 162 | | } |
| 163 | | } |
| 251 | static void z80pio_port_w(const device_config *device, int channel) |
| 252 | { |
| 253 | z80pio_t *z80pio = get_safe_token(device); |
| 254 | UINT8 data = z80pio->output[channel]; |
| 164 | 255 | |
| 165 | | /* otherwise, just interrupt when ready is cleared */ |
| 166 | | else |
| 167 | | irq = (z80pio->rdy[ch] == 0); |
| 256 | if (z80pio->mode[channel] == PIO_MODE_CONTROL) |
| 257 | { |
| 258 | /* mask input pins */ |
| 259 | data &= ~z80pio->ddr[channel]; |
| 168 | 260 | } |
| 169 | 261 | |
| 170 | | if (irq) |
| 171 | | z80pio->int_state[ch] |= Z80_DAISY_INT; |
| 262 | if (channel == PIO_PORT_A) |
| 263 | { |
| 264 | if (z80pio->intf->port_a_w) |
| 265 | { |
| 266 | z80pio->intf->port_a_w(device, 0, data); |
| 267 | } |
| 268 | } |
| 172 | 269 | else |
| 173 | | z80pio->int_state[ch] &= ~Z80_DAISY_INT; |
| 270 | { |
| 271 | if (z80pio->intf->port_b_w) |
| 272 | { |
| 273 | z80pio->intf->port_b_w(device, 0, data); |
| 274 | } |
| 275 | } |
| 174 | 276 | |
| 175 | | if (old_state != z80pio->int_state[ch]) |
| 176 | | interrupt_check(device); |
| 277 | //LOGERROR("Z80PIO \"%s\" Port %c : Output Data '%02x'\n", device->tag, 'A' + channel, data); |
| 177 | 278 | } |
| 178 | 279 | |
| 280 | static void z80pio_set_mode(const device_config *device, int channel, UINT8 data) |
| 281 | { |
| 282 | z80pio_t *z80pio = get_safe_token(device); |
| 179 | 283 | |
| 284 | int mode = data >> 6; |
| 180 | 285 | |
| 286 | switch (mode) |
| 287 | { |
| 288 | case PIO_MODE_OUTPUT: |
| 289 | LOGERROR("Z80PIO \"%s\" Port %c : Mode %u (Byte Output)\n", device->tag, 'A' + channel, mode); |
| 290 | |
| 291 | /* set mode */ |
| 292 | z80pio->mode[channel] = mode; |
| 293 | |
| 294 | /* enable data output */ |
| 295 | z80pio_port_w(device, channel); |
| 296 | |
| 297 | /* assert ready line */ |
| 298 | z80pio_ready_w(device, channel, 1); |
| 299 | break; |
| 300 | |
| 301 | case PIO_MODE_INPUT: |
| 302 | LOGERROR("Z80PIO \"%s\" Port %c : Mode %u (Byte Input)\n", device->tag, 'A' + channel, mode); |
| 303 | |
| 304 | /* set mode */ |
| 305 | z80pio->mode[channel] = mode; |
| 306 | break; |
| 307 | |
| 308 | case PIO_MODE_BIDIRECTIONAL: |
| 309 | if (channel == PIO_PORT_A) |
| 310 | { |
| 311 | LOGERROR("Z80PIO \"%s\" Port %c : Mode %u (Bidirectional)\n", device->tag, 'A' + channel, mode); |
| 312 | |
| 313 | /* set mode */ |
| 314 | z80pio->mode[channel] = mode; |
| 315 | } |
| 316 | break; |
| 317 | |
| 318 | case PIO_MODE_CONTROL: |
| 319 | LOGERROR("Z80PIO \"%s\" Port %c : Mode %u (Bit Control)\n", device->tag, 'A' + channel, mode); |
| 320 | |
| 321 | /* set mode */ |
| 322 | z80pio->mode[channel] = mode; |
| 323 | |
| 324 | if ((channel == PIO_PORT_A) || (z80pio->mode[PIO_PORT_A] != PIO_MODE_BIDIRECTIONAL)) |
| 325 | { |
| 326 | /* clear ready line */ |
| 327 | z80pio_ready_w(device, channel, 0); |
| 328 | } |
| 329 | |
| 330 | /* disable interrupts until DDR is written */ |
| 331 | z80pio_set_irq_enable(device, channel, 0); |
| 332 | |
| 333 | /* set logic equation to false */ |
| 334 | z80pio->match[channel] = 0; |
| 335 | |
| 336 | /* next word is I/O control */ |
| 337 | z80pio->state[channel] = PIO_STATE_DDR; |
| 338 | break; |
| 339 | } |
| 340 | } |
| 341 | |
| 181 | 342 | /*************************************************************************** |
| 182 | 343 | CONTROL REGISTER READ/WRITE |
| 183 | 344 | ***************************************************************************/ |
| 184 | 345 | |
| 185 | | WRITE8_DEVICE_HANDLER( z80pio_c_w ) |
| 346 | READ8_DEVICE_HANDLER( lh0081_c_r ) |
| 186 | 347 | { |
| 187 | | z80pio_t *z80pio = get_safe_token( device ); |
| 348 | z80pio_t *z80pio = get_safe_token(device); |
| 188 | 349 | |
| 189 | | /* There are only 2 channels */ |
| 190 | | offset &= 0x01; |
| 350 | return (z80pio->enable[PIO_PORT_A] & 0xc0) | (z80pio->enable[PIO_PORT_B] >> 4); |
| 351 | } |
| 191 | 352 | |
| 192 | | /* load direction phase ? */ |
| 193 | | if (z80pio->mode[offset] == 0x13) |
| 194 | | { |
| 195 | | VPRINTF(("PIO-%c Bits %02x\n", 'A' + offset, data)); |
| 196 | | z80pio->dir[offset] = data; |
| 197 | | z80pio->mode[offset] = 0x03; |
| 198 | | return; |
| 199 | | } |
| 353 | READ8_DEVICE_HANDLER( z80pio_c_r ) |
| 354 | { |
| 355 | return 0; |
| 356 | } |
| 200 | 357 | |
| 201 | | /* load mask folows phase ? */ |
| 202 | | if (z80pio->enable[offset] & PIO_INT_MASK) |
| 203 | | { |
| 204 | | /* load mask folows */ |
| 205 | | z80pio->mask[offset] = data; |
| 206 | | z80pio->enable[offset] &= ~PIO_INT_MASK; |
| 207 | | VPRINTF(("PIO-%c interrupt mask %02x\n",'A'+offset,data )); |
| 208 | | return; |
| 209 | | } |
| 358 | WRITE8_DEVICE_HANDLER( z80pio_c_w ) |
| 359 | { |
| 360 | z80pio_t *z80pio = get_safe_token(device); |
| 361 | int channel = offset & 0x01; |
| 210 | 362 | |
| 211 | | switch (data & 0x0f) |
| 363 | switch (z80pio->state[channel]) |
| 212 | 364 | { |
| 213 | | case PIO_OP_MODE: /* mode select 0=out,1=in,2=i/o,3=bit */ |
| 214 | | z80pio->mode[offset] = (data >> 6); |
| 215 | | VPRINTF(("PIO-%c Mode %x\n", 'A' + offset, z80pio->mode[offset])); |
| 216 | | if (z80pio->mode[offset] == 0x03) |
| 217 | | z80pio->mode[offset] = 0x13; |
| 218 | | return; |
| 365 | case PIO_STATE_NORMAL: |
| 366 | if (!BIT(data, 0)) |
| 367 | { |
| 368 | LOGERROR("Z80PIO \"%s\" Port %c : Interrupt Vector Word '%02x'\n", device->tag, 'A' + channel, z80pio->vector[channel]); |
| 219 | 369 | |
| 220 | | case PIO_OP_INTC: /* interrupt control */ |
| 221 | | z80pio->enable[offset] = data & 0xf0; |
| 222 | | z80pio->mask[offset] = 0x00; |
| 223 | | /* when interrupt enable , set vector request flag */ |
| 224 | | VPRINTF(("PIO-%c Controll %02x\n", 'A' + offset, data)); |
| 225 | | break; |
| 370 | /* load interrupt vector */ |
| 371 | z80pio->vector[channel] = data & 0xfe; |
| 372 | } |
| 373 | else if ((data & 0x0f) == PIO_IRQ_DISABLE_WORD) |
| 374 | { |
| 375 | LOGERROR("Z80PIO \"%s\" Port %c : Interrupt Disable Word '%02x'\n", device->tag, 'A' + channel, data); |
| 226 | 376 | |
| 227 | | case PIO_OP_INTE: /* interrupt enable controll */ |
| 228 | | z80pio->enable[offset] &= ~PIO_INT_ENABLE; |
| 229 | | z80pio->enable[offset] |= (data & PIO_INT_ENABLE); |
| 230 | | VPRINTF(("PIO-%c enable %02x\n", 'A' + offset, data & 0x80)); |
| 231 | | break; |
| 377 | /* set interrupt enable */ |
| 378 | z80pio->enable[channel] = (data & 0x80) | (z80pio->enable[channel] & 0x7f); |
| 379 | z80pio_set_irq_enable(device, channel, BIT(data, 7)); |
| 380 | } |
| 381 | else if ((data & 0x0f) == PIO_MODE_CONTROL_WORD) |
| 382 | { |
| 383 | LOGERROR("Z80PIO \"%s\" Port %c : Mode Control Word '%02x'\n", device->tag, 'A' + channel, data); |
| 232 | 384 | |
| 233 | | default: |
| 234 | | if (!(data & 1)) |
| 385 | /* set operating mode */ |
| 386 | z80pio_set_mode(device, channel, data); |
| 387 | } |
| 388 | else if ((data & 0x0f) == PIO_IRQ_CONTROL_WORD) |
| 389 | { |
| 390 | LOGERROR("Z80PIO \"%s\" Port %c : Interrupt Control Word '%02x'\n", device->tag, 'A' + channel, data); |
| 391 | |
| 392 | /* set interrupt control word */ |
| 393 | z80pio->enable[channel] = data & 0xf0; |
| 394 | |
| 395 | if (data & PIO_IRQ_MASK_FOLLOWS) |
| 235 | 396 | { |
| 236 | | z80pio->vector[offset] = data; |
| 237 | | VPRINTF(("PIO-%c vector %02x\n", 'A' + offset, data)); |
| 397 | /* disable interrupts until mask is written */ |
| 398 | z80pio_set_irq_enable(device, channel, 0); |
| 399 | |
| 400 | /* reset pending interrupt */ |
| 401 | z80pio->irq_pending[channel] = 0; |
| 402 | |
| 403 | /* set logic equation to false */ |
| 404 | z80pio->match[channel] = 0; |
| 405 | |
| 406 | /* next word is mask control */ |
| 407 | z80pio->state[channel] = PIO_STATE_MASK; |
| 238 | 408 | } |
| 239 | 409 | else |
| 240 | | VPRINTF(("PIO-%c illegal command %02x\n", 'A' + offset, data)); |
| 241 | | break; |
| 242 | | } |
| 410 | { |
| 411 | /* set interrupt enable */ |
| 412 | z80pio_set_irq_enable(device, channel, BIT(data, 7)); |
| 413 | } |
| 414 | } |
| 415 | break; |
| 243 | 416 | |
| 244 | | /* interrupt check */ |
| 245 | | update_irq_state(device, offset); |
| 246 | | } |
| 417 | case PIO_STATE_DDR: |
| 418 | LOGERROR("Z80PIO \"%s\" Port %c : I/O Control Word '%02x'\n", device->tag, 'A' + channel, data); |
| 247 | 419 | |
| 420 | /* set data direction */ |
| 421 | z80pio->ddr[channel] = data; |
| 248 | 422 | |
| 249 | | READ8_DEVICE_HANDLER( z80pio_c_r ) |
| 250 | | { |
| 251 | | /* There are only 2 channels */ |
| 252 | | offset &= 0x01; |
| 423 | /* set interrupt enable */ |
| 424 | z80pio_set_irq_enable(device, channel, BIT(z80pio->enable[channel], 7)); |
| 253 | 425 | |
| 254 | | VPRINTF(("PIO-%c controll read\n", 'A' + offset )); |
| 255 | | return 0; |
| 256 | | } |
| 426 | /* next word is indeterminate */ |
| 427 | z80pio->state[channel] = PIO_STATE_NORMAL; |
| 428 | break; |
| 257 | 429 | |
| 430 | case PIO_STATE_MASK: |
| 431 | LOGERROR("Z80PIO \"%s\" Port %c : Mask Control Word '%02x'\n", device->tag, 'A' + channel, data); |
| 258 | 432 | |
| 433 | /* set interrupt mask */ |
| 434 | z80pio->mask[channel] = data; |
| 259 | 435 | |
| 436 | /* set interrupt enable */ |
| 437 | z80pio_set_irq_enable(device, channel, BIT(z80pio->enable[channel], 7)); |
| 438 | |
| 439 | /* next word is indeterminate */ |
| 440 | z80pio->state[channel] = PIO_STATE_NORMAL; |
| 441 | break; |
| 442 | } |
| 443 | } |
| 444 | |
| 260 | 445 | /*************************************************************************** |
| 261 | 446 | DATA REGISTER READ/WRITE |
| 262 | 447 | ***************************************************************************/ |
| 263 | 448 | |
| 264 | | WRITE8_DEVICE_HANDLER( z80pio_d_w ) |
| 449 | READ8_DEVICE_HANDLER( z80pio_d_r ) |
| 265 | 450 | { |
| 266 | 451 | z80pio_t *z80pio = get_safe_token( device ); |
| 452 | int channel = offset & 0x01; |
| 453 | UINT8 data = 0; |
| 267 | 454 | |
| 268 | | /* There are only 2 channels */ |
| 269 | | offset &= 0x01; |
| 455 | switch (z80pio->mode[channel]) |
| 456 | { |
| 457 | case PIO_MODE_OUTPUT: |
| 458 | data = z80pio->output[channel]; |
| 459 | break; |
| 270 | 460 | |
| 271 | | z80pio->out[offset] = data; /* latch out data */ |
| 272 | | if(z80pio->port_write[offset]) |
| 273 | | z80pio->port_write[offset](device, 0, data); |
| 461 | case PIO_MODE_INPUT: |
| 462 | data = z80pio->input[channel]; |
| 274 | 463 | |
| 275 | | switch (z80pio->mode[offset]) |
| 276 | | { |
| 277 | | case PIO_MODE0: /* mode 0 output */ |
| 278 | | case PIO_MODE2: /* mode 2 i/o */ |
| 279 | | set_rdy(device, offset, 1); /* ready = H */ |
| 280 | | update_irq_state(device, offset); |
| 281 | | return; |
| 464 | /* clear ready line */ |
| 465 | z80pio_ready_w(device, channel, 0); |
| 282 | 466 | |
| 283 | | case PIO_MODE1: /* mode 1 input */ |
| 284 | | case PIO_MODE3: /* mode 0 bit */ |
| 285 | | return; |
| 467 | /* assert ready line */ |
| 468 | z80pio_ready_w(device, channel, 1); |
| 469 | break; |
| 286 | 470 | |
| 287 | | default: |
| 288 | | VPRINTF(("PIO-%c data write,bad mode\n",'A'+offset )); |
| 471 | case PIO_MODE_BIDIRECTIONAL: |
| 472 | data = z80pio->input[PIO_PORT_A] | (z80pio->output[PIO_PORT_A] & (~z80pio->ddr[PIO_PORT_A])); |
| 473 | |
| 474 | /* clear ready line */ |
| 475 | z80pio_ready_w(device, 1, 0); |
| 476 | |
| 477 | /* assert ready line */ |
| 478 | z80pio_ready_w(device, 1, 1); |
| 479 | break; |
| 480 | |
| 481 | case PIO_MODE_CONTROL: |
| 482 | z80pio->input[channel] = z80pio_port_r(device, channel); |
| 483 | |
| 484 | data = (z80pio->input[channel] & z80pio->ddr[channel]) | (z80pio->output[channel] & (~z80pio->ddr[channel])); |
| 485 | break; |
| 289 | 486 | } |
| 487 | |
| 488 | LOGERROR("Z80PIO \"%s\" Port %c : Data Register Read '%02x'\n", device->tag, 'A' + channel, data); |
| 489 | |
| 490 | return data; |
| 290 | 491 | } |
| 291 | 492 | |
| 292 | | |
| 293 | | READ8_DEVICE_HANDLER( z80pio_d_r ) |
| 493 | WRITE8_DEVICE_HANDLER( z80pio_d_w ) |
| 294 | 494 | { |
| 295 | 495 | z80pio_t *z80pio = get_safe_token( device ); |
| 496 | int channel = offset & 0x01; |
| 296 | 497 | |
| 297 | | /* There are only 2 channels */ |
| 298 | | offset &= 0x01; |
| 498 | LOGERROR("Z80PIO \"%s\" Port %c : Data Register Write '%02x'\n", device->tag, 'A' + channel, data); |
| 299 | 499 | |
| 300 | | switch (z80pio->mode[offset]) |
| 500 | switch (z80pio->mode[channel]) |
| 301 | 501 | { |
| 302 | | case PIO_MODE0: /* mode 0 output */ |
| 303 | | return z80pio->out[offset]; |
| 502 | case PIO_MODE_OUTPUT: |
| 503 | /* clear ready line */ |
| 504 | z80pio_ready_w(device, channel, 0); |
| 304 | 505 | |
| 305 | | case PIO_MODE1: /* mode 1 input */ |
| 306 | | set_rdy(device, offset, 1); /* ready = H */ |
| 307 | | if(z80pio->port_read[offset]) |
| 308 | | z80pio->in[offset] = z80pio->port_read[offset](device, 0); |
| 309 | | update_irq_state(device, offset); |
| 310 | | return z80pio->in[offset]; |
| 506 | /* output data */ |
| 507 | z80pio->output[channel] = data; |
| 508 | z80pio_port_w(device, channel); |
| 311 | 509 | |
| 312 | | case PIO_MODE2: /* mode 2 i/o */ |
| 313 | | if (offset) VPRINTF(("PIO-B mode 2 \n")); |
| 314 | | set_rdy(device, 1, 1); /* brdy = H */ |
| 315 | | if(z80pio->port_read[offset]) |
| 316 | | z80pio->in[offset] = z80pio->port_read[offset](device, 0); |
| 317 | | update_irq_state(device, offset); |
| 318 | | return z80pio->in[offset]; |
| 510 | /* assert ready line */ |
| 511 | z80pio_ready_w(device, channel, 1); |
| 512 | break; |
| 319 | 513 | |
| 320 | | case PIO_MODE3: /* mode 3 bit */ |
| 321 | | if(z80pio->port_read[offset]) |
| 322 | | z80pio->in[offset] = z80pio->port_read[offset](device, 0); |
| 323 | | return (z80pio->in[offset] & z80pio->dir[offset]) | (z80pio->out[offset] & ~z80pio->dir[offset]); |
| 514 | case PIO_MODE_INPUT: |
| 515 | /* do nothing */ |
| 516 | break; |
| 517 | |
| 518 | case PIO_MODE_BIDIRECTIONAL: |
| 519 | /* clear ready line */ |
| 520 | z80pio_ready_w(device, channel, 0); |
| 521 | |
| 522 | /* latch output data */ |
| 523 | z80pio->output[channel] = data; |
| 524 | |
| 525 | if (!z80pio->strobe[channel]) |
| 526 | { |
| 527 | /* output data if ASTB active */ |
| 528 | z80pio_port_w(device, channel); |
| 529 | } |
| 530 | |
| 531 | /* assert ready line */ |
| 532 | z80pio_ready_w(device, channel, 1); |
| 533 | break; |
| 534 | |
| 535 | case PIO_MODE_CONTROL: |
| 536 | /* output data */ |
| 537 | z80pio->output[channel] = data; |
| 538 | z80pio_port_w(device, channel); |
| 539 | break; |
| 324 | 540 | } |
| 325 | | VPRINTF(("PIO-%c data read,bad mode\n",'A'+offset )); |
| 326 | | return 0; |
| 327 | 541 | } |
| 328 | 542 | |
| 329 | | |
| 330 | | |
| 331 | 543 | /*************************************************************************** |
| 332 | | PORT I/O |
| 544 | STROBE STATE MANAGEMENT |
| 333 | 545 | ***************************************************************************/ |
| 334 | 546 | |
| 335 | | WRITE8_DEVICE_HANDLER( z80pio_p_w ) |
| 547 | static TIMER_CALLBACK( z80pio_poll_tick ) |
| 336 | 548 | { |
| 337 | | z80pio_t *z80pio = get_safe_token( device ); |
| 549 | const device_config *device = (device_config *) ptr; |
| 550 | z80pio_t *z80pio = get_safe_token(device); |
| 551 | int channel; |
| 338 | 552 | |
| 339 | | /* There are only 2 channels */ |
| 340 | | offset &= 0x01; |
| 341 | | |
| 342 | | z80pio->in[offset] = data; |
| 343 | | switch (z80pio->mode[offset]) |
| 553 | for (channel = PIO_PORT_A; channel < PIO_PORT_COUNT; channel++) |
| 344 | 554 | { |
| 345 | | case PIO_MODE0: |
| 346 | | VPRINTF(("PIO-%c OUTPUT mode and data write\n",'A'+offset )); |
| 347 | | break; |
| 555 | if ((z80pio->mode[channel] == PIO_MODE_CONTROL) && (z80pio->mask[channel] != 0xff)) |
| 556 | { |
| 557 | int bit; |
| 558 | int match = 0; |
| 348 | 559 | |
| 349 | | case PIO_MODE2: /* only port A */ |
| 350 | | offset = 1; /* handshake and IRQ is use portB */ |
| 560 | int edge = (z80pio->enable[channel] & PIO_IRQ_ACTIVE_HIGH) ? 1 : 0; |
| 351 | 561 | |
| 352 | | case PIO_MODE1: |
| 353 | | set_rdy(device, offset, 0); |
| 354 | | update_irq_state(device, offset); |
| 355 | | break; |
| 562 | UINT8 mask = z80pio->mask[channel]; |
| 563 | UINT8 ddr = z80pio->ddr[channel]; |
| 564 | UINT8 old_data = z80pio->input[channel] & ddr; |
| 565 | UINT8 data = z80pio_port_r(device, channel) & ddr; |
| 356 | 566 | |
| 357 | | case PIO_MODE3: |
| 358 | | /* irq check */ |
| 359 | | update_irq_state(device, offset); |
| 360 | | break; |
| 361 | | } |
| 362 | | } |
| 567 | if (old_data == data) continue; |
| 363 | 568 | |
| 569 | for (bit = 0; bit < 8; bit++) |
| 570 | { |
| 571 | if (BIT(mask, bit)) continue; /* masked out */ |
| 572 | if (!BIT(ddr, bit)) continue; /* output bit */ |
| 364 | 573 | |
| 365 | | READ8_DEVICE_HANDLER( z80pio_p_r ) |
| 366 | | { |
| 367 | | z80pio_t *z80pio = get_safe_token( device ); |
| 574 | if ((BIT(old_data, bit) ^ edge) && !(BIT(data, bit) ^ edge)) /* falling edge */ |
| 575 | { |
| 576 | /* logic equation is true, until proven otherwise */ |
| 577 | match = 1; |
| 368 | 578 | |
| 369 | | /* There are only 2 channels */ |
| 370 | | offset &= 0x01; |
| 579 | LOGERROR("Z80PIO \"%s\" Port %c : Edge Transition detected on bit %u, data %02x %02x\n", device->tag, 'A' + channel, bit, old_data, data); |
| 580 | } |
| 581 | else if (z80pio->enable[channel] & PIO_IRQ_AND) |
| 582 | { |
| 583 | /* all bits must match in AND mode, so logic equation is false */ |
| 584 | match = 0; |
| 585 | break; |
| 586 | } |
| 587 | } |
| 371 | 588 | |
| 372 | | switch (z80pio->mode[offset]) |
| 373 | | { |
| 374 | | case PIO_MODE2: /* port A only */ |
| 375 | | case PIO_MODE0: |
| 376 | | set_rdy(device, offset, 0); |
| 377 | | update_irq_state(device, offset); |
| 378 | | break; |
| 589 | if (!z80pio->match[channel] && match) /* rising edge */ |
| 590 | { |
| 591 | /* trigger interrupt only once */ |
| 592 | z80pio_trigger_interrupt(device, channel); |
| 593 | z80pio->input[channel] = data; |
| 594 | } |
| 379 | 595 | |
| 380 | | case PIO_MODE1: |
| 381 | | VPRINTF(("PIO-%c INPUT mode and data read\n",'A'+offset )); |
| 382 | | break; |
| 383 | | |
| 384 | | case PIO_MODE3: |
| 385 | | return (z80pio->in[offset] & z80pio->dir[offset]) | (z80pio->out[offset] & ~z80pio->dir[offset]); |
| 596 | z80pio->match[channel] = match; |
| 597 | } |
| 386 | 598 | } |
| 387 | | return z80pio->out[offset]; |
| 388 | 599 | } |
| 389 | 600 | |
| 390 | | |
| 391 | 601 | /*************************************************************************** |
| 392 | 602 | STROBE STATE MANAGEMENT |
| 393 | 603 | ***************************************************************************/ |
| 394 | 604 | |
| 395 | | static void z80pio_update_strobe(const device_config *device, int ch, int state) |
| 605 | static void z80pio_strobe_bidirectional(const device_config *device, int channel, int state) |
| 396 | 606 | { |
| 397 | | z80pio_t *z80pio = get_safe_token( device ); |
| 607 | z80pio_t *z80pio = get_safe_token(device); |
| 398 | 608 | |
| 399 | | switch (z80pio->mode[ch]) |
| 609 | switch (channel) |
| 400 | 610 | { |
| 401 | | /* output mode: a positive edge is used by peripheral to acknowledge |
| 402 | | the receipt of data */ |
| 403 | | case PIO_MODE0: |
| 611 | case PIO_PORT_A: |
| 612 | if (!state) /* low level */ |
| 404 | 613 | { |
| 405 | | /* ensure valid */ |
| 406 | | state = state & 0x01; |
| 614 | /* output data */ |
| 615 | z80pio_port_w(device, PIO_PORT_A); |
| 616 | } |
| 617 | else if (!z80pio->strobe[channel] && state) /* rising edge */ |
| 618 | { |
| 619 | /* trigger interrupt */ |
| 620 | z80pio_trigger_interrupt(device, channel); |
| 407 | 621 | |
| 408 | | /* strobe changed state? */ |
| 409 | | if ((z80pio->strobe[ch] ^ state) != 0) |
| 410 | | { |
| 411 | | /* yes */ |
| 412 | | if (state != 0) |
| 413 | | { |
| 414 | | /* positive edge */ |
| 415 | | VPRINTF(("PIO-%c positive strobe\n",'A' + ch)); |
| 622 | /* clear ready line */ |
| 623 | z80pio_ready_w(device, channel, 0); |
| 624 | } |
| 625 | break; |
| 416 | 626 | |
| 417 | | /* ready is now inactive */ |
| 418 | | set_rdy(device, ch, 0); |
| 627 | case PIO_PORT_B: |
| 628 | if (!state) /* low level */ |
| 629 | { |
| 630 | /* input data */ |
| 631 | z80pio->input[channel] = z80pio_port_r(device, PIO_PORT_A); |
| 632 | } |
| 633 | else if (!z80pio->strobe[channel] && state) /* rising edge */ |
| 634 | { |
| 635 | /* trigger interrupt */ |
| 636 | z80pio_trigger_interrupt(device, channel); |
| 419 | 637 | |
| 420 | | /* int enabled? */ |
| 421 | | if (z80pio->enable[ch] & PIO_INT_ENABLE) |
| 422 | | { |
| 423 | | /* trigger an int request */ |
| 424 | | z80pio->int_state[ch] |= Z80_DAISY_INT; |
| 425 | | } |
| 426 | | } |
| 427 | | } |
| 638 | /* clear ready line */ |
| 639 | z80pio_ready_w(device, channel, 0); |
| 640 | } |
| 641 | break; |
| 642 | } |
| 428 | 643 | |
| 429 | | /* store strobe state */ |
| 430 | | z80pio->strobe[ch] = state; |
| 644 | /* latch strobe state */ |
| 645 | z80pio->strobe[channel] = state; |
| 646 | } |
| 431 | 647 | |
| 432 | | /* check interrupt */ |
| 433 | | interrupt_check(device); |
| 648 | static void z80pio_strobe(const device_config *device, int channel, int state) |
| 649 | { |
| 650 | z80pio_t *z80pio = get_safe_token(device); |
| 651 | |
| 652 | switch (z80pio->mode[channel]) |
| 653 | { |
| 654 | case PIO_MODE_OUTPUT: |
| 655 | if (!z80pio->strobe[channel] && state) /* rising edge */ |
| 656 | { |
| 657 | /* trigger interrupt */ |
| 658 | z80pio_trigger_interrupt(device, channel); |
| 659 | |
| 660 | /* clear ready line */ |
| 661 | z80pio_ready_w(device, channel, 0); |
| 434 | 662 | } |
| 435 | 663 | break; |
| 436 | 664 | |
| 437 | | /* input mode: strobe is used by peripheral to load data from the peripheral |
| 438 | | into port a input register, data loaded into pio when signal is active */ |
| 665 | case PIO_MODE_INPUT: |
| 666 | if (!state) /* low level */ |
| 667 | { |
| 668 | /* strobe data in */ |
| 669 | z80pio->input[channel] = z80pio_port_r(device, channel); |
| 670 | } |
| 671 | else if (!z80pio->strobe[channel] && state) /* rising edge */ |
| 672 | { |
| 673 | /* trigger interrupt */ |
| 674 | z80pio_trigger_interrupt(device, channel); |
| 439 | 675 | |
| 440 | | default: |
| 441 | | break; |
| 676 | /* clear ready line */ |
| 677 | z80pio_ready_w(device, channel, 0); |
| 678 | } |
| 679 | break; |
| 680 | |
| 681 | case PIO_MODE_CONTROL: |
| 682 | /* ignore strobes */ |
| 683 | break; |
| 442 | 684 | } |
| 685 | |
| 686 | /* latch strobe state */ |
| 687 | z80pio->strobe[channel] = state; |
| 443 | 688 | } |
| 444 | 689 | |
| 690 | static void z80pio_strobe_w(const device_config *device, int channel, int state) |
| 691 | { |
| 692 | z80pio_t *z80pio = get_safe_token(device); |
| 445 | 693 | |
| 446 | | void z80pio_astb_w(const device_config *device, int state) { z80pio_update_strobe(device, 0, state); } |
| 447 | | void z80pio_bstb_w(const device_config *device, int state) { z80pio_update_strobe(device, 1, state); } |
| 694 | LOGERROR("Z80PIO \"%s\" Port %c : Strobe %u\n", device->tag, 'A' + channel, state); |
| 448 | 695 | |
| 696 | if (z80pio->mode[PIO_PORT_A] == PIO_MODE_BIDIRECTIONAL) |
| 697 | { |
| 698 | /* port A bidirectional mode */ |
| 699 | z80pio_strobe_bidirectional(device, channel, state); |
| 700 | } |
| 701 | else |
| 702 | { |
| 703 | z80pio_strobe(device, channel, state); |
| 704 | } |
| 705 | } |
| 449 | 706 | |
| 707 | void z80pio_astb_w(const device_config *device, int state) |
| 708 | { |
| 709 | z80pio_strobe_w(device, PIO_PORT_A, state); |
| 710 | } |
| 450 | 711 | |
| 712 | void z80pio_bstb_w(const device_config *device, int state) |
| 713 | { |
| 714 | z80pio_strobe_w(device, PIO_PORT_B, state); |
| 715 | } |
| 716 | |
| 451 | 717 | /*************************************************************************** |
| 452 | 718 | DAISY CHAIN INTERFACE |
| 453 | 719 | ***************************************************************************/ |
| r3596 | r3597 | |
| 456 | 722 | { |
| 457 | 723 | z80pio_t *z80pio = get_safe_token( device ); |
| 458 | 724 | int state = 0; |
| 459 | | int ch; |
| 725 | int channel; |
| 460 | 726 | |
| 461 | 727 | /* loop over all channels */ |
| 462 | | for (ch = 0; ch < 2; ch++) |
| 728 | for (channel = PIO_PORT_A; channel < PIO_PORT_COUNT; channel++) |
| 463 | 729 | { |
| 464 | 730 | /* if we're servicing a request, don't indicate more interrupts */ |
| 465 | | if (z80pio->int_state[ch] & Z80_DAISY_IEO) |
| 731 | if (z80pio->int_state[channel] & Z80_DAISY_IEO) |
| 466 | 732 | { |
| 467 | 733 | state |= Z80_DAISY_IEO; |
| 468 | 734 | break; |
| 469 | 735 | } |
| 470 | | state |= z80pio->int_state[ch]; |
| 736 | |
| 737 | state |= z80pio->int_state[channel]; |
| 471 | 738 | } |
| 739 | |
| 740 | LOGERROR("Z80PIO \"%s\" : Interrupt State %u\n", device->tag, state); |
| 741 | |
| 472 | 742 | return state; |
| 473 | 743 | } |
| 474 | 744 | |
| 475 | | |
| 476 | 745 | static int z80pio_irq_ack(const device_config *device) |
| 477 | 746 | { |
| 478 | 747 | z80pio_t *z80pio = get_safe_token( device ); |
| 479 | | int ch; |
| 748 | int channel; |
| 480 | 749 | |
| 750 | LOGERROR("Z80PIO \"%s\" Interrupt Acknowledge\n", device->tag); |
| 751 | |
| 481 | 752 | /* loop over all channels */ |
| 482 | | for (ch = 0; ch < 2; ch++) |
| 483 | | |
| 753 | for (channel = PIO_PORT_A; channel < PIO_PORT_COUNT; channel++) |
| 754 | { |
| 484 | 755 | /* find the first channel with an interrupt requested */ |
| 485 | | if (z80pio->int_state[ch] & Z80_DAISY_INT) |
| 756 | if (z80pio->int_state[channel] & Z80_DAISY_INT) |
| 486 | 757 | { |
| 487 | 758 | /* clear interrupt, switch to the IEO state, and update the IRQs */ |
| 488 | | z80pio->int_state[ch] = Z80_DAISY_IEO; |
| 489 | | interrupt_check(device); |
| 490 | | return z80pio->vector[ch]; |
| 759 | z80pio->int_state[channel] = Z80_DAISY_IEO; |
| 760 | z80pio_check_interrupt(device); |
| 761 | |
| 762 | return z80pio->vector[channel]; |
| 491 | 763 | } |
| 764 | } |
| 492 | 765 | |
| 493 | | VPRINTF(("z80pio_irq_ack: failed to find an interrupt to ack!")); |
| 766 | LOGERROR("z80pio_irq_ack: failed to find an interrupt to ack!"); |
| 767 | |
| 494 | 768 | return z80pio->vector[0]; |
| 495 | 769 | } |
| 496 | 770 | |
| 497 | | |
| 498 | 771 | static void z80pio_irq_reti(const device_config *device) |
| 499 | 772 | { |
| 500 | 773 | z80pio_t *z80pio = get_safe_token( device ); |
| 501 | | int ch; |
| 774 | int channel; |
| 502 | 775 | |
| 776 | LOGERROR("Z80PIO \"%s\" Return from Interrupt\n", device->tag); |
| 777 | |
| 503 | 778 | /* loop over all channels */ |
| 504 | | for (ch = 0; ch < 2; ch++) |
| 505 | | |
| 779 | for (channel = PIO_PORT_A; channel < PIO_PORT_COUNT; channel++) |
| 780 | { |
| 506 | 781 | /* find the first channel with an IEO pending */ |
| 507 | | if (z80pio->int_state[ch] & Z80_DAISY_IEO) |
| 782 | if (z80pio->int_state[channel] & Z80_DAISY_IEO) |
| 508 | 783 | { |
| 509 | 784 | /* clear the IEO state and update the IRQs */ |
| 510 | | z80pio->int_state[ch] &= ~Z80_DAISY_IEO; |
| 511 | | interrupt_check(device); |
| 785 | z80pio->int_state[channel] &= ~Z80_DAISY_IEO; |
| 786 | z80pio_check_interrupt(device); |
| 787 | |
| 512 | 788 | return; |
| 513 | 789 | } |
| 790 | } |
| 514 | 791 | |
| 515 | | VPRINTF(("z80pio_irq_reti: failed to find an interrupt to clear IEO on!")); |
| 792 | LOGERROR("z80pio_irq_reti: failed to find an interrupt to clear IEO on!"); |
| 516 | 793 | } |
| 517 | 794 | |
| 518 | | |
| 519 | 795 | /*************************************************************************** |
| 520 | 796 | READ/WRITE HANDLERS |
| 521 | 797 | ***************************************************************************/ |
| 798 | |
| 522 | 799 | READ8_DEVICE_HANDLER(z80pio_r) |
| 523 | 800 | { |
| 524 | 801 | return (offset & 2) ? z80pio_c_r(device, offset & 1) : z80pio_d_r(device, offset & 1); |
| r3596 | r3597 | |
| 532 | 809 | z80pio_d_w(device, offset & 1, data); |
| 533 | 810 | } |
| 534 | 811 | |
| 812 | READ8_DEVICE_HANDLER(z80pio_alt_r) |
| 813 | { |
| 814 | int channel = BIT(offset, 1); |
| 535 | 815 | |
| 816 | return (offset & 1) ? z80pio_c_r(device, channel) : z80pio_d_r(device, channel); |
| 817 | } |
| 818 | |
| 819 | WRITE8_DEVICE_HANDLER(z80pio_alt_w) |
| 820 | { |
| 821 | int channel = BIT(offset, 1); |
| 822 | |
| 823 | if (offset & 1) |
| 824 | z80pio_c_w(device, channel, data); |
| 825 | else |
| 826 | z80pio_d_w(device, channel, data); |
| 827 | } |
| 828 | |
| 829 | /*************************************************************************** |
| 830 | DEVICE INTERFACE |
| 831 | ***************************************************************************/ |
| 832 | |
| 536 | 833 | static DEVICE_START( z80pio ) |
| 537 | 834 | { |
| 538 | 835 | const z80pio_interface *intf = device->static_config; |
| 539 | 836 | z80pio_t *z80pio = get_safe_token( device ); |
| 837 | int cpunum = -1; |
| 540 | 838 | |
| 541 | | z80pio->intr = intf->intr; |
| 542 | | z80pio->port_read[0] = intf->portAread; |
| 543 | | z80pio->port_read[1] = intf->portBread; |
| 544 | | z80pio->port_write[0] = intf->portAwrite; |
| 545 | | z80pio->port_write[1] = intf->portBwrite; |
| 546 | | z80pio->rdyr[0] = intf->rdyA; |
| 547 | | z80pio->rdyr[1] = intf->rdyB; |
| 839 | assert(intf != NULL); |
| 840 | z80pio->intf = intf; |
| 548 | 841 | |
| 549 | | /* register for save states */ |
| 550 | | state_save_register_item_array("z80pio", device->tag, 0, z80pio->vector); |
| 842 | /* get clock */ |
| 843 | |
| 844 | if (intf->cpu != NULL) |
| 845 | { |
| 846 | cpunum = mame_find_cpu_index(device->machine, intf->cpu); |
| 847 | } |
| 848 | |
| 849 | if (cpunum != -1) |
| 850 | { |
| 851 | z80pio->clock = device->machine->config->cpu[cpunum].clock; |
| 852 | } |
| 853 | else |
| 854 | { |
| 855 | assert(intf->clock > 0); |
| 856 | z80pio->clock = intf->clock; |
| 857 | } |
| 858 | |
| 859 | /* allocate poll timer */ |
| 860 | |
| 861 | z80pio->poll_timer = timer_alloc(z80pio_poll_tick, (void *)device); |
| 862 | timer_adjust_periodic(z80pio->poll_timer, attotime_zero, 0, ATTOTIME_IN_HZ(z80pio->clock / 16)); |
| 863 | |
| 864 | /* allocate interrupt enable timer */ |
| 865 | |
| 866 | z80pio->irq_timer = timer_alloc(z80pio_irq_tick, (void *)device); |
| 867 | |
| 868 | /* register for state saving */ |
| 869 | |
| 870 | state_save_register_item_array("z80pio", device->tag, 0, z80pio->state); |
| 551 | 871 | state_save_register_item_array("z80pio", device->tag, 0, z80pio->mode); |
| 872 | state_save_register_item_array("z80pio", device->tag, 0, z80pio->irq_enable); |
| 873 | state_save_register_item_array("z80pio", device->tag, 0, z80pio->irq_pending); |
| 874 | state_save_register_item_array("z80pio", device->tag, 0, z80pio->int_state); |
| 552 | 875 | state_save_register_item_array("z80pio", device->tag, 0, z80pio->enable); |
| 876 | state_save_register_item_array("z80pio", device->tag, 0, z80pio->input); |
| 877 | state_save_register_item_array("z80pio", device->tag, 0, z80pio->output); |
| 878 | state_save_register_item_array("z80pio", device->tag, 0, z80pio->vector); |
| 553 | 879 | state_save_register_item_array("z80pio", device->tag, 0, z80pio->mask); |
| 554 | | state_save_register_item_array("z80pio", device->tag, 0, z80pio->dir); |
| 555 | | state_save_register_item_array("z80pio", device->tag, 0, z80pio->rdy); |
| 556 | | state_save_register_item_array("z80pio", device->tag, 0, z80pio->in); |
| 557 | | state_save_register_item_array("z80pio", device->tag, 0, z80pio->out); |
| 880 | state_save_register_item_array("z80pio", device->tag, 0, z80pio->ddr); |
| 558 | 881 | state_save_register_item_array("z80pio", device->tag, 0, z80pio->strobe); |
| 559 | | state_save_register_item_array("z80pio", device->tag, 0, z80pio->int_state); |
| 882 | state_save_register_item_array("z80pio", device->tag, 0, z80pio->match); |
| 560 | 883 | |
| 561 | 884 | return DEVICE_START_OK; |
| 562 | 885 | } |
| 563 | 886 | |
| 564 | | |
| 565 | 887 | static DEVICE_RESET( z80pio ) |
| 566 | 888 | { |
| 567 | | z80pio_t *z80pio = get_safe_token( device ); |
| 568 | | int i; |
| 889 | z80pio_t *z80pio = get_safe_token(device); |
| 890 | int channel; |
| 569 | 891 | |
| 570 | | for (i = 0; i < 2; i++) |
| 892 | LOGERROR("Z80PIO \"%s\" : Reset\n", device->tag); |
| 893 | |
| 894 | for (channel = 0; channel < 2; channel++) |
| 571 | 895 | { |
| 572 | | z80pio->mask[i] = 0xff; /* mask all on */ |
| 573 | | z80pio->enable[i] = 0x00; /* disable */ |
| 574 | | z80pio->mode[i] = 0x01; /* mode input */ |
| 575 | | z80pio->dir[i] = 0x01; /* dir input */ |
| 576 | | set_rdy(device, i, 0); /* RDY = low */ |
| 577 | | z80pio->out[i] = 0x00; /* outdata = 0 */ |
| 578 | | z80pio->int_state[i] = 0; |
| 579 | | z80pio->strobe[i] = 0; |
| 896 | /* set mode 1 */ |
| 897 | z80pio->mode[channel] = PIO_MODE_INPUT; |
| 898 | |
| 899 | /* disable interrupt */ |
| 900 | z80pio->enable[channel] &= 0x7f; |
| 901 | z80pio->irq_enable[channel] = 0; |
| 902 | z80pio->irq_pending[channel] = 0; |
| 903 | z80pio->int_state[channel] = 0; |
| 904 | z80pio->match[channel] = 0; |
| 905 | |
| 906 | /* reset all bits of the data I/O register */ |
| 907 | z80pio->ddr[channel] = 0; |
| 908 | |
| 909 | /* set all bits of the mask control register */ |
| 910 | z80pio->mask[channel] = 0xff; |
| 911 | |
| 912 | /* reset output register */ |
| 913 | z80pio->output[channel] = 0; |
| 914 | |
| 915 | /* clear ready line */ |
| 916 | z80pio_ready_w(device, channel, 0); |
| 580 | 917 | } |
| 581 | | interrupt_check(device); |
| 918 | |
| 919 | z80pio_check_interrupt(device); |
| 582 | 920 | } |
| 583 | 921 | |
| 584 | | |
| 585 | 922 | static DEVICE_SET_INFO( z80pio ) |
| 586 | 923 | { |
| 587 | 924 | switch (state) |
| r3596 | r3597 | |
| 590 | 927 | } |
| 591 | 928 | } |
| 592 | 929 | |
| 593 | | |
| 594 | 930 | DEVICE_GET_INFO( z80pio ) |
| 595 | 931 | { |
| 596 | 932 | switch (state) |
| r3596 | r3597 | |
| 618 | 954 | } |
| 619 | 955 | } |
| 620 | 956 | |
| 957 | DEVICE_GET_INFO( z8420 ) |
| 958 | { |
| 959 | switch (state) |
| 960 | { |
| 961 | /* --- the following bits of info are returned as NULL-terminated strings --- */ |
| 962 | case DEVINFO_STR_NAME: info->s = "Zilog Z8420"; break; |
| 963 | case DEVINFO_STR_FAMILY: info->s = "Z80 PIO"; break; |
| 964 | |
| 965 | default: DEVICE_GET_INFO_CALL(z80pio); |
| 966 | } |
| 967 | } |
| 968 | |
| 969 | DEVICE_GET_INFO( lh0081 ) |
| 970 | { |
| 971 | switch (state) |
| 972 | { |
| 973 | /* --- the following bits of info are returned as NULL-terminated strings --- */ |
| 974 | case DEVINFO_STR_NAME: info->s = "Sharp LH0081"; break; |
| 975 | case DEVINFO_STR_FAMILY: info->s = "Z80 PIO"; break; |
| 976 | |
| 977 | default: DEVICE_GET_INFO_CALL(z80pio); |
| 978 | } |
| 979 | } |
| 980 | |
| 981 | DEVICE_GET_INFO( mk3881 ) |
| 982 | { |
| 983 | switch (state) |
| 984 | { |
| 985 | /* --- the following bits of info are returned as NULL-terminated strings --- */ |
| 986 | case DEVINFO_STR_NAME: info->s = "Mostek MK3881"; break; |
| 987 | case DEVINFO_STR_FAMILY: info->s = "Z80 PIO"; break; |
| 988 | |
| 989 | default: DEVICE_GET_INFO_CALL(z80pio); |
| 990 | } |
| 991 | } |
src/mess/machine/conkort.c
| r3596 | r3597 | |
| 71 | 71 | |
| 72 | 72 | Common
|
| 73 | 73 | ------
|
| 74 | | - remove cpunum references
|
| 75 | 74 | - separate wd17xx reset from init
|
| 76 | 75 | |
| 77 | 76 | Slow Controller
|
| r3596 | r3597 | |
| 85 | 84 | Fast Controller
|
| 86 | 85 | ---------------
|
| 87 | 86 | - Z80 DMA interrupt
|
| 88 | | - Z80 DMA memory <-> IO transfer
|
| 89 | 87 | - FDC INT
|
| 90 | 88 | - FDC DRQ
|
| 91 | 89 | |
| r3596 | r3597 | |
| 103 | 101 | typedef struct _slow_t slow_t;
|
| 104 | 102 | struct _slow_t
|
| 105 | 103 | {
|
| 106 | | int cpunum; /* CPU index of the Z80 */
|
| 104 | int cpunum; /* CPU index of the Z80 */
|
| 107 | 105 | |
| 108 | | UINT8 status;
|
| 109 | | UINT8 data;
|
| 110 | | int pio_ardy;
|
| 111 | | int fdc_irq;
|
| 106 | UINT8 status; /* ABC BUS status */
|
| 107 | UINT8 data; /* ABC BUS data */
|
| 108 | int pio_ardy; /* PIO port A ready */
|
| 109 | int fdc_irq; /* FDC interrupt */
|
| 112 | 110 | |
| 111 | /* devices */
|
| 113 | 112 | const device_config *z80pio;
|
| 114 | 113 | };
|
| 115 | 114 | |
| 116 | 115 | typedef struct _fast_t fast_t;
|
| 117 | 116 | struct _fast_t
|
| 118 | 117 | {
|
| 119 | | int cpunum; /* CPU index of the Z80 */
|
| 118 | int cpunum; /* CPU index of the Z80 */
|
| 120 | 119 | |
| 121 | | UINT8 status;
|
| 122 | | UINT8 data;
|
| 123 | | int fdc_irq;
|
| 120 | UINT8 status; /* ABC BUS status */
|
| 121 | UINT8 data; /* ABC BUS data */
|
| 122 | int fdc_irq; /* FDC interrupt */
|
| 124 | 123 | |
| 124 | /* devices */
|
| 125 | 125 | const device_config *z80dma;
|
| 126 | 126 | };
|
| 127 | 127 | |
| r3596 | r3597 | |
| 141 | 141 | return (fast_t *)device->token;
|
| 142 | 142 | }
|
| 143 | 143 | |
| 144 | INLINE slow_t *get_safe_token_machine_slow(running_machine *machine)
|
| 145 | {
|
| 146 | const device_config *device = devtag_get_device(machine, LUXOR_55_10828, CONKORT_TAG);
|
| 147 | return get_safe_token_slow(device);
|
| 148 | }
|
| 149 | |
| 150 | INLINE fast_t *get_safe_token_machine_fast(running_machine *machine)
|
| 151 | {
|
| 152 | const device_config *device = devtag_get_device(machine, LUXOR_55_21046, CONKORT_TAG);
|
| 153 | return get_safe_token_fast(device);
|
| 154 | }
|
| 155 | |
| 144 | 156 | static const device_config *get_floppy_image(int drive)
|
| 145 | 157 | {
|
| 146 | 158 | return image_from_devtype_and_index(IO_FLOPPY, drive);
|
| r3596 | r3597 | |
| 150 | 162 | |
| 151 | 163 | static READ8_HANDLER( slow_bus_data_r )
|
| 152 | 164 | {
|
| 153 | | const device_config *device = devtag_get_device(machine, LUXOR_55_10828, CONKORT_TAG);
|
| 154 | | const device_config *z80pio = devtag_get_device(device->machine, Z80PIO, CONKORT_Z80PIO_TAG);
|
| 165 | slow_t *conkort = get_safe_token_machine_slow(space->machine);
|
| 155 | 166 | |
| 156 | | slow_t *conkort = get_safe_token_slow(device);
|
| 157 | | |
| 158 | 167 | UINT8 data = 0xff;
|
| 159 | 168 | |
| 160 | | z80pio_astb_w(z80pio, 0);
|
| 169 | z80pio_astb_w(conkort->z80pio, 0);
|
| 161 | 170 | |
| 162 | 171 | if (!BIT(conkort->status, 6))
|
| 163 | 172 | {
|
| 164 | 173 | data = conkort->data;
|
| 165 | 174 | }
|
| 166 | 175 | |
| 167 | | z80pio_astb_w(z80pio, 1);
|
| 176 | z80pio_astb_w(conkort->z80pio, 1);
|
| 168 | 177 | |
| 169 | 178 | return data;
|
| 170 | 179 | }
|
| 171 | 180 | |
| 172 | 181 | static WRITE8_HANDLER( slow_bus_data_w )
|
| 173 | 182 | {
|
| 174 | | const device_config *device = devtag_get_device(machine, LUXOR_55_10828, CONKORT_TAG);
|
| 175 | | const device_config *z80pio = devtag_get_device(device->machine, Z80PIO, CONKORT_Z80PIO_TAG);
|
| 183 | slow_t *conkort = get_safe_token_machine_slow(space->machine);
|
| 176 | 184 | |
| 177 | | slow_t *conkort = get_safe_token_slow(device);
|
| 185 | z80pio_astb_w(conkort->z80pio, 0);
|
| 178 | 186 | |
| 179 | | z80pio_astb_w(z80pio, 0);
|
| 180 | | |
| 181 | 187 | if (BIT(conkort->status, 6))
|
| 182 | 188 | {
|
| 183 | 189 | conkort->data = data;
|
| 184 | 190 | }
|
| 185 | 191 | |
| 186 | | z80pio_astb_w(z80pio, 1);
|
| 192 | z80pio_astb_w(conkort->z80pio, 1);
|
| 187 | 193 | }
|
| 188 | 194 | |
| 189 | 195 | static READ8_HANDLER( slow_bus_stat_r )
|
| 190 | 196 | {
|
| 191 | | const device_config *device = devtag_get_device(machine, LUXOR_55_10828, CONKORT_TAG);
|
| 192 | | slow_t *conkort = get_safe_token_slow(device);
|
| 197 | slow_t *conkort = get_safe_token_machine_slow(space->machine);
|
| 193 | 198 | |
| 194 | | return (conkort->pio_ardy << 7) | conkort->status;
|
| 199 | return (conkort->status & 0xfe) | conkort->pio_ardy;
|
| 195 | 200 | }
|
| 196 | 201 | |
| 197 | 202 | static WRITE8_HANDLER( slow_bus_c1_w )
|
| 198 | 203 | {
|
| 199 | | const device_config *device = devtag_get_device(machine, LUXOR_55_10828, CONKORT_TAG);
|
| 200 | | slow_t *conkort = get_safe_token_slow(device);
|
| 204 | slow_t *conkort = get_safe_token_machine_slow(space->machine);
|
| 201 | 205 | |
| 202 | | cpunum_set_input_line(machine, conkort->cpunum, INPUT_LINE_NMI, PULSE_LINE);
|
| 206 | cpu_set_input_line(space->machine->cpu[conkort->cpunum], INPUT_LINE_NMI, PULSE_LINE);
|
| 203 | 207 | }
|
| 204 | 208 | |
| 205 | 209 | static WRITE8_HANDLER( slow_bus_c3_w )
|
| 206 | 210 | {
|
| 207 | | const device_config *device = devtag_get_device(machine, LUXOR_55_10828, CONKORT_TAG);
|
| 208 | | slow_t *conkort = get_safe_token_slow(device);
|
| 211 | slow_t *conkort = get_safe_token_machine_slow(space->machine);
|
| 209 | 212 | |
| 210 | | cpunum_set_input_line(machine, conkort->cpunum, INPUT_LINE_RESET, PULSE_LINE);
|
| 213 | cpu_set_input_line(space->machine->cpu[conkort->cpunum], INPUT_LINE_RESET, PULSE_LINE);
|
| 211 | 214 | }
|
| 212 | 215 | |
| 213 | | static void slow_card_select(const device_config *device, UINT8 data)
|
| 216 | static ABCBUS_CARD_SELECT( luxor_55_10828 )
|
| 214 | 217 | {
|
| 215 | 218 | slow_t *conkort = get_safe_token_slow(device);
|
| 216 | 219 | |
| 217 | 220 | if (data == 0x2d) // TODO: bit 0 of this is configurable with S1
|
| 218 | 221 | {
|
| 219 | | memory_install_readwrite8_handler(device->machine, 0, ADDRESS_SPACE_IO, ABCBUS_INP, ABCBUS_OUT, 0x18, 0, slow_bus_data_r, slow_bus_data_w);
|
| 220 | | memory_install_read8_handler(device->machine, 0, ADDRESS_SPACE_IO, ABCBUS_STAT, ABCBUS_STAT, 0x18, 0, slow_bus_stat_r);
|
| 221 | | memory_install_write8_handler(device->machine, 0, ADDRESS_SPACE_IO, ABCBUS_C1, ABCBUS_C1, 0x18, 0, slow_bus_c1_w);
|
| 222 | | memory_install_write8_handler(device->machine, 0, ADDRESS_SPACE_IO, ABCBUS_C2, ABCBUS_C2, 0x18, 0, SMH_NOP);
|
| 223 | | memory_install_write8_handler(device->machine, 0, ADDRESS_SPACE_IO, ABCBUS_C3, ABCBUS_C3, 0x18, 0, slow_bus_c3_w);
|
| 224 | | memory_install_write8_handler(device->machine, 0, ADDRESS_SPACE_IO, ABCBUS_C4, ABCBUS_C4, 0x18, 0, SMH_NOP);
|
| 222 | memory_install_readwrite8_handler(cpu_get_address_space(device->machine->cpu[0], ADDRESS_SPACE_IO), ABCBUS_INP, ABCBUS_OUT, 0x18, 0, slow_bus_data_r, slow_bus_data_w);
|
| 223 | memory_install_read8_handler(cpu_get_address_space(device->machine->cpu[0], ADDRESS_SPACE_IO), ABCBUS_STAT, ABCBUS_STAT, 0x18, 0, slow_bus_stat_r);
|
| 224 | memory_install_write8_handler(cpu_get_address_space(device->machine->cpu[0], ADDRESS_SPACE_IO), ABCBUS_C1, ABCBUS_C1, 0x18, 0, slow_bus_c1_w);
|
| 225 | memory_install_write8_handler(cpu_get_address_space(device->machine->cpu[0], ADDRESS_SPACE_IO), ABCBUS_C2, ABCBUS_C2, 0x18, 0, SMH_NOP);
|
| 226 | memory_install_write8_handler(cpu_get_address_space(device->machine->cpu[0], ADDRESS_SPACE_IO), ABCBUS_C3, ABCBUS_C3, 0x18, 0, slow_bus_c3_w);
|
| 227 | memory_install_write8_handler(cpu_get_address_space(device->machine->cpu[0], ADDRESS_SPACE_IO), ABCBUS_C4, ABCBUS_C4, 0x18, 0, SMH_NOP);
|
| 225 | 228 | }
|
| 226 | 229 | |
| 227 | | cpunum_set_input_line(device->machine, conkort->cpunum, INPUT_LINE_RESET, PULSE_LINE);
|
| 230 | cpu_set_input_line(device->machine->cpu[conkort->cpunum], INPUT_LINE_RESET, PULSE_LINE);
|
| 228 | 231 | }
|
| 229 | 232 | |
| 230 | 233 | static WRITE8_HANDLER( slow_ctrl_w )
|
| r3596 | r3597 | |
| 261 | 264 | if (!BIT(data, 7))
|
| 262 | 265 | {
|
| 263 | 266 | /* FDC master reset */
|
| 264 | | wd17xx_reset(machine);
|
| 267 | wd17xx_reset(space->machine);
|
| 265 | 268 | }
|
| 266 | 269 | }
|
| 267 | 270 | |
| 268 | 271 | static WRITE8_HANDLER( slow_status_w )
|
| 269 | 272 | {
|
| 270 | | const device_config *device = devtag_get_device(machine, LUXOR_55_10828, CONKORT_TAG);
|
| 271 | | slow_t *conkort = get_safe_token_slow(device);
|
| 273 | /*
|
| 272 | 274 | |
| 273 | | conkort->status = data & 0x7f;
|
| 275 | bit description
|
| 274 | 276 | |
| 275 | | cpunum_set_input_line(device->machine, 0, INPUT_LINE_IRQ0, BIT(data, 7) ? ASSERT_LINE : CLEAR_LINE);
|
| 277 | 0 _INT to main Z80
|
| 278 | 1 |
| 279 | 2 |
| 280 | 3 |
| 281 | 4 |
| 282 | 5 |
| 283 | 6 LS245 DIR
|
| 284 | 7 |
| 285 | |
| 286 | */
|
| 287 | |
| 288 | slow_t *conkort = get_safe_token_machine_slow(space->machine);
|
| 289 | |
| 290 | conkort->status = data;
|
| 291 | |
| 292 | /* interrupt to main CPU */
|
| 293 | cpu_set_input_line(space->machine->cpu[conkort->cpunum], INPUT_LINE_IRQ0, BIT(data, 7) ? ASSERT_LINE : CLEAR_LINE);
|
| 276 | 294 | }
|
| 277 | 295 | |
| 278 | 296 | /* Fast Controller */
|
| 279 | 297 | |
| 280 | 298 | static READ8_HANDLER( fast_bus_data_r )
|
| 281 | 299 | {
|
| 282 | | const device_config *device = devtag_get_device(machine, LUXOR_55_21046, CONKORT_TAG);
|
| 283 | | fast_t *conkort = get_safe_token_fast(device);
|
| 300 | fast_t *conkort = get_safe_token_machine_fast(space->machine);
|
| 284 | 301 | |
| 285 | 302 | UINT8 data = 0xff;
|
| 286 | 303 | |
| r3596 | r3597 | |
| 294 | 311 | |
| 295 | 312 | static WRITE8_HANDLER( fast_bus_data_w )
|
| 296 | 313 | {
|
| 297 | | const device_config *device = devtag_get_device(machine, LUXOR_55_21046, CONKORT_TAG);
|
| 298 | | fast_t *conkort = get_safe_token_fast(device);
|
| 314 | fast_t *conkort = get_safe_token_machine_fast(space->machine);
|
| 299 | 315 | |
| 300 | 316 | if (BIT(conkort->status, 6))
|
| 301 | 317 | {
|
| 302 | 318 | conkort->data = data;
|
| 303 | 319 | }
|
| 304 | | |
| 305 | | // cpunum_set_input_line(machine, conkort->cpunum, INPUT_LINE_NMI, PULSE_LINE);
|
| 306 | 320 | }
|
| 307 | 321 | |
| 308 | 322 | static READ8_HANDLER( fast_bus_stat_r )
|
| 309 | 323 | {
|
| 310 | | const device_config *device = devtag_get_device(machine, LUXOR_55_21046, CONKORT_TAG);
|
| 311 | | fast_t *conkort = get_safe_token_fast(device);
|
| 324 | fast_t *conkort = get_safe_token_machine_fast(space->machine);
|
| 312 | 325 | |
| 313 | 326 | return conkort->status;
|
| 314 | 327 | }
|
| 315 | 328 | |
| 316 | 329 | static WRITE8_HANDLER( fast_bus_c1_w )
|
| 317 | 330 | {
|
| 318 | | const device_config *device = devtag_get_device(machine, LUXOR_55_21046, CONKORT_TAG);
|
| 319 | | fast_t *conkort = get_safe_token_fast(device);
|
| 331 | fast_t *conkort = get_safe_token_machine_fast(space->machine);
|
| 320 | 332 | |
| 321 | | cpunum_set_input_line(machine, conkort->cpunum, INPUT_LINE_NMI, PULSE_LINE);
|
| 333 | cpu_set_input_line(space->machine->cpu[conkort->cpunum], INPUT_LINE_NMI, PULSE_LINE);
|
| 322 | 334 | }
|
| 323 | 335 | |
| 324 | 336 | static WRITE8_HANDLER( fast_bus_c3_w )
|
| 325 | 337 | {
|
| 326 | | const device_config *device = devtag_get_device(machine, LUXOR_55_21046, CONKORT_TAG);
|
| 327 | | fast_t *conkort = get_safe_token_fast(device);
|
| 338 | fast_t *conkort = get_safe_token_machine_fast(space->machine);
|
| 328 | 339 | |
| 329 | | cpunum_set_input_line(machine, conkort->cpunum, INPUT_LINE_RESET, PULSE_LINE);
|
| 340 | cpu_set_input_line(space->machine->cpu[conkort->cpunum], INPUT_LINE_RESET, PULSE_LINE);
|
| 330 | 341 | }
|
| 331 | 342 | |
| 332 | | static void fast_card_select(const device_config *device, UINT8 data)
|
| 343 | static ABCBUS_CARD_SELECT( luxor_55_21046 )
|
| 333 | 344 | {
|
| 334 | 345 | fast_t *conkort = get_safe_token_fast(device);
|
| 335 | 346 | |
| 336 | 347 | if (data == input_port_read(device->machine, "SW3"))
|
| 337 | 348 | {
|
| 338 | | memory_install_readwrite8_handler(device->machine, 0, ADDRESS_SPACE_IO, ABCBUS_INP, ABCBUS_OUT, 0x18, 0, fast_bus_data_r, fast_bus_data_w);
|
| 339 | | memory_install_read8_handler(device->machine, 0, ADDRESS_SPACE_IO, ABCBUS_STAT, ABCBUS_STAT, 0x18, 0, fast_bus_stat_r);
|
| 340 | | memory_install_write8_handler(device->machine, 0, ADDRESS_SPACE_IO, ABCBUS_C1, ABCBUS_C1, 0x18, 0, fast_bus_c1_w);
|
| 341 | | memory_install_write8_handler(device->machine, 0, ADDRESS_SPACE_IO, ABCBUS_C2, ABCBUS_C2, 0x18, 0, SMH_NOP);
|
| 342 | | memory_install_write8_handler(device->machine, 0, ADDRESS_SPACE_IO, ABCBUS_C3, ABCBUS_C3, 0x18, 0, fast_bus_c3_w);
|
| 343 | | memory_install_write8_handler(device->machine, 0, ADDRESS_SPACE_IO, ABCBUS_C4, ABCBUS_C4, 0x18, 0, SMH_NOP);
|
| 349 | memory_install_readwrite8_handler(cpu_get_address_space(device->machine->cpu[0], ADDRESS_SPACE_IO), ABCBUS_INP, ABCBUS_OUT, 0x18, 0, fast_bus_data_r, fast_bus_data_w);
|
| 350 | memory_install_read8_handler(cpu_get_address_space(device->machine->cpu[0], ADDRESS_SPACE_IO), ABCBUS_STAT, ABCBUS_STAT, 0x18, 0, fast_bus_stat_r);
|
| 351 | memory_install_write8_handler(cpu_get_address_space(device->machine->cpu[0], ADDRESS_SPACE_IO), ABCBUS_C1, ABCBUS_C1, 0x18, 0, fast_bus_c1_w);
|
| 352 | memory_install_write8_handler(cpu_get_address_space(device->machine->cpu[0], ADDRESS_SPACE_IO), ABCBUS_C2, ABCBUS_C2, 0x18, 0, SMH_NOP);
|
| 353 | memory_install_write8_handler(cpu_get_address_space(device->machine->cpu[0], ADDRESS_SPACE_IO), ABCBUS_C3, ABCBUS_C3, 0x18, 0, fast_bus_c3_w);
|
| 354 | memory_install_write8_handler(cpu_get_address_space(device->machine->cpu[0], ADDRESS_SPACE_IO), ABCBUS_C4, ABCBUS_C4, 0x18, 0, SMH_NOP);
|
| 344 | 355 | }
|
| 345 | 356 | |
| 346 | | cpunum_set_input_line(device->machine, conkort->cpunum, INPUT_LINE_RESET, PULSE_LINE);
|
| 357 | cpu_set_input_line(device->machine->cpu[conkort->cpunum], INPUT_LINE_RESET, PULSE_LINE);
|
| 347 | 358 | }
|
| 348 | 359 | |
| 349 | | static WRITE8_HANDLER( fast_1f_w )
|
| 360 | static READ8_HANDLER( fast_ctrl_r )
|
| 350 | 361 | {
|
| 351 | | /*
|
| 352 | | |
| 353 | | bit description
|
| 354 | | |
| 355 | | 0 |
| 356 | | 1 |
| 357 | | 2 |
| 358 | | 3 |
| 359 | | 4 |
| 360 | | 5 |
| 361 | | 6 |
| 362 | | 7 |
| 363 | | |
| 364 | | */
|
| 365 | | |
| 366 | | logerror("1F write %02x\n", data);
|
| 362 | return 0xff; // TODO what is this?
|
| 367 | 363 | }
|
| 368 | 364 | |
| 369 | | static WRITE8_HANDLER( fast_3f_w )
|
| 370 | | {
|
| 371 | | /*
|
| 372 | | |
| 373 | | bit description
|
| 374 | | |
| 375 | | 0 |
| 376 | | 1 |
| 377 | | 2 |
| 378 | | 3 |
| 379 | | 4 |
| 380 | | 5 |
| 381 | | 6 |
| 382 | | 7 |
| 383 | | |
| 384 | | */
|
| 385 | | |
| 386 | | logerror("3F write %02x\n", data);
|
| 387 | | }
|
| 388 | | |
| 389 | | static WRITE8_HANDLER( fast_ctrl_w )
|
| 390 | | {
|
| 391 | | /*
|
| 392 | | |
| 393 | | bit description
|
| 394 | | |
| 395 | | 0 _SEL 0
|
| 396 | | 1 _SEL 1
|
| 397 | | 2 _MOT
|
| 398 | | 3 _SIDE
|
| 399 | | 4 |
| 400 | | 5 |
| 401 | | 6 |
| 402 | | 7 |
| 403 | | |
| 404 | | */
|
| 405 | | |
| 406 | | /* drive selection */
|
| 407 | | if (!BIT(data, 0)) wd17xx_set_drive(0);
|
| 408 | | if (!BIT(data, 1)) wd17xx_set_drive(1);
|
| 409 | | |
| 410 | | /* motor enable */
|
| 411 | | floppy_drive_set_motor_state(get_floppy_image(0), !BIT(data, 2));
|
| 412 | | floppy_drive_set_motor_state(get_floppy_image(1), !BIT(data, 2));
|
| 413 | | floppy_drive_set_ready_state(get_floppy_image(0), 1, 1);
|
| 414 | | floppy_drive_set_ready_state(get_floppy_image(1), 1, 1);
|
| 415 | | |
| 416 | | /* disk side selection */
|
| 417 | | wd17xx_set_side(!BIT(data, 3));
|
| 418 | | }
|
| 419 | | |
| 420 | 365 | static READ8_HANDLER( fast_data_r )
|
| 421 | 366 | {
|
| 422 | | const device_config *device = devtag_get_device(machine, LUXOR_55_21046, CONKORT_TAG);
|
| 423 | | fast_t *conkort = get_safe_token_fast(device);
|
| 367 | fast_t *conkort = get_safe_token_machine_fast(space->machine);
|
| 424 | 368 | |
| 425 | 369 | return conkort->data;
|
| 426 | 370 | }
|
| 427 | 371 | |
| 428 | 372 | static WRITE8_HANDLER( fast_data_w )
|
| 429 | 373 | {
|
| 430 | | const device_config *device = devtag_get_device(machine, LUXOR_55_21046, CONKORT_TAG);
|
| 431 | | fast_t *conkort = get_safe_token_fast(device);
|
| 374 | fast_t *conkort = get_safe_token_machine_fast(space->machine);
|
| 432 | 375 | |
| 433 | 376 | conkort->data = data;
|
| 434 | 377 | }
|
| 435 | 378 | |
| 436 | 379 | static WRITE8_HANDLER( fast_status_w )
|
| 437 | 380 | {
|
| 438 | | const device_config *device = devtag_get_device(machine, LUXOR_55_21046, CONKORT_TAG);
|
| 439 | | fast_t *conkort = get_safe_token_fast(device);
|
| 381 | fast_t *conkort = get_safe_token_machine_fast(space->machine);
|
| 440 | 382 | |
| 441 | 383 | conkort->status = data;
|
| 442 | 384 | }
|
| r3596 | r3597 | |
| 446 | 388 | // Slow Controller
|
| 447 | 389 | |
| 448 | 390 | static ADDRESS_MAP_START( slow_map, ADDRESS_SPACE_PROGRAM, 8 )
|
| 449 | | AM_RANGE(0x0000, 0x0fff) AM_ROM
|
| 391 | AM_RANGE(0x0000, 0x0fff) AM_ROM AM_REGION("abc830", 0)
|
| 450 | 392 | AM_RANGE(0x1000, 0x13ff) AM_RAM
|
| 451 | 393 | ADDRESS_MAP_END
|
| 452 | 394 | |
| r3596 | r3597 | |
| 461 | 403 | // Fast Controller
|
| 462 | 404 | |
| 463 | 405 | static ADDRESS_MAP_START( fast_map, ADDRESS_SPACE_PROGRAM, 8 )
|
| 464 | | AM_RANGE(0x0000, 0x1fff) AM_ROM
|
| 406 | AM_RANGE(0x0000, 0x1fff) AM_ROM AM_REGION("conkort", 0)
|
| 465 | 407 | AM_RANGE(0x2000, 0x3fff) AM_RAM
|
| 466 | 408 | ADDRESS_MAP_END
|
| 467 | 409 | |
| r3596 | r3597 | |
| 472 | 414 | AM_RANGE(0x2f, 0x2f) AM_WRITE(fast_status_w)
|
| 473 | 415 | // AM_RANGE(0x3f, 0x3f) AM_WRITE()
|
| 474 | 416 | // AM_RANGE(0x4f, 0x4f) AM_WRITE()
|
| 475 | | // AM_RANGE(0x5d, 0x5d) AM_READ()
|
| 476 | | |
| 417 | AM_RANGE(0x5d, 0x5d) AM_READ(fast_ctrl_r)
|
| 477 | 418 | AM_RANGE(0x68, 0x6b) AM_READ(wd17xx_r)
|
| 478 | 419 | AM_RANGE(0x78, 0x7b) AM_WRITE(wd17xx_w)
|
| 479 | 420 | AM_RANGE(0x87, 0x87) AM_DEVREADWRITE(Z80DMA, CONKORT_Z80DMA_TAG, z80dma_r, z80dma_w)
|
| r3596 | r3597 | |
| 522 | 463 | PORT_DIPSETTING( 0x2c, "ABC 832/834/850" )
|
| 523 | 464 | PORT_DIPSETTING( 0x2d, "ABC 830" )
|
| 524 | 465 | PORT_DIPSETTING( 0x2e, "ABC 838" )
|
| 466 | |
| 467 | PORT_START("CONKORT_ROM")
|
| 468 | PORT_CONFNAME( 0x07, 0x00, "Controller PROM" )
|
| 469 | PORT_CONFSETTING( 0x00, "Luxor v1.07" )
|
| 470 | PORT_CONFSETTING( 0x01, "Luxor v1.08" )
|
| 471 | PORT_CONFSETTING( 0x02, "DIAB v2.07" )
|
| 525 | 472 | INPUT_PORTS_END
|
| 526 | 473 | |
| 527 | 474 | /* Z80 PIO */
|
| 528 | 475 | |
| 529 | 476 | static Z80PIO_ON_INT_CHANGED( pio_interrupt )
|
| 530 | 477 | {
|
| 531 | | cpunum_set_input_line(device->machine, 1, INPUT_LINE_IRQ0, state); // TODO hardcoded
|
| 478 | slow_t *conkort = get_safe_token_machine_slow(device->machine);
|
| 479 | |
| 480 | cpu_set_input_line(device->machine->cpu[conkort->cpunum], INPUT_LINE_IRQ0, state);
|
| 532 | 481 | }
|
| 533 | 482 | |
| 534 | 483 | static READ8_DEVICE_HANDLER( pio_port_a_r )
|
| 535 | 484 | {
|
| 536 | | /*
|
| 485 | slow_t *conkort = get_safe_token_machine_slow(device->machine);
|
| 537 | 486 | |
| 538 | | bit description
|
| 539 | | |
| 540 | | 0 _INT to main Z80
|
| 541 | | 1 |
| 542 | | 2 |
| 543 | | 3 |
| 544 | | 4 |
| 545 | | 5 |
| 546 | | 6 LS245 DIR
|
| 547 | | 7 |
| 548 | | |
| 549 | | */
|
| 550 | | |
| 551 | | const device_config *conkort_device = devtag_get_device(device->machine, LUXOR_55_10828, CONKORT_TAG);
|
| 552 | | slow_t *conkort = get_safe_token_slow(conkort_device);
|
| 553 | | |
| 554 | 487 | return conkort->data;
|
| 555 | 488 | }
|
| 556 | 489 | |
| 557 | 490 | static WRITE8_DEVICE_HANDLER( pio_port_a_w )
|
| 558 | 491 | {
|
| 559 | | const device_config *conkort_device = devtag_get_device(device->machine, LUXOR_55_10828, CONKORT_TAG);
|
| 560 | | slow_t *conkort = get_safe_token_slow(conkort_device);
|
| 492 | slow_t *conkort = get_safe_token_machine_slow(device->machine);
|
| 561 | 493 | |
| 562 | 494 | conkort->data = data;
|
| 563 | 495 | }
|
| r3596 | r3597 | |
| 579 | 511 | |
| 580 | 512 | */
|
| 581 | 513 | |
| 582 | | const device_config *conkort_device = devtag_get_device(device->machine, LUXOR_55_10828, CONKORT_TAG);
|
| 583 | | slow_t *conkort = get_safe_token_slow(conkort_device);
|
| 514 | slow_t *conkort = get_safe_token_machine_slow(device->machine);
|
| 584 | 515 | |
| 585 | 516 | return conkort->fdc_irq << 7;
|
| 586 | 517 | }
|
| r3596 | r3597 | |
| 606 | 537 | |
| 607 | 538 | static Z80PIO_ON_ARDY_CHANGED( pio_ardy_w )
|
| 608 | 539 | {
|
| 609 | | const device_config *conkort_device = devtag_get_device(device->machine, LUXOR_55_10828, CONKORT_TAG);
|
| 610 | | slow_t *conkort = get_safe_token_slow(conkort_device);
|
| 540 | slow_t *conkort = get_safe_token_machine_slow(device->machine);
|
| 611 | 541 | |
| 612 | 542 | conkort->pio_ardy = state;
|
| 613 | 543 | }
|
| r3596 | r3597 | |
| 615 | 545 | static Z80PIO_INTERFACE( pio_intf )
|
| 616 | 546 | {
|
| 617 | 547 | NULL, /* CPU (cannot use from within device) */
|
| 618 | | XTAL_4MHz/2, /* clock (get from main CPU) */
|
| 619 | | pio_interrupt, /* callback when change interrupt status */
|
| 548 | XTAL_4MHz/2, /* chip clock */
|
| 549 | pio_interrupt, /* interrupt callback */
|
| 620 | 550 | pio_port_a_r, /* port A read callback */
|
| 621 | 551 | pio_port_b_r, /* port B read callback */
|
| 622 | 552 | pio_port_a_w, /* port A write callback */
|
| 623 | 553 | pio_port_b_w, /* port B write callback */
|
| 624 | | pio_ardy_w, /* portA ready active callback */
|
| 625 | | NULL /* portB ready active callback */
|
| 554 | pio_ardy_w, /* port A ready callback */
|
| 555 | NULL /* port B ready callback */
|
| 626 | 556 | };
|
| 627 | 557 | |
| 628 | 558 | static const z80_daisy_chain slow_daisy_chain[] =
|
| r3596 | r3597 | |
| 633 | 563 | |
| 634 | 564 | /* Z80 DMA */
|
| 635 | 565 | |
| 566 | /*
|
| 567 | |
| 568 | DMA Transfer Programs
|
| 569 | ---------------------
|
| 570 | |
| 571 | C3 14 28 95 6B 02 8A CF 01 AF CF 87
|
| 572 | |
| 573 | C3 reset
|
| 574 | 14 port A is memory, port A address increments
|
| 575 | 28 port B is I/O, port B address fixed
|
| 576 | 95 byte mode, port B starting address low follows, interrupt control byte follows
|
| 577 | 6B port B starting address 0x006B (FDC DATA read)
|
| 578 | 02 interrupt at end of block
|
| 579 | 8A ready active high
|
| 580 | CF load
|
| 581 | 01 transfer B->A
|
| 582 | AF disable interrupts
|
| 583 | CF load
|
| 584 | 87 enable DMA
|
| 585 | |
| 586 | C3 14 28 95 7B 02 8A CF 05 AF CF 87
|
| 587 | |
| 588 | C3 reset
|
| 589 | 14 port A is memory, port A address increments
|
| 590 | 28 port B is I/O, port B address fixed
|
| 591 | 95 byte mode, port B starting address low follows, interrupt control byte follows
|
| 592 | 7B port B starting address 0x007B (FDC DATA write)
|
| 593 | 02 interrupt at end of block
|
| 594 | 8A ready active high
|
| 595 | CF load
|
| 596 | 05 transfer A->B
|
| 597 | AF disable interrupts
|
| 598 | CF load
|
| 599 | 87 enable DMA
|
| 600 | |
| 601 | C3 91 40 8A AB
|
| 602 | |
| 603 | C3 reset
|
| 604 | 91 byte mode, interrupt control byte follows
|
| 605 | 40 interrupt on RDY
|
| 606 | 8A _CE only, ready active high, stop on end of block
|
| 607 | AB enable interrupts
|
| 608 | |
| 609 | */
|
| 610 | |
| 636 | 611 | #define Z80DMA_CPUNUM 1
|
| 637 | 612 | |
| 638 | | static dma_irq_callback(const device_config *device, int state)
|
| 613 | static void dma_irq_callback(const device_config *device, int state)
|
| 639 | 614 | {
|
| 640 | | cpunum_set_input_line(device->machine, Z80DMA_CPUNUM, INPUT_LINE_IRQ0, state);
|
| 615 | fast_t *conkort = get_safe_token_machine_fast(device->machine);
|
| 616 | |
| 617 | cpu_set_input_line(device->machine->cpu[conkort->cpunum], INPUT_LINE_IRQ0, state);
|
| 641 | 618 | }
|
| 642 | 619 | |
| 643 | | static READ8_DEVICE_HANDLER( dma_read_byte )
|
| 620 | static READ8_DEVICE_HANDLER( dma_port_a_r )
|
| 644 | 621 | {
|
| 645 | | UINT8 data;
|
| 622 | fast_t *conkort = get_safe_token_machine_fast(device->machine);
|
| 623 | const address_space *program = cpu_get_address_space(device->machine->cpu[conkort->cpunum], ADDRESS_SPACE_PROGRAM);
|
| 646 | 624 | |
| 647 | | cpuintrf_push_context(Z80DMA_CPUNUM);
|
| 648 | | data = program_read_byte(offset);
|
| 649 | | cpuintrf_pop_context();
|
| 625 | UINT8 data = 0xff;
|
| 650 | 626 | |
| 627 | cpu_push_context(device->machine->cpu[conkort->cpunum]);
|
| 628 | |
| 629 | data = memory_read_byte_8le(program, offset);
|
| 630 |
|
| 631 | cpu_pop_context();
|
| 632 | |
| 651 | 633 | return data;
|
| 652 | 634 | }
|
| 653 | 635 | |
| 654 | | static WRITE8_DEVICE_HANDLER( dma_write_byte )
|
| 636 | static WRITE8_DEVICE_HANDLER( dma_port_a_w )
|
| 655 | 637 | {
|
| 656 | | cpuintrf_push_context(Z80DMA_CPUNUM);
|
| 657 | | program_write_byte(offset, data);
|
| 658 | | cpuintrf_pop_context();
|
| 638 | fast_t *conkort = get_safe_token_machine_fast(device->machine);
|
| 639 | const address_space *program = cpu_get_address_space(device->machine->cpu[conkort->cpunum], ADDRESS_SPACE_PROGRAM);
|
| 640 | |
| 641 | cpu_push_context(device->machine->cpu[conkort->cpunum]);
|
| 642 |
|
| 643 | memory_write_byte_8le(program, offset, data);
|
| 644 |
|
| 645 | cpu_pop_context();
|
| 659 | 646 | }
|
| 660 | 647 | |
| 661 | | static READ8_DEVICE_HANDLER( wd17xx_read_byte )
|
| 648 | static READ8_DEVICE_HANDLER( dma_port_b_r )
|
| 662 | 649 | {
|
| 663 | | return wd17xx_data_r(device->machine, offset);
|
| 650 | fast_t *conkort = get_safe_token_machine_fast(device->machine);
|
| 651 | const address_space *io = cpu_get_address_space(device->machine->cpu[conkort->cpunum], ADDRESS_SPACE_IO);
|
| 652 | |
| 653 | UINT8 data = 0xff;
|
| 654 | |
| 655 | cpu_push_context(device->machine->cpu[conkort->cpunum]);
|
| 656 | |
| 657 | data = memory_read_byte_8le(io, offset);
|
| 658 | |
| 659 | cpu_pop_context();
|
| 660 | |
| 661 | return data;
|
| 664 | 662 | }
|
| 665 | 663 | |
| 666 | | static WRITE8_DEVICE_HANDLER( wd17xx_write_byte )
|
| 664 | static WRITE8_DEVICE_HANDLER( dma_port_b_w )
|
| 667 | 665 | {
|
| 668 | | wd17xx_data_w(device->machine, offset, data);
|
| 666 | fast_t *conkort = get_safe_token_machine_fast(device->machine);
|
| 667 | const address_space *io = cpu_get_address_space(device->machine->cpu[conkort->cpunum], ADDRESS_SPACE_IO);
|
| 668 | |
| 669 | cpu_push_context(device->machine->cpu[conkort->cpunum]);
|
| 670 | |
| 671 | memory_write_byte_8le(io, offset, data);
|
| 672 | |
| 673 | cpu_pop_context();
|
| 669 | 674 | }
|
| 670 | 675 | |
| 671 | 676 | static const z80dma_interface dma_intf =
|
| 672 | 677 | {
|
| 673 | | Z80DMA_CPUNUM, /* cpunum to HALT */
|
| 674 | | XTAL_16MHz/4, /* chip clock */
|
| 675 | | dma_read_byte, /* memory read */
|
| 676 | | dma_write_byte, /* memory write */
|
| 677 | | wd17xx_read_byte, /* port A read */
|
| 678 | | wd17xx_write_byte, /* port A write */
|
| 679 | | 0, /* port B read */
|
| 680 | | 0, /* port B write */
|
| 681 | | dma_irq_callback /* interrupt callback */
|
| 678 | Z80DMA_CPUNUM, /* cpunum to HALT */
|
| 679 | XTAL_16MHz/4, /* chip clock */
|
| 680 | dma_port_a_r, /* memory read */
|
| 681 | dma_port_a_w, /* memory write */
|
| 682 | dma_port_a_r, /* port A read */
|
| 683 | dma_port_a_w, /* port A write */
|
| 684 | dma_port_b_r, /* port B read */
|
| 685 | dma_port_b_w, /* port B write */
|
| 686 | dma_irq_callback /* interrupt callback */
|
| 682 | 687 | };
|
| 683 | 688 | |
| 684 | 689 | static const z80_daisy_chain fast_daisy_chain[] =
|
| r3596 | r3597 | |
| 691 | 696 | |
| 692 | 697 | static void slow_wd1791_callback(running_machine *machine, wd17xx_state_t state, void *param)
|
| 693 | 698 | {
|
| 694 | | const device_config *device = devtag_get_device(machine, LUXOR_55_10828, CONKORT_TAG);
|
| 695 | | slow_t *conkort = get_safe_token_slow(device);
|
| 699 | slow_t *conkort = get_safe_token_machine_slow(machine);
|
| 696 | 700 | |
| 697 | 701 | switch(state)
|
| 698 | 702 | {
|
| r3596 | r3597 | |
| 713 | 717 | |
| 714 | 718 | static void fast_wd1793_callback(running_machine *machine, wd17xx_state_t state, void *param)
|
| 715 | 719 | {
|
| 716 | | // const device_config *z80dma = devtag_get_device(machine, Z80DMA, CONKORT_Z80DMA_TAG);
|
| 720 | fast_t *conkort = get_safe_token_machine_fast(machine);
|
| 717 | 721 | |
| 718 | 722 | switch(state)
|
| 719 | 723 | {
|
| r3596 | r3597 | |
| 722 | 726 | case WD17XX_IRQ_SET:
|
| 723 | 727 | break;
|
| 724 | 728 | case WD17XX_DRQ_CLR:
|
| 725 | | //z80dma_rdy_w(z80dma, 0, 0);
|
| 729 | z80dma_rdy_w(conkort->z80dma, 0, 0);
|
| 726 | 730 | break;
|
| 727 | 731 | case WD17XX_DRQ_SET:
|
| 728 | | //z80dma_rdy_w(z80dma, 0, 1);
|
| 732 | z80dma_rdy_w(conkort->z80dma, 0, 1);
|
| 729 | 733 | break;
|
| 730 | 734 | }
|
| 731 | 735 | }
|
| r3596 | r3597 | |
| 753 | 757 | |
| 754 | 758 | /* ROMs */
|
| 755 | 759 | |
| 756 | | ROM_START( l5510828 )
|
| 757 | | ROM_REGION( 0x10000, CONKORT_Z80_TAG, 0 )
|
| 758 | | ROM_LOAD( "mpi02.bin", 0x0000, 0x0800, CRC(2aac9296) SHA1(c01a62e7933186bdf7068d2e9a5bc36590544349) ) // ABC830 with MPI drives. Styrkort Artnr 5510760-01
|
| 760 | ROM_START( luxor_55_10828 )
|
| 761 | ROM_REGION( 0x1000, "abc830", ROMREGION_LOADBYNAME )
|
| 762 | ROM_LOAD( "mpi02.bin", 0x0000, 0x0800, CRC(2aac9296) SHA1(c01a62e7933186bdf7068d2e9a5bc36590544349) ) // MPI 51
|
| 763 | ROM_LOAD( "basf6106.bin", 0x0800, 0x0800, NO_DUMP ) // BASF 6106
|
| 759 | 764 | |
| 760 | | ROM_REGION( 0x800, "abc830", 0 )
|
| 761 | | ROM_LOAD( "mpi02.bin", 0x0000, 0x0800, CRC(2aac9296) SHA1(c01a62e7933186bdf7068d2e9a5bc36590544349) ) // ABC830 with MPI drives. Styrkort Artnr 5510760-01
|
| 762 | | |
| 763 | | ROM_REGION( 0x1800, "abc832", 0 )
|
| 765 | ROM_REGION( 0x1800, "abc832", ROMREGION_LOADBYNAME )
|
| 764 | 766 | ROM_LOAD( "micr1015.bin", 0x0000, 0x0800, CRC(a7bc05fa) SHA1(6ac3e202b7ce802c70d89728695f1cb52ac80307) ) // Micropolis 1015
|
| 765 | 767 | ROM_LOAD( "micr1115.bin", 0x0800, 0x0800, CRC(f2fc5ccc) SHA1(86d6baadf6bf1d07d0577dc1e092850b5ff6dd1b) ) // Micropolis 1115
|
| 766 | 768 | ROM_LOAD( "basf6118.bin", 0x1000, 0x0800, CRC(9ca1a1eb) SHA1(04973ad69de8da403739caaebe0b0f6757e4a6b1) ) // BASF 6118
|
| 767 | 769 | |
| 768 | | ROM_REGION( 0x1000, "abc850", 0 )
|
| 769 | | ROM_LOAD( "rodi202.bin", 0x0000, 0x0800, CRC(337b4dcf) SHA1(791ebeb4521ddc11fb9742114018e161e1849bdf) ) // Rodime 202
|
| 770 | | ROM_LOAD( "basf6185.bin", 0x0800, 0x0800, CRC(06f8fe2e) SHA1(e81f2a47c854e0dbb096bee3428d79e63591059d) ) // BASF 6185
|
| 770 | ROM_REGION( 0x1000, "abc838", ROMREGION_LOADBYNAME )
|
| 771 | ROM_LOAD( "basf6104.bin", 0x0800, 0x0800, NO_DUMP ) // BASF 6104
|
| 772 | ROM_LOAD( "basf6115.bin", 0x0800, 0x0800, NO_DUMP ) // BASF 6115
|
| 773 | ROM_END
|
| 771 | 774 | |
| 772 | | ROM_REGION( 0x1000, "abc852", 0 )
|
| 775 | ROM_START( luxor_55_21046 )
|
| 776 | ROM_REGION( 0x10000, "conkort", ROMREGION_LOADBYNAME )
|
| 777 | ROM_LOAD( "6490318-07.bin", 0x0000, 0x2000, CRC(06ae1fe8) SHA1(ad1d9d0c192539af70cb95223263915a09693ef8) ) // PROM v1.07, Art N/O 6490318-07. Luxor Styrkort Art. N/O 55 21046-41. Date 1985-07-03
|
| 778 | // ROM_LOAD( "fast108.bin", 0x2000, 0x2000, CRC(229764cb) SHA1(a2e2f6f49c31b827efc62f894de9a770b65d109d) ) // Luxor v1.08
|
| 779 | // ROM_LOAD( "fast207.bin", 0x4000, 0x2000, CRC(86622f52) SHA1(61ad271de53152c1640c0b364fce46d1b0b4c7e2) ) // DIAB v2.07
|
| 780 | ROM_END
|
| 781 | |
| 782 | ROM_START( hdd_controller ) // TODO: remove this!
|
| 783 | ROM_REGION( 0x1000, "abc850", ROMREGION_LOADBYNAME )
|
| 784 | ROM_LOAD( "rodi202.bin", 0x0000, 0x0800, CRC(337b4dcf) SHA1(791ebeb4521ddc11fb9742114018e161e1849bdf) ) // Rodime RO202 (http://artofhacking.com/th99/h/txt/3699.txt)
|
| 785 | ROM_LOAD( "basf6185.bin", 0x0800, 0x0800, CRC(06f8fe2e) SHA1(e81f2a47c854e0dbb096bee3428d79e63591059d) ) // BASF 6185 (http://bk0010.narod.ru/hardware_specs/h/txt/178.txt)
|
| 786 | |
| 787 | ROM_REGION( 0x1000, "abc852", ROMREGION_LOADBYNAME )
|
| 773 | 788 | ROM_LOAD( "nec5126.bin", 0x0000, 0x1000, CRC(17c247e7) SHA1(7339738b87751655cb4d6414422593272fe72f5d) ) // NEC 5126
|
| 774 | 789 | |
| 775 | | ROM_REGION( 0x800, "abc856", 0 )
|
| 790 | ROM_REGION( 0x800, "abc856", ROMREGION_LOADBYNAME )
|
| 776 | 791 | ROM_LOAD( "micr1325.bin", 0x0000, 0x0800, CRC(084af409) SHA1(342b8e214a8c4c2b014604e53c45ef1bd1c69ea3) ) // Micropolis 1325
|
| 777 | 792 | |
| 778 | | ROM_REGION( 0x1000, "xebec", 0 )
|
| 793 | ROM_REGION( 0x1000, "xebec", ROMREGION_LOADBYNAME )
|
| 779 | 794 | ROM_LOAD( "st4038.bin", 0x0000, 0x0800, CRC(4c803b87) SHA1(1141bb51ad9200fc32d92a749460843dc6af8953) ) // Seagate ST4038
|
| 780 | 795 | ROM_LOAD( "st225.bin", 0x0800, 0x0800, CRC(c9f68f81) SHA1(7ff8b2a19f71fe0279ab3e5a0a5fffcb6030360c) ) // Seagate ST225
|
| 781 | 796 | ROM_END
|
| 782 | 797 | |
| 783 | | ROM_START( l5521046 )
|
| 784 | | ROM_REGION( 0x10000, CONKORT_Z80_TAG, 0 )
|
| 785 | | ROM_LOAD( "fast108.bin", 0x0000, 0x2000, CRC(229764cb) SHA1(a2e2f6f49c31b827efc62f894de9a770b65d109d) ) // Luxor v1.08
|
| 786 | | ROM_LOAD( "6490318-07.bin", 0x0000, 0x2000, CRC(06ae1fe8) SHA1(ad1d9d0c192539af70cb95223263915a09693ef8) ) // PROM v1.07, Art N/O 6490318-07. Luxor Styrkort Art. N/O 55 21046-41. Date 1985-07-03
|
| 787 | | ROM_LOAD( "fast207.bin", 0x0000, 0x2000, CRC(86622f52) SHA1(61ad271de53152c1640c0b364fce46d1b0b4c7e2) ) // DIAB v2.07
|
| 788 | | ROM_END
|
| 789 | | |
| 790 | 798 | /* Device Interface */
|
| 791 | 799 | |
| 792 | 800 | static DEVICE_START( luxor_55_10828 )
|
| 793 | 801 | {
|
| 794 | 802 | slow_t *conkort = device->token;
|
| 795 | | char unique_tag[30];
|
| 796 | 803 | astring *tempstring = astring_alloc();
|
| 797 | 804 | |
| 798 | 805 | /* validate arguments */
|
| 799 | | |
| 800 | 806 | assert(device->machine != NULL);
|
| 801 | 807 | assert(device->tag != NULL);
|
| 802 | 808 | assert(strlen(device->tag) < 20);
|
| 803 | 809 | |
| 804 | 810 | /* find our CPU */
|
| 805 | | |
| 806 | 811 | astring_printf(tempstring, "%s:%s", device->tag, CONKORT_Z80_TAG);
|
| 807 | 812 | conkort->cpunum = mame_find_cpu_index(device->machine, astring_c(tempstring));
|
| 808 | 813 | astring_free(tempstring);
|
| 809 | 814 | |
| 815 | /* find devices */
|
| 816 | conkort->z80pio = devtag_get_device(device->machine, Z80PIO, "conkort:3a"); // TODO hardcoded
|
| 817 | |
| 810 | 818 | /* initialize FDC */
|
| 811 | | |
| 812 | 819 | wd17xx_init(device->machine, WD_TYPE_179X, slow_wd1791_callback, NULL); // FD1791-01
|
| 813 | 820 | |
| 814 | 821 | /* register for state saving */
|
| 815 | 822 | |
| 816 | | state_save_combine_module_and_tag(unique_tag, "conkort", device->tag);
|
| 817 | | |
| 818 | 823 | return DEVICE_START_OK;
|
| 819 | 824 | }
|
| 820 | 825 | |
| 826 | static DEVICE_RESET( luxor_55_10828 )
|
| 827 | {
|
| 828 | wd17xx_reset(device->machine);
|
| 829 | }
|
| 830 | |
| 821 | 831 | static DEVICE_SET_INFO( luxor_55_10828 )
|
| 822 | 832 | {
|
| 823 | 833 | switch (state)
|
| r3596 | r3597 | |
| 826 | 836 | }
|
| 827 | 837 | }
|
| 828 | 838 | |
| 829 | | static DEVICE_RESET( luxor_55_10828 )
|
| 830 | | {
|
| 831 | | wd17xx_reset(device->machine);
|
| 832 | | }
|
| 833 | | |
| 834 | 839 | DEVICE_GET_INFO( luxor_55_10828 )
|
| 835 | 840 | {
|
| 836 | 841 | switch (state)
|
| 837 | 842 | {
|
| 838 | 843 | /* --- the following bits of info are returned as 64-bit signed integers --- */
|
| 839 | | case DEVINFO_INT_INLINE_CONFIG_BYTES: info->i = 0; break;
|
| 840 | | case DEVINFO_INT_CLASS: info->i = DEVICE_CLASS_PERIPHERAL; break;
|
| 841 | | case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(slow_t); break;
|
| 844 | case DEVINFO_INT_INLINE_CONFIG_BYTES: info->i = 0; break;
|
| 845 | case DEVINFO_INT_CLASS: info->i = DEVICE_CLASS_PERIPHERAL; break;
|
| 846 | case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(slow_t); break;
|
| 842 | 847 | |
| 843 | 848 | /* --- the following bits of info are returned as pointers --- */
|
| 844 | | case DEVINFO_PTR_ROM_REGION: info->romregion = rom_l5510828; break;
|
| 845 | | case DEVINFO_PTR_MACHINE_CONFIG: info->machine_config = machine_config_luxor_55_10828; break;
|
| 849 | case DEVINFO_PTR_ROM_REGION: info->romregion = ROM_NAME(luxor_55_10828); break;
|
| 850 | case DEVINFO_PTR_MACHINE_CONFIG: info->machine_config = MACHINE_DRIVER_NAME(luxor_55_10828); break;
|
| 846 | 851 | |
| 847 | 852 | /* --- the following bits of info are returned as pointers to data or functions --- */
|
| 848 | | case DEVINFO_FCT_SET_INFO: info->set_info = DEVICE_SET_INFO_NAME(luxor_55_10828); break;
|
| 849 | | case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(luxor_55_10828); break;
|
| 850 | | case DEVINFO_FCT_STOP: /* Nothing */ break;
|
| 851 | | case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(luxor_55_10828); break;
|
| 852 | | case DEVINFO_FCT_CARD_SELECT: info->f = (genf *)slow_card_select; break;
|
| 853 | case DEVINFO_FCT_SET_INFO: info->set_info = DEVICE_SET_INFO_NAME(luxor_55_10828); break;
|
| 854 | case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(luxor_55_10828); break;
|
| 855 | case DEVINFO_FCT_STOP: /* Nothing */ break;
|
| 856 | case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(luxor_55_10828); break;
|
| 857 | case DEVINFO_FCT_ABCBUS_CARD_SELECT: info->f = (genf *)ABCBUS_CARD_SELECT_NAME(luxor_55_10828); break;
|
| 853 | 858 | |
| 854 | 859 | /* --- the following bits of info are returned as NULL-terminated strings --- */
|
| 855 | | case DEVINFO_STR_NAME: info->s = "Luxor 55 10828"; break;
|
| 856 | | case DEVINFO_STR_FAMILY: info->s = "Luxor ABC"; break;
|
| 857 | | case DEVINFO_STR_VERSION: info->s = "1.0"; break;
|
| 858 | | case DEVINFO_STR_SOURCE_FILE: info->s = __FILE__; break;
|
| 859 | | case DEVINFO_STR_CREDITS: info->s = "Copyright the MESS Team"; break;
|
| 860 | case DEVINFO_STR_NAME: info->s = "Luxor 55 10828-01"; break;
|
| 861 | case DEVINFO_STR_FAMILY: info->s = "Luxor ABC"; break;
|
| 862 | case DEVINFO_STR_VERSION: info->s = "1.0"; break;
|
| 863 | case DEVINFO_STR_SOURCE_FILE: info->s = __FILE__; break;
|
| 864 | case DEVINFO_STR_CREDITS: info->s = "Copyright the MESS Team"; break;
|
| 860 | 865 | }
|
| 861 | 866 | }
|
| 862 | 867 | |
| 863 | 868 | static DEVICE_START( luxor_55_21046 )
|
| 864 | 869 | {
|
| 865 | 870 | fast_t *conkort = device->token;
|
| 866 | | char unique_tag[30];
|
| 867 | 871 | astring *tempstring = astring_alloc();
|
| 868 | 872 | |
| 869 | 873 | /* validate arguments */
|
| 870 | | |
| 871 | 874 | assert(device->machine != NULL);
|
| 872 | 875 | assert(device->tag != NULL);
|
| 873 | 876 | assert(strlen(device->tag) < 20);
|
| 874 | 877 | |
| 875 | 878 | /* find our CPU */
|
| 876 | | |
| 877 | 879 | astring_printf(tempstring, "%s:%s", device->tag, CONKORT_Z80_TAG);
|
| 878 | 880 | conkort->cpunum = mame_find_cpu_index(device->machine, astring_c(tempstring));
|
| 879 | 881 | astring_free(tempstring);
|
| 880 | 882 | |
| 883 | /* find devices */
|
| 884 | conkort->z80dma = devtag_get_device(device->machine, Z80DMA, "conkort:z80dma"); // TODO hardcoded
|
| 885 | |
| 881 | 886 | /* initialize FDC */
|
| 882 | | |
| 883 | 887 | wd17xx_init(device->machine, WD_TYPE_1793, fast_wd1793_callback, NULL); // FD1793-01
|
| 884 | 888 | |
| 885 | 889 | /* register for state saving */
|
| 886 | 890 | |
| 887 | | state_save_combine_module_and_tag(unique_tag, "conkort", device->tag);
|
| 888 | | |
| 889 | 891 | return DEVICE_START_OK;
|
| 890 | 892 | }
|
| 891 | 893 | |
| 894 | static DEVICE_RESET( luxor_55_21046 )
|
| 895 | {
|
| 896 | /* reset the FDC */
|
| 897 | wd17xx_reset(device->machine);
|
| 898 | }
|
| 899 | |
| 892 | 900 | static DEVICE_SET_INFO( luxor_55_21046 )
|
| 893 | 901 | {
|
| 894 | 902 | switch (state)
|
| r3596 | r3597 | |
| 897 | 905 | }
|
| 898 | 906 | }
|
| 899 | 907 | |
| 900 | | static DEVICE_RESET( luxor_55_21046 )
|
| 901 | | {
|
| 902 | | wd17xx_reset(device->machine);
|
| 903 | | }
|
| 904 | | |
| 905 | 908 | DEVICE_GET_INFO( luxor_55_21046 )
|
| 906 | 909 | {
|
| 907 | 910 | switch (state)
|
| 908 | 911 | {
|
| 909 | 912 | /* --- the following bits of info are returned as 64-bit signed integers --- */
|
| 910 | | case DEVINFO_INT_INLINE_CONFIG_BYTES: info->i = 0; break;
|
| 911 | | case DEVINFO_INT_CLASS: info->i = DEVICE_CLASS_PERIPHERAL; break;
|
| 912 | | case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(slow_t); break;
|
| 913 | case DEVINFO_INT_INLINE_CONFIG_BYTES: info->i = 0; break;
|
| 914 | case DEVINFO_INT_CLASS: info->i = DEVICE_CLASS_PERIPHERAL; break;
|
| 915 | case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(fast_t); break;
|
| 913 | 916 | |
| 914 | 917 | /* --- the following bits of info are returned as pointers --- */
|
| 915 | | case DEVINFO_PTR_ROM_REGION: info->romregion = rom_l5521046; break;
|
| 916 | | case DEVINFO_PTR_MACHINE_CONFIG: info->machine_config = machine_config_luxor_55_21046; break;
|
| 918 | case DEVINFO_PTR_ROM_REGION: info->romregion = ROM_NAME(luxor_55_21046); break;
|
| 919 | case DEVINFO_PTR_MACHINE_CONFIG: info->machine_config = MACHINE_DRIVER_NAME(luxor_55_21046); break;
|
| 917 | 920 | |
| 918 | 921 | /* --- the following bits of info are returned as pointers to data or functions --- */
|
| 919 | | case DEVINFO_FCT_SET_INFO: info->set_info = DEVICE_SET_INFO_NAME(luxor_55_21046); break;
|
| 920 | | case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(luxor_55_21046); break;
|
| 921 | | case DEVINFO_FCT_STOP: /* Nothing */ break;
|
| 922 | | case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(luxor_55_21046); break;
|
| 923 | | case DEVINFO_FCT_CARD_SELECT: info->f = (genf *)fast_card_select; break;
|
| 922 | case DEVINFO_FCT_SET_INFO: info->set_info = DEVICE_SET_INFO_NAME(luxor_55_21046); break;
|
| 923 | case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(luxor_55_21046); break;
|
| 924 | case DEVINFO_FCT_STOP: /* Nothing */ break;
|
| 925 | case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(luxor_55_21046); break;
|
| 926 | case DEVINFO_FCT_ABCBUS_CARD_SELECT: info->f = (genf *)ABCBUS_CARD_SELECT_NAME(luxor_55_21046); break;
|
| 924 | 927 | |
| 925 | 928 | /* --- the following bits of info are returned as NULL-terminated strings --- */
|
| 926 | | case DEVINFO_STR_NAME: info->s = "Luxor Conkort 55 21046"; break;
|
| 927 | | case DEVINFO_STR_FAMILY: info->s = "Luxor ABC"; break;
|
| 928 | | case DEVINFO_STR_VERSION: info->s = "1.0"; break;
|
| 929 | | case DEVINFO_STR_SOURCE_FILE: info->s = __FILE__; break;
|
| 930 | | case DEVINFO_STR_CREDITS: info->s = "Copyright the MESS Team"; break;
|
| 929 | case DEVINFO_STR_NAME: info->s = "Luxor Conkort 55 21046-xx"; break;
|
| 930 | case DEVINFO_STR_FAMILY: info->s = "Luxor ABC"; break;
|
| 931 | case DEVINFO_STR_VERSION: info->s = "1.0"; break;
|
| 932 | case DEVINFO_STR_SOURCE_FILE: info->s = __FILE__; break;
|
| 933 | case DEVINFO_STR_CREDITS: info->s = "Copyright the MESS Team"; break;
|
| 931 | 934 | }
|
| 932 | 935 | }
|
src/mess/drivers/abc80x.c
| r3596 | r3597 | |
| 87 | 87 | |
| 88 | 88 | static const device_config *cassette_device_image(running_machine *machine) |
| 89 | 89 | { |
| 90 | | return device_list_find_by_tag( machine->config->devicelist, CASSETTE, "cassette" ); |
| 90 | return devtag_get_device(machine, CASSETTE, "cassette"); |
| 91 | 91 | } |
| 92 | 92 | |
| 93 | 93 | /* Discrete Sound */ |
| r3596 | r3597 | |
| 268 | 268 | //logerror("%04x-%04x: Video RAM %04x (32K)\n", start_addr, end_addr, videoram_offset); |
| 269 | 269 | |
| 270 | 270 | memory_install_readwrite8_handler(cpu_get_address_space(machine->cpu[0], ADDRESS_SPACE_PROGRAM), start_addr, end_addr, 0, 0, SMH_BANK(bank), SMH_BANK(bank)); |
| 271 | | memory_configure_bank(bank, 1, 1, state->videoram + videoram_offset, 0); |
| 272 | | memory_set_bank(bank, 1); |
| 271 | memory_configure_bank(machine, bank, 1, 1, state->videoram + videoram_offset, 0); |
| 272 | memory_set_bank(machine, bank, 1); |
| 273 | 273 | } |
| 274 | 274 | |
| 275 | 275 | for (bank = 9; bank <= 16; bank++) |
| r3596 | r3597 | |
| 282 | 282 | //logerror("%04x-%04x: Work RAM (32K)\n", start_addr, end_addr); |
| 283 | 283 | |
| 284 | 284 | memory_install_readwrite8_handler(cpu_get_address_space(machine->cpu[0], ADDRESS_SPACE_PROGRAM), start_addr, end_addr, 0, 0, SMH_BANK(bank), SMH_BANK(bank)); |
| 285 | | memory_set_bank(bank, 0); |
| 285 | memory_set_bank(machine, bank, 0); |
| 286 | 286 | } |
| 287 | 287 | } |
| 288 | 288 | else |
| r3596 | r3597 | |
| 302 | 302 | //logerror("%04x-%04x: Video RAM %04x (4K)\n", start_addr, end_addr, videoram_offset); |
| 303 | 303 | |
| 304 | 304 | memory_install_readwrite8_handler(cpu_get_address_space(machine->cpu[0], ADDRESS_SPACE_PROGRAM), start_addr, end_addr, 0, 0, SMH_BANK(bank), SMH_BANK(bank)); |
| 305 | | memory_configure_bank(bank, 1, 1, state->videoram + videoram_offset, 0); |
| 306 | | memory_set_bank(bank, 1); |
| 305 | memory_configure_bank(machine, bank, 1, 1, state->videoram + videoram_offset, 0); |
| 306 | memory_set_bank(machine, bank, 1); |
| 307 | 307 | } |
| 308 | 308 | else |
| 309 | 309 | { |
| r3596 | r3597 | |
| 316 | 316 | //logerror("%04x-%04x: ROM (4K)\n", start_addr, end_addr); |
| 317 | 317 | |
| 318 | 318 | memory_install_readwrite8_handler(cpu_get_address_space(machine->cpu[0], ADDRESS_SPACE_PROGRAM), start_addr, end_addr, 0, 0, SMH_BANK(bank), SMH_UNMAP); |
| 319 | | memory_set_bank(bank, 0); |
| 319 | memory_set_bank(machine, bank, 0); |
| 320 | 320 | break; |
| 321 | 321 | |
| 322 | 322 | case 8: |
| r3596 | r3597 | |
| 325 | 325 | |
| 326 | 326 | memory_install_readwrite8_handler(cpu_get_address_space(machine->cpu[0], ADDRESS_SPACE_PROGRAM), 0x7000, 0x77ff, 0, 0, SMH_BANK(bank), SMH_UNMAP); |
| 327 | 327 | memory_install_readwrite8_handler(cpu_get_address_space(machine->cpu[0], ADDRESS_SPACE_PROGRAM), 0x7800, 0x7fff, 0, 0, abc806_charram_r, abc806_charram_w); |
| 328 | | memory_set_bank(bank, 0); |
| 328 | memory_set_bank(machine, bank, 0); |
| 329 | 329 | break; |
| 330 | 330 | |
| 331 | 331 | default: |
| r3596 | r3597 | |
| 333 | 333 | //logerror("%04x-%04x: Work RAM (4K)\n", start_addr, end_addr); |
| 334 | 334 | |
| 335 | 335 | memory_install_readwrite8_handler(cpu_get_address_space(machine->cpu[0], ADDRESS_SPACE_PROGRAM), start_addr, end_addr, 0, 0, SMH_BANK(bank), SMH_BANK(bank)); |
| 336 | | memory_set_bank(bank, 0); |
| 336 | memory_set_bank(machine, bank, 0); |
| 337 | 337 | break; |
| 338 | 338 | } |
| 339 | 339 | } |
| r3596 | r3597 | |
| 366 | 366 | memory_install_readwrite8_handler(cpu_get_address_space(machine->cpu[0], ADDRESS_SPACE_PROGRAM), start_addr, end_addr, 0, 0, SMH_BANK(bank), SMH_BANK(bank)); |
| 367 | 367 | } |
| 368 | 368 | |
| 369 | | memory_configure_bank(bank, 1, 1, state->videoram + videoram_offset, 0); |
| 370 | | memory_set_bank(bank, 1); |
| 369 | memory_configure_bank(machine, bank, 1, 1, state->videoram + videoram_offset, 0); |
| 370 | memory_set_bank(machine, bank, 1); |
| 371 | 371 | } |
| 372 | 372 | } |
| 373 | 373 | } |
| 374 | 374 | |
| 375 | 375 | static READ8_HANDLER( abc806_mai_r ) |
| 376 | 376 | { |
| 377 | | abc806_state *state = machine->driver_data; |
| 377 | abc806_state *state = space->machine->driver_data; |
| 378 | 378 | |
| 379 | 379 | int bank = offset >> 12; |
| 380 | 380 | |
| r3596 | r3597 | |
| 398 | 398 | |
| 399 | 399 | */ |
| 400 | 400 | |
| 401 | | abc806_state *state = machine->driver_data; |
| 401 | abc806_state *state = space->machine->driver_data; |
| 402 | 402 | |
| 403 | 403 | int bank = offset >> 12; |
| 404 | 404 | |
| 405 | 405 | state->map[bank] = data; |
| 406 | 406 | |
| 407 | | abc806_bankswitch(machine); |
| 407 | abc806_bankswitch(space->machine); |
| 408 | 408 | } |
| 409 | 409 | |
| 410 | 410 | /* Z80 SIO/2 */ |
| r3596 | r3597 | |
| 449 | 449 | |
| 450 | 450 | static READ8_HANDLER( abc800_pling_r ) |
| 451 | 451 | { |
| 452 | | abc800_state *state = machine->driver_data; |
| 452 | abc800_state *state = space->machine->driver_data; |
| 453 | 453 | |
| 454 | 454 | state->pling = !state->pling; |
| 455 | 455 | |
| 456 | | discrete_sound_w(machine, NODE_01, state->pling); |
| 456 | discrete_sound_w(space, NODE_01, state->pling); |
| 457 | 457 | |
| 458 | 458 | return 0xff; |
| 459 | 459 | } |
| 460 | 460 | |
| 461 | 461 | static READ8_HANDLER( abc802_pling_r ) |
| 462 | 462 | { |
| 463 | | abc802_state *state = machine->driver_data; |
| 463 | abc802_state *state = space->machine->driver_data; |
| 464 | 464 | |
| 465 | 465 | state->pling = !state->pling; |
| 466 | 466 | |
| 467 | | discrete_sound_w(machine, NODE_01, state->pling); |
| 467 | discrete_sound_w(space, NODE_01, state->pling); |
| 468 | 468 | |
| 469 | 469 | return 0xff; |
| 470 | 470 | } |
| r3596 | r3597 | |
| 785 | 785 | |
| 786 | 786 | static void ctc_interrupt(const device_config *device, int state) |
| 787 | 787 | { |
| 788 | | cpunum_set_input_line(device->machine, 0, INPUT_LINE_IRQ0, state); |
| 788 | cpu_set_input_line(device->machine->cpu[0], INPUT_LINE_IRQ0, state); |
| 789 | 789 | } |
| 790 | 790 | |
| 791 | 791 | static WRITE8_DEVICE_HANDLER( ctc_z0_w ) |
| r3596 | r3597 | |
| 854 | 854 | |
| 855 | 855 | static void sio_interrupt(const device_config *device, int state) |
| 856 | 856 | { |
| 857 | | cpunum_set_input_line(device->machine, 0, INPUT_LINE_IRQ0, state); |
| 857 | cpu_set_input_line(device->machine->cpu[0], INPUT_LINE_IRQ0, state); |
| 858 | 858 | } |
| 859 | 859 | |
| 860 | 860 | static WRITE8_DEVICE_HANDLER( sio_dtr_w ) |
| r3596 | r3597 | |
| 900 | 900 | |
| 901 | 901 | static Z80DART_ON_INT_CHANGED( dart_interrupt ) |
| 902 | 902 | { |
| 903 | | cpunum_set_input_line(device->machine, 0, INPUT_LINE_IRQ0, state); |
| 903 | cpu_set_input_line(device->machine->cpu[0], INPUT_LINE_IRQ0, state); |
| 904 | 904 | } |
| 905 | 905 | |
| 906 | 906 | static Z80DART_RXD_READ( abc800_dart_rxd_r ) |
| r3596 | r3597 | |
| 1193 | 1193 | |
| 1194 | 1194 | for (bank = 1; bank <= 16; bank++) |
| 1195 | 1195 | { |
| 1196 | | memory_configure_bank(bank, 0, 1, mem + (0x1000 * (bank - 1)), 0); |
| 1197 | | memory_configure_bank(bank, 1, 1, state->videoram, 0); |
| 1198 | | memory_set_bank(bank, 0); |
| 1196 | memory_configure_bank(machine, bank, 0, 1, mem + (0x1000 * (bank - 1)), 0); |
| 1197 | memory_configure_bank(machine, bank, 1, 1, state->videoram, 0); |
| 1198 | memory_set_bank(machine, bank, 0); |
| 1199 | 1199 | } |
| 1200 | 1200 | |
| 1201 | 1201 | /* register for state saving */ |
| r3596 | r3597 | |
| 1217 | 1217 | |
| 1218 | 1218 | for (bank = 1; bank <= 16; bank++) |
| 1219 | 1219 | { |
| 1220 | | memory_set_bank(bank, 0); |
| 1220 | memory_set_bank(machine, bank, 0); |
| 1221 | 1221 | } |
| 1222 | 1222 | |
| 1223 | 1223 | abc806_bankswitch(machine); |
| r3596 | r3597 | |
| 1664 | 1664 | |
| 1665 | 1665 | /* Driver Initialization */ |
| 1666 | 1666 | |
| 1667 | | static OPBASE_HANDLER( abc800_opbase_handler ) |
| 1667 | static DIRECT_UPDATE_HANDLER( abc800_direct_update_handler ) |
| 1668 | 1668 | { |
| 1669 | | abc800_state *state = machine->driver_data; |
| 1669 | abc800_state *state = space->machine->driver_data; |
| 1670 | 1670 | |
| 1671 | 1671 | if (address >= 0x7800 && address < 0x8000) |
| 1672 | 1672 | { |
| 1673 | | opbase->rom = opbase->ram = memory_region(machine, Z80_TAG); |
| 1673 | direct->raw = direct->decrypted = memory_region(space->machine, Z80_TAG); |
| 1674 | 1674 | |
| 1675 | 1675 | if (!state->fetch_charram) |
| 1676 | 1676 | { |
| 1677 | 1677 | state->fetch_charram = 1; |
| 1678 | | abc800_bankswitch(machine); |
| 1678 | abc800_bankswitch(space->machine); |
| 1679 | 1679 | } |
| 1680 | 1680 | |
| 1681 | 1681 | return ~0; |
| r3596 | r3597 | |
| 1684 | 1684 | if (state->fetch_charram) |
| 1685 | 1685 | { |
| 1686 | 1686 | state->fetch_charram = 0; |
| 1687 | | abc800_bankswitch(machine); |
| 1687 | abc800_bankswitch(space->machine); |
| 1688 | 1688 | } |
| 1689 | 1689 | |
| 1690 | 1690 | return address; |
| 1691 | 1691 | } |
| 1692 | 1692 | |
| 1693 | | static OPBASE_HANDLER( abc802_opbase_handler ) |
| 1693 | static DIRECT_UPDATE_HANDLER( abc802_direct_update_handler ) |
| 1694 | 1694 | { |
| 1695 | | abc802_state *state = machine->driver_data; |
| 1695 | abc802_state *state = space->machine->driver_data; |
| 1696 | 1696 | |
| 1697 | 1697 | if (state->lrs) |
| 1698 | 1698 | { |
| 1699 | 1699 | if (address >= 0x7800 && address < 0x8000) |
| 1700 | 1700 | { |
| 1701 | | opbase->rom = opbase->ram = memory_region(machine, Z80_TAG); |
| 1701 | direct->raw = direct->decrypted = memory_region(space->machine, Z80_TAG); |
| 1702 | 1702 | return ~0; |
| 1703 | 1703 | } |
| 1704 | 1704 | } |
| 1705 | 1705 | else |
| 1706 | 1706 | { |
| 1707 | | opbase->rom = opbase->ram = mess_ram; |
| 1707 | direct->raw = direct->decrypted = mess_ram; |
| 1708 | 1708 | return ~0; |
| 1709 | 1709 | } |
| 1710 | 1710 | |
| 1711 | 1711 | return address; |
| 1712 | 1712 | } |
| 1713 | 1713 | |
| 1714 | | static OPBASE_HANDLER( abc806_opbase_handler ) |
| 1714 | static DIRECT_UPDATE_HANDLER( abc806_direct_update_handler ) |
| 1715 | 1715 | { |
| 1716 | | abc806_state *state = machine->driver_data; |
| 1716 | abc806_state *state = space->machine->driver_data; |
| 1717 | 1717 | |
| 1718 | 1718 | if (address >= 0x7800 && address < 0x8000) |
| 1719 | 1719 | { |
| 1720 | | opbase->rom = opbase->ram = memory_region(machine, Z80_TAG); |
| 1720 | direct->raw = direct->decrypted = memory_region(space->machine, Z80_TAG); |
| 1721 | 1721 | |
| 1722 | 1722 | if (!state->fetch_charram) |
| 1723 | 1723 | { |
| 1724 | 1724 | state->fetch_charram = 1; |
| 1725 | | abc806_bankswitch(machine); |
| 1725 | abc806_bankswitch(space->machine); |
| 1726 | 1726 | } |
| 1727 | 1727 | |
| 1728 | 1728 | return ~0; |
| r3596 | r3597 | |
| 1731 | 1731 | if (state->fetch_charram) |
| 1732 | 1732 | { |
| 1733 | 1733 | state->fetch_charram = 0; |
| 1734 | | abc806_bankswitch(machine); |
| 1734 | abc806_bankswitch(space->machine); |
| 1735 | 1735 | } |
| 1736 | 1736 | |
| 1737 | 1737 | return address; |
| r3596 | r3597 | |
| 1739 | 1739 | |
| 1740 | 1740 | static DRIVER_INIT( abc800 ) |
| 1741 | 1741 | { |
| 1742 | | memory_set_opbase_handler(0, abc800_opbase_handler); |
| 1742 | memory_set_direct_update_handler(cpu_get_address_space(machine->cpu[0], ADDRESS_SPACE_PROGRAM), abc800_direct_update_handler); |
| 1743 | 1743 | } |
| 1744 | 1744 | |
| 1745 | 1745 | static DRIVER_INIT( abc802 ) |
| 1746 | 1746 | { |
| 1747 | | memory_set_opbase_handler(0, abc802_opbase_handler); |
| 1747 | memory_set_direct_update_handler(cpu_get_address_space(machine->cpu[0], ADDRESS_SPACE_PROGRAM), abc802_direct_update_handler); |
| 1748 | 1748 | } |
| 1749 | 1749 | |
| 1750 | 1750 | static DRIVER_INIT( abc806 ) |
| 1751 | 1751 | { |
| 1752 | | memory_set_opbase_handler(0, abc806_opbase_handler); |
| 1752 | memory_set_direct_update_handler(cpu_get_address_space(machine->cpu[0], ADDRESS_SPACE_PROGRAM), abc806_direct_update_handler); |
| 1753 | 1753 | } |
| 1754 | 1754 | |
| 1755 | 1755 | /* System Drivers */ |