| Previous | 15994 Revisions | Next |
| r3343 Sunday 28th September, 2008 at 15:37:16 UTC by Wilbert Pol |
|---|
| Converted the z80pio implementation into a device. |
| [src/emu/machine] | z80pio.c z80pio.h |
| [src/mess/drivers] | abc80.c bbcbc.c einstein.c kc.c kramermc.c mbee.c mpf1.c super80.c |
| [src/mess/includes] | kc.h kramermc.h mbee.h |
| [src/mess/machine] | kc.c kramermc.c mbee.c |
| r3342 | r3343 | |
|---|---|---|
| 58 | 58 | UINT8 vector[2]; /* interrupt vector */ |
| 59 | 59 | void (*intr)(running_machine *, int which); /* interrupt callbacks */ |
| 60 | 60 | void (*rdyr[2])(int data); /* RDY active callback */ |
| 61 | read8_machine_func port_read[2]; /* port read callbacks */ | |
| 62 | write8_machine_func port_write[2]; /* port write callbacks */ | |
| 61 | read8_device_func port_read[2]; /* port read callbacks */ | |
| 62 | write8_device_func port_write[2]; /* port write callbacks */ | |
| 63 | 63 | UINT8 mode[2]; /* mode 00=in,01=out,02=i/o,03=bit*/ |
| 64 | 64 | UINT8 enable[2]; /* interrupt enable */ |
| 65 | 65 | UINT8 mask[2]; /* mask folowers */ |
| r3342 | r3343 | |
| 70 | 70 | UINT8 strobe[2]; /* strobe inputs */ |
| 71 | 71 | UINT8 int_state[2]; /* interrupt status (daisy chain) */ |
| 72 | 72 | }; |
| 73 | typedef struct _z80pio z80pio; | |
| 73 | typedef struct _z80pio z80pio_t; | |
| 74 | 74 | |
| 75 | 75 | |
| 76 | ||
| 77 | 76 | /*************************************************************************** |
| 78 | | |
| 77 | | |
| 79 | 78 | ***************************************************************************/ |
| 80 | 79 | |
| 81 | static z80pio pios[MAX_PIO]; | |
| 80 | INLINE z80pio_t *get_safe_token(const device_config *device) | |
| 81 | { | |
| 82 | assert(device != NULL); | |
| 83 | assert(device->token != NULL); | |
| 84 | assert(device->type == Z80PIO); | |
| 85 | return (z80pio_t *)device->token; | |
| 86 | } | |
| 82 | 87 | |
| 83 | 88 | |
| 84 | ||
| 85 | 89 | /*************************************************************************** |
| 86 | 90 | INTERNAL STATE MANAGEMENT |
| 87 | 91 | ***************************************************************************/ |
| 88 | 92 | |
| 89 | ||
| 93 | INLINE void set_rdy(const device_config *device, int ch, int state) | |
| 90 | 94 | { |
| 95 | z80pio_t *z80pio = get_safe_token( device ); | |
| 91 | 96 | /* set state */ |
| 92 | pio->rdy[ch] = state; | |
| 97 | z80pio->rdy[ch] = state; | |
| 93 | 98 | |
| 94 | 99 | /* call callback with state */ |
| 95 | if (pio->rdyr[ch]) | |
| 96 | (*pio->rdyr[ch])(pio->rdy[ch]); | |
| 100 | if (z80pio->rdyr[ch]) | |
| 101 | z80pio->rdyr[ch](z80pio->rdy[ch]); | |
| 97 | 102 | } |
| 98 | 103 | |
| 99 | 104 | |
| 100 | ||
| 105 | INLINE void interrupt_check(const device_ | |
| 101 | 106 | { |
| 102 | z80pio *pio = | |
| 107 | z80pio_t *z80pio = get_safe_token( dev | |
| 103 | 108 | |
| 104 | 109 | /* if we have a callback, update it with the current state */ |
| 105 | if (pio->intr) | |
| 106 | (*pio->intr)(machine, (z80pio_irq_state(which) & Z80_DAISY_INT) ? ASSERT_LINE : CLEAR_LINE); | |
| 110 | if (z80pio->intr) | |
| 111 | z80pio->intr(device->machine, (z80pio_irq_state(device) & Z80_DAISY_INT) ? ASSERT_LINE : CLEAR_LINE); | |
| 107 | 112 | } |
| 108 | 113 | |
| 109 | 114 | |
| 110 | static void update_irq_state( | |
| 115 | static void update_irq_state(const devi | |
| 111 | 116 | { |
| 112 | int old_state = pio->int_state[ch]; | |
| 117 | z80pio_t *z80pio = get_safe_token( device ); | |
| 118 | int old_state = z80pio->int_state[ch]; | |
| 113 | 119 | int irq = 0; |
| 114 | 120 | int data; |
| 115 | if (pio->mode[ch] == 0x13 || (pio->enable[ch] & PIO_INT_MASK)) return; | |
| 121 | if (z80pio->mode[ch] == 0x13 || (z80pio->enable[ch] & PIO_INT_MASK)) return; | |
| 116 | 122 | |
| 117 | 123 | /* only check if interrupts are enabled */ |
| 118 | if (pio->enable[ch] & PIO_INT_ENABLE) | |
| 124 | if (z80pio->enable[ch] & PIO_INT_ENABLE) | |
| 119 | 125 | { |
| 120 | 126 | /* in mode 3, interrupts are tricky */ |
| 121 | if (pio->mode[ch] == PIO_MODE3) | |
| 127 | if (z80pio->mode[ch] == PIO_MODE3) | |
| 122 | 128 | { |
| 123 | 129 | /* fetch input data (ignore output lines) */ |
| 124 | data = pio->in[ch] & pio->dir[ch]; | |
| 130 | data = z80pio->in[ch] & z80pio->dir[ch]; | |
| 125 | 131 | |
| 126 | 132 | /* keep only relevant bits */ |
| 127 | data &= ~pio->mask[ch]; | |
| 133 | data &= ~z80pio->mask[ch]; | |
| 128 | 134 | |
| 129 | 135 | /* if active low, invert the bits */ |
| 130 | if (!(pio->enable[ch] & PIO_INT_HIGH)) | |
| 131 | data ^= pio->mask[ch]; | |
| 136 | if (!(z80pio->enable[ch] & PIO_INT_HIGH)) | |
| 137 | data ^= z80pio->mask[ch]; | |
| 132 | 138 | |
| 133 | 139 | /* if AND logic, interrupt if all bits are set */ |
| 134 | if (pio->enable[ch] & PIO_INT_AND) | |
| 135 | irq = (data == pio->mask[ch]); | |
| 140 | if (z80pio->enable[ch] & PIO_INT_AND) | |
| 141 | irq = (data == z80pio->mask[ch]); | |
| 136 | 142 | |
| 137 | 143 | /* otherwise, interrupt if at least one bit is set */ |
| 138 | 144 | else |
| 139 | 145 | irq = (data != 0); |
| 140 | 146 | |
| 141 | 147 | /* if portB, portA mode 2 check */ |
| 142 | if (ch && (pio->mode[0] == PIO_MODE2)) | |
| 148 | if (ch && (z80pio->mode[0] == PIO_MODE2)) | |
| 143 | 149 | { |
| 144 | if (pio->rdy[ch] == 0) | |
| 150 | if (z80pio->rdy[ch] == 0) | |
| 145 | 151 | irq = 1; |
| 146 | 152 | } |
| 147 | 153 | } |
| 148 | 154 | |
| 149 | 155 | /* otherwise, just interrupt when ready is cleared */ |
| 150 | 156 | else |
| 151 | irq = (pio->rdy[ch] == 0); | |
| 157 | irq = (z80pio->rdy[ch] == 0); | |
| 152 | 158 | } |
| 153 | 159 | |
| 154 | 160 | if (irq) |
| 155 | pio->int_state[ch] |= Z80_DAISY_INT; | |
| 161 | z80pio->int_state[ch] |= Z80_DAISY_INT; | |
| 156 | 162 | else |
| 157 | pio->int_state[ch] &= ~Z80_DAISY_INT; | |
| 163 | z80pio->int_state[ch] &= ~Z80_DAISY_INT; | |
| 158 | 164 | |
| 159 | if (old_state != pio->int_state[ch]) | |
| 160 | interrupt_check(machine, pio - pios); | |
| 165 | if (old_state != z80pio->int_state[ch]) | |
| 166 | interrupt_check(device); | |
| 161 | 167 | } |
| 162 | 168 | |
| 163 | 169 | |
| 164 | 170 | |
| 165 | 171 | /*************************************************************************** |
| 166 | | |
| 172 | CON | |
| 167 | 173 | ***************************************************************************/ |
| 168 | 174 | |
| 169 | ||
| 175 | WRITE | |
| 170 | 176 | { |
| 171 | z80pio *pio = | |
| 177 | z80pio_t *z80pio = get_safe_token( dev | |
| 172 | 178 | |
| 173 | assert(which < MAX_PIO); | |
| 179 | /* There are only 2 channels */ | |
| 180 | offset &= 0x01; | |
| 174 | 181 | |
| 175 | memset(pio, 0, sizeof(*pio)); | |
| 176 | ||
| 177 | pio->intr = intf->intr; | |
| 178 | pio->port_read[0] = intf->portAread; | |
| 179 | pio->port_read[1] = intf->portBread; | |
| 180 | pio->port_write[0] = intf->portAwrite; | |
| 181 | pio->port_write[1] = intf->portBwrite; | |
| 182 | pio->rdyr[0] = intf->rdyA; | |
| 183 | pio->rdyr[1] = intf->rdyB; | |
| 184 | z80pio_reset(which); | |
| 185 | ||
| 186 | state_save_register_item_array("z80pio", which, pio->vector); | |
| 187 | state_save_register_item_array("z80pio", which, pio->mode); | |
| 188 | state_save_register_item_array("z80pio", which, pio->enable); | |
| 189 | state_save_register_item_array("z80pio", which, pio->mask); | |
| 190 | state_save_register_item_array("z80pio", which, pio->dir); | |
| 191 | state_save_register_item_array("z80pio", which, pio->rdy); | |
| 192 | state_save_register_item_array("z80pio", which, pio->in); | |
| 193 | state_save_register_item_array("z80pio", which, pio->out); | |
| 194 | state_save_register_item_array("z80pio", which, pio->strobe); | |
| 195 | state_save_register_item_array("z80pio", which, pio->int_state); | |
| 196 | } | |
| 197 | ||
| 198 | ||
| 199 | void z80pio_reset(int which) | |
| 200 | { | |
| 201 | z80pio *pio = pios + which; | |
| 202 | int i; | |
| 203 | ||
| 204 | for (i = 0; i < 2; i++) | |
| 205 | { | |
| 206 | pio->mask[i] = 0xff; /* mask all on */ | |
| 207 | pio->enable[i] = 0x00; /* disable */ | |
| 208 | pio->mode[i] = 0x01; /* mode input */ | |
| 209 | pio->dir[i] = 0x01; /* dir input */ | |
| 210 | set_rdy(pio, i, 0); /* RDY = low */ | |
| 211 | pio->out[i] = 0x00; /* outdata = 0 */ | |
| 212 | pio->int_state[i] = 0; | |
| 213 | pio->strobe[i] = 0; | |
| 214 | } | |
| 215 | interrupt_check(Machine, which); | |
| 216 | } | |
| 217 | ||
| 218 | ||
| 219 | ||
| 220 | /*************************************************************************** | |
| 221 | CONTROL REGISTER READ/WRITE | |
| 222 | ***************************************************************************/ | |
| 223 | ||
| 224 | void z80pio_c_w(running_machine *machine, int which, int ch, UINT8 data) | |
| 225 | { | |
| 226 | z80pio *pio = pios + which; | |
| 227 | ||
| 228 | 182 | /* load direction phase ? */ |
| 229 | if (pio->mode[ | |
| 183 | if (z80pio->mode[offset] == 0x13) | |
| 230 | 184 | { |
| 231 | VPRINTF(("PIO-%c Bits %02x\n", 'A' + ch, data)); | |
| 232 | pio->dir[ch] = data; | |
| 233 | pio->mode[ch] = 0x03; | |
| 185 | VPRINTF(("PIO-%c Bits %02x\n", 'A' + offset, data)); | |
| 186 | z80pio->dir[offset] = data; | |
| 187 | z80pio->mode[offset] = 0x03; | |
| 234 | 188 | return; |
| 235 | 189 | } |
| 236 | 190 | |
| 237 | 191 | /* load mask folows phase ? */ |
| 238 | if (pio->enable[ | |
| 192 | if (z80pio->enable[offset] & PIO_INT_MASK) | |
| 239 | 193 | { |
| 240 | 194 | /* load mask folows */ |
| 241 | pio->mask[ch] = data; | |
| 242 | pio->enable[ch] &= ~PIO_INT_MASK; | |
| 243 | VPRINTF(("PIO-%c interrupt mask %02x\n",'A'+ch,data )); | |
| 195 | z80pio->mask[offset] = data; | |
| 196 | z80pio->enable[offset] &= ~PIO_INT_MASK; | |
| 197 | VPRINTF(("PIO-%c interrupt mask %02x\n",'A'+offset,data )); | |
| 244 | 198 | return; |
| 245 | 199 | } |
| 246 | 200 | |
| 247 | 201 | switch (data & 0x0f) |
| 248 | 202 | { |
| 249 | 203 | case PIO_OP_MODE: /* mode select 0=out,1=in,2=i/o,3=bit */ |
| 250 | pio->mode[ch] = (data >> 6); | |
| 251 | VPRINTF(("PIO-%c Mode %x\n", 'A' + ch, pio->mode[ch])); | |
| 252 | if (pio->mode[ch] == 0x03) | |
| 253 | pio->mode[ch] = 0x13; | |
| 204 | z80pio->mode[offset] = (data >> 6); | |
| 205 | VPRINTF(("PIO-%c Mode %x\n", 'A' + offset, z80pio->mode[offset])); | |
| 206 | if (z80pio->mode[offset] == 0x03) | |
| 207 | z80pio->mode[offset] = 0x13; | |
| 254 | 208 | return; |
| 255 | 209 | |
| 256 | 210 | case PIO_OP_INTC: /* interrupt control */ |
| 257 | pio->enable[ch] = data & 0xf0; | |
| 258 | pio->mask[ch] = 0x00; | |
| 211 | z80pio->enable[offset] = data & 0xf0; | |
| 212 | z80pio->mask[offset] = 0x00; | |
| 259 | 213 | /* when interrupt enable , set vector request flag */ |
| 260 | VPRINTF(("PIO-%c Controll %02x\n", 'A' + | |
| 214 | VPRINTF(("PIO-%c Controll %02x\n", 'A' + offset, data)); | |
| 261 | 215 | break; |
| 262 | 216 | |
| 263 | 217 | case PIO_OP_INTE: /* interrupt enable controll */ |
| 264 | pio->enable[ch] &= ~PIO_INT_ENABLE; | |
| 265 | pio->enable[ch] |= (data & PIO_INT_ENABLE); | |
| 266 | VPRINTF(("PIO-%c enable %02x\n", 'A' + ch, data & 0x80)); | |
| 218 | z80pio->enable[offset] &= ~PIO_INT_ENABLE; | |
| 219 | z80pio->enable[offset] |= (data & PIO_INT_ENABLE); | |
| 220 | VPRINTF(("PIO-%c enable %02x\n", 'A' + offset, data & 0x80)); | |
| 267 | 221 | break; |
| 268 | 222 | |
| 269 | 223 | default: |
| 270 | 224 | if (!(data & 1)) |
| 271 | 225 | { |
| 272 | pio->vector[ch] = data; | |
| 273 | VPRINTF(("PIO-%c vector %02x\n", 'A' + ch, data)); | |
| 226 | z80pio->vector[offset] = data; | |
| 227 | VPRINTF(("PIO-%c vector %02x\n", 'A' + offset, data)); | |
| 274 | 228 | } |
| 275 | 229 | else |
| 276 | VPRINTF(("PIO-%c illegal command %02x\n", 'A' + | |
| 230 | VPRINTF(("PIO-%c illegal command %02x\n", 'A' + offset, data)); | |
| 277 | 231 | break; |
| 278 | 232 | } |
| 279 | 233 | |
| 280 | 234 | /* interrupt check */ |
| 281 | update_irq_state( | |
| 235 | update_irq_state(dev | |
| 282 | 236 | } |
| 283 | 237 | |
| 284 | 238 | |
| 285 | ||
| 239 | READ8_DEVICE_HANDLER( z80pio_c_r | |
| 286 | 240 | { |
| 287 | VPRINTF(("PIO-%c controll read\n", 'A' + ch )); | |
| 241 | /* There are only 2 channels */ | |
| 242 | offset &= 0x01; | |
| 243 | ||
| 244 | VPRINTF(("PIO-%c controll read\n", 'A' + offset )); | |
| 288 | 245 | return 0; |
| 289 | 246 | } |
| 290 | 247 | |
| r3342 | r3343 | |
| 294 | 251 | DATA REGISTER READ/WRITE |
| 295 | 252 | ***************************************************************************/ |
| 296 | 253 | |
| 297 | ||
| 254 | WRITE8_DEVICE_HANDLER( z80pio_d_w | |
| 298 | 255 | { |
| 299 | z80pio *pio = | |
| 256 | z80pio_t *z80pio = get_safe_token( dev | |
| 300 | 257 | |
| 301 | pio->out[ch] = data; /* latch out data */ | |
| 302 | if(pio->port_write[ch]) | |
| 303 | pio->port_write[ch](machine, 0, data); | |
| 258 | /* There are only 2 channels */ | |
| 259 | offset &= 0x01; | |
| 304 | 260 | |
| 305 | switch (pio->mode[ch]) | |
| 261 | z80pio->out[offset] = data; /* latch out data */ | |
| 262 | if(z80pio->port_write[offset]) | |
| 263 | z80pio->port_write[offset](device, 0, data); | |
| 264 | ||
| 265 | switch (z80pio->mode[offset]) | |
| 306 | 266 | { |
| 307 | 267 | case PIO_MODE0: /* mode 0 output */ |
| 308 | 268 | case PIO_MODE2: /* mode 2 i/o */ |
| 309 | set_rdy(pio, ch, 1); /* ready = H */ | |
| 310 | update_irq_state(machine, pio, ch); | |
| 269 | set_rdy(device, offset, 1); /* ready = H */ | |
| 270 | update_irq_state(device, offset); | |
| 311 | 271 | return; |
| 312 | 272 | |
| 313 | 273 | case PIO_MODE1: /* mode 1 input */ |
| r3342 | r3343 | |
| 315 | 275 | return; |
| 316 | 276 | |
| 317 | 277 | default: |
| 318 | VPRINTF(("PIO-%c data write,bad mode\n",'A'+ | |
| 278 | VPRINTF(("PIO-%c data write,bad mode\n",'A'+offset )); | |
| 319 | 279 | } |
| 320 | 280 | } |
| 321 | 281 | |
| 322 | 282 | |
| 323 | ||
| 283 | READ8_DEVICE_HANDLER( z80pio_d_r | |
| 324 | 284 | { |
| 325 | z80pio *pio = | |
| 285 | z80pio_t *z80pio = get_safe_token( dev | |
| 326 | 286 | |
| 327 | switch (pio->mode[ch]) | |
| 287 | /* There are only 2 channels */ | |
| 288 | offset &= 0x01; | |
| 289 | ||
| 290 | switch (z80pio->mode[offset]) | |
| 328 | 291 | { |
| 329 | 292 | case PIO_MODE0: /* mode 0 output */ |
| 330 | return pio->out[ | |
| 293 | return z80pio->out[offset]; | |
| 331 | 294 | |
| 332 | 295 | case PIO_MODE1: /* mode 1 input */ |
| 333 | set_rdy(pio, ch, 1); /* ready = H */ | |
| 334 | if(pio->port_read[ch]) | |
| 335 | pio->in[ch] = pio->port_read[ch](machine, 0); | |
| 336 | update_irq_state(machine, pio, ch); | |
| 337 | return pio->in[ch]; | |
| 296 | set_rdy(device, offset, 1); /* ready = H */ | |
| 297 | if(z80pio->port_read[offset]) | |
| 298 | z80pio->in[offset] = z80pio->port_read[offset](device, 0); | |
| 299 | update_irq_state(device, offset); | |
| 300 | return z80pio->in[offset]; | |
| 338 | 301 | |
| 339 | 302 | case PIO_MODE2: /* mode 2 i/o */ |
| 340 | if (ch) VPRINTF(("PIO-B mode 2 \n")); | |
| 341 | set_rdy(pio, 1, 1); /* brdy = H */ | |
| 342 | if(pio->port_read[ch]) | |
| 343 | pio->in[ch] = pio->port_read[ch](machine, 0); | |
| 344 | update_irq_state(machine, pio, ch); | |
| 345 | return pio->in[ch]; | |
| 303 | if (offset) VPRINTF(("PIO-B mode 2 \n")); | |
| 304 | set_rdy(device, 1, 1); /* brdy = H */ | |
| 305 | if(z80pio->port_read[offset]) | |
| 306 | z80pio->in[offset] = z80pio->port_read[offset](device, 0); | |
| 307 | update_irq_state(device, offset); | |
| 308 | return z80pio->in[offset]; | |
| 346 | 309 | |
| 347 | 310 | case PIO_MODE3: /* mode 3 bit */ |
| 348 | if(pio->port_read[ch]) | |
| 349 | pio->in[ch] = pio->port_read[ch](machine, 0); | |
| 350 | return (pio->in[ch] & pio->dir[ch]) | (pio->out[ch] & ~pio->dir[ch]); | |
| 311 | if(z80pio->port_read[offset]) | |
| 312 | z80pio->in[offset] = z80pio->port_read[offset](device, 0); | |
| 313 | return (z80pio->in[offset] & z80pio->dir[offset]) | (z80pio->out[offset] & ~z80pio->dir[offset]); | |
| 351 | 314 | } |
| 352 | VPRINTF(("PIO-%c data read,bad mode\n",'A'+ | |
| 315 | VPRINTF(("PIO-%c data read,bad mode\n",'A'+offset )); | |
| 353 | 316 | return 0; |
| 354 | 317 | } |
| 355 | 318 | |
| r3342 | r3343 | |
| 359 | 322 | PORT I/O |
| 360 | 323 | ***************************************************************************/ |
| 361 | 324 | |
| 362 | ||
| 325 | WRITE8_DEVICE_HANDLER( z80pio_p_w | |
| 363 | 326 | { |
| 364 | z80pio *pio = | |
| 327 | z80pio_t *z80pio = get_safe_token( dev | |
| 365 | 328 | |
| 366 | pio->in[ch] = data; | |
| 367 | switch (pio->mode[ch]) | |
| 329 | /* There are only 2 channels */ | |
| 330 | offset &= 0x01; | |
| 331 | ||
| 332 | z80pio->in[offset] = data; | |
| 333 | switch (z80pio->mode[offset]) | |
| 368 | 334 | { |
| 369 | 335 | case PIO_MODE0: |
| 370 | VPRINTF(("PIO-%c OUTPUT mode and data write\n",'A'+ | |
| 336 | VPRINTF(("PIO-%c OUTPUT mode and data write\n",'A'+offset )); | |
| 371 | 337 | break; |
| 372 | 338 | |
| 373 | 339 | case PIO_MODE2: /* only port A */ |
| 374 | | |
| 340 | offset = 1; /* handshake and IRQ is use portB */ | |
| 375 | 341 | |
| 376 | 342 | case PIO_MODE1: |
| 377 | set_rdy(pio, ch, 0); | |
| 378 | update_irq_state(machine, pio, ch); | |
| 343 | set_rdy(device, offset, 0); | |
| 344 | update_irq_state(device, offset); | |
| 379 | 345 | break; |
| 380 | 346 | |
| 381 | 347 | case PIO_MODE3: |
| 382 | 348 | /* irq check */ |
| 383 | update_irq_state( | |
| 349 | update_irq_state(dev | |
| 384 | 350 | break; |
| 385 | 351 | } |
| 386 | 352 | } |
| 387 | 353 | |
| 388 | 354 | |
| 389 | ||
| 355 | READ8_DEVICE_HANDLER( z80pio_p_r | |
| 390 | 356 | { |
| 391 | z80pio *pio = | |
| 357 | z80pio_t *z80pio = get_safe_token( dev | |
| 392 | 358 | |
| 393 | switch (pio->mode[ch]) | |
| 359 | /* There are only 2 channels */ | |
| 360 | offset &= 0x01; | |
| 361 | ||
| 362 | switch (z80pio->mode[offset]) | |
| 394 | 363 | { |
| 395 | 364 | case PIO_MODE2: /* port A only */ |
| 396 | 365 | case PIO_MODE0: |
| 397 | set_rdy(pio, ch, 0); | |
| 398 | update_irq_state(machine, pio, ch); | |
| 366 | set_rdy(device, offset, 0); | |
| 367 | update_irq_state(device, offset); | |
| 399 | 368 | break; |
| 400 | 369 | |
| 401 | 370 | case PIO_MODE1: |
| 402 | VPRINTF(("PIO-%c INPUT mode and data read\n",'A'+ | |
| 371 | VPRINTF(("PIO-%c INPUT mode and data read\n",'A'+offset )); | |
| 403 | 372 | break; |
| 404 | 373 | |
| 405 | 374 | case PIO_MODE3: |
| 406 | return (pio->in[ | |
| 375 | return (z80pio->in[offset] & z80pio->dir[offset]) | (z80pio->out[offset] & ~z80pio->dir[offset]); | |
| 407 | 376 | } |
| 408 | return pio->out[ | |
| 377 | return z80pio->out[offset]; | |
| 409 | 378 | } |
| 410 | 379 | |
| 411 | 380 | |
| 412 | WRITE8_HANDLER( z80pioA_0_p_w ) { z80pio_p_w(machine, 0, 0, data); } | |
| 413 | WRITE8_HANDLER( z80pioB_0_p_w ) { z80pio_p_w(machine, 0, 1, data); } | |
| 414 | READ8_HANDLER( z80pioA_0_p_r ) { return z80pio_p_r(machine, 0, 0); } | |
| 415 | READ8_HANDLER( z80pioB_0_p_r ) { return z80pio_p_r(machine, 0, 1); } | |
| 416 | ||
| 417 | WRITE8_HANDLER( z80pioA_1_p_w ) { z80pio_p_w(machine, 1, 0, data); } | |
| 418 | WRITE8_HANDLER( z80pioB_1_p_w ) { z80pio_p_w(machine, 1, 1, data); } | |
| 419 | READ8_HANDLER( z80pioA_1_p_r ) { return z80pio_p_r(machine, 1, 0); } | |
| 420 | READ8_HANDLER( z80pioB_1_p_r ) { return z80pio_p_r(machine, 1, 1); } | |
| 421 | ||
| 422 | ||
| 423 | ||
| 424 | 381 | /*************************************************************************** |
| 425 | 382 | STROBE STATE MANAGEMENT |
| 426 | 383 | ***************************************************************************/ |
| 427 | 384 | |
| 428 | static void z80pio_update_strobe( | |
| 385 | static void z80pio_update_strobe(const device_ | |
| 429 | 386 | { |
| 430 | z80pio *pio = | |
| 387 | z80pio_t *z80pio = get_safe_token( dev | |
| 431 | 388 | |
| 432 | switch (pio->mode[ch]) | |
| 389 | switch (z80pio->mode[ch]) | |
| 433 | 390 | { |
| 434 | 391 | /* output mode: a positive edge is used by peripheral to acknowledge |
| 435 | 392 | the receipt of data */ |
| r3342 | r3343 | |
| 439 | 396 | state = state & 0x01; |
| 440 | 397 | |
| 441 | 398 | /* strobe changed state? */ |
| 442 | if ((pio->strobe[ch] ^ state) != 0) | |
| 399 | if ((z80pio->strobe[ch] ^ state) != 0) | |
| 443 | 400 | { |
| 444 | 401 | /* yes */ |
| 445 | 402 | if (state != 0) |
| r3342 | r3343 | |
| 448 | 405 | VPRINTF(("PIO-%c positive strobe\n",'A' + ch)); |
| 449 | 406 | |
| 450 | 407 | /* ready is now inactive */ |
| 451 | set_rdy( | |
| 408 | set_rdy(device, ch, 0); | |
| 452 | 409 | |
| 453 | 410 | /* int enabled? */ |
| 454 | if (pio->enable[ch] & PIO_INT_ENABLE) | |
| 411 | if (z80pio->enable[ch] & PIO_INT_ENABLE) | |
| 455 | 412 | { |
| 456 | 413 | /* trigger an int request */ |
| 457 | pio->int_state[ch] |= Z80_DAISY_INT; | |
| 414 | z80pio->int_state[ch] |= Z80_DAISY_INT; | |
| 458 | 415 | } |
| 459 | 416 | } |
| 460 | 417 | } |
| 461 | 418 | |
| 462 | 419 | /* store strobe state */ |
| 463 | pio->strobe[ch] = state; | |
| 420 | z80pio->strobe[ch] = state; | |
| 464 | 421 | |
| 465 | 422 | /* check interrupt */ |
| 466 | interrupt_check( | |
| 423 | interrupt_check(d | |
| 467 | 424 | } |
| 468 | 425 | break; |
| 469 | 426 | |
| r3342 | r3343 | |
| 476 | 433 | } |
| 477 | 434 | |
| 478 | 435 | |
| 479 | void z80pio_astb_w(running_machine *machine, int which, int state) { z80pio_update_strobe(machine, which, 0, state); } | |
| 480 | void z80pio_bstb_w(running_machine *machine, int which, int state) { z80pio_update_strobe(machine, which, 1, state); } | |
| 436 | void z80pio_astb_w(const device_config *device, int state) { z80pio_update_strobe(device, 0, state); } | |
| 437 | void z80pio_bstb_w(const device_config *device, int state) { z80pio_update_strobe(device, 1, state); } | |
| 481 | 438 | |
| 482 | 439 | |
| 483 | 440 | |
| r3342 | r3343 | |
| 485 | 442 | DAISY CHAIN INTERFACE |
| 486 | 443 | ***************************************************************************/ |
| 487 | 444 | |
| 488 | int z80pio_irq_state( | |
| 445 | int z80pio_irq_state(const device_config *device) | |
| 489 | 446 | { |
| 490 | z80pio *pio = | |
| 447 | z80pio_t *z80pio = get_safe_token( dev | |
| 491 | 448 | int state = 0; |
| 492 | 449 | int ch; |
| 493 | 450 | |
| r3342 | r3343 | |
| 495 | 452 | for (ch = 0; ch < 2; ch++) |
| 496 | 453 | { |
| 497 | 454 | /* if we're servicing a request, don't indicate more interrupts */ |
| 498 | if (pio->int_state[ch] & Z80_DAISY_IEO) | |
| 455 | if (z80pio->int_state[ch] & Z80_DAISY_IEO) | |
| 499 | 456 | { |
| 500 | 457 | state |= Z80_DAISY_IEO; |
| 501 | 458 | break; |
| 502 | 459 | } |
| 503 | state |= pio->int_state[ch]; | |
| 460 | state |= z80pio->int_state[ch]; | |
| 504 | 461 | } |
| 505 | 462 | return state; |
| 506 | 463 | } |
| 507 | 464 | |
| 508 | 465 | |
| 509 | int z80pio_irq_ack( | |
| 466 | int z80pio_irq_ack(const device_config *device) | |
| 510 | 467 | { |
| 511 | z80pio *pio = | |
| 468 | z80pio_t *z80pio = get_safe_token( dev | |
| 512 | 469 | int ch; |
| 513 | 470 | |
| 514 | 471 | /* loop over all channels */ |
| 515 | 472 | for (ch = 0; ch < 2; ch++) |
| 516 | 473 | |
| 517 | 474 | /* find the first channel with an interrupt requested */ |
| 518 | if (pio->int_state[ch] & Z80_DAISY_INT) | |
| 475 | if (z80pio->int_state[ch] & Z80_DAISY_INT) | |
| 519 | 476 | { |
| 520 | 477 | /* clear interrupt, switch to the IEO state, and update the IRQs */ |
| 521 | pio->int_state[ch] = Z80_DAISY_IEO; | |
| 522 | interrupt_check(Machine, which); | |
| 523 | return pio->vector[ch]; | |
| 478 | z80pio->int_state[ch] = Z80_DAISY_IEO; | |
| 479 | interrupt_check(device); | |
| 480 | return z80pio->vector[ch]; | |
| 524 | 481 | } |
| 525 | 482 | |
| 526 | 483 | VPRINTF(("z80pio_irq_ack: failed to find an interrupt to ack!")); |
| 527 | return pio->vector[0]; | |
| 484 | return z80pio->vector[0]; | |
| 528 | 485 | } |
| 529 | 486 | |
| 530 | 487 | |
| 531 | void z80pio_irq_reti( | |
| 488 | void z80pio_irq_reti(const device_config *device) | |
| 532 | 489 | { |
| 533 | z80pio *pio = | |
| 490 | z80pio_t *z80pio = get_safe_token( dev | |
| 534 | 491 | int ch; |
| 535 | 492 | |
| 536 | 493 | /* loop over all channels */ |
| 537 | 494 | for (ch = 0; ch < 2; ch++) |
| 538 | 495 | |
| 539 | 496 | /* find the first channel with an IEO pending */ |
| 540 | if (pio->int_state[ch] & Z80_DAISY_IEO) | |
| 497 | if (z80pio->int_state[ch] & Z80_DAISY_IEO) | |
| 541 | 498 | { |
| 542 | 499 | /* clear the IEO state and update the IRQs */ |
| 543 | pio->int_state[ch] &= ~Z80_DAISY_IEO; | |
| 544 | interrupt_check(Machine, which); | |
| 500 | z80pio->int_state[ch] &= ~Z80_DAISY_IEO; | |
| 501 | interrupt_check(device); | |
| 545 | 502 | return; |
| 546 | 503 | } |
| 547 | 504 | |
| 548 | 505 | VPRINTF(("z80pio_irq_reti: failed to find an interrupt to clear IEO on!")); |
| 549 | 506 | } |
| 550 | 507 | |
| 508 | ||
| 551 | 509 | /*************************************************************************** |
| 552 | 510 | READ/WRITE HANDLERS |
| 553 | 511 | ***************************************************************************/ |
| 554 | READ8_HANDLER(z80pio | |
| 512 | READ8_DEVICE_HANDLER(z80pio | |
| 555 | 513 | { |
| 556 | return (offset & 2) ? z80pio_c_r( | |
| 514 | return (offset & 2) ? z80pio_c_r(device, offset & 1) : z80pio_d_r(dev | |
| 557 | 515 | } |
| 558 | 516 | |
| 559 | WRITE8_HANDLER(z80pio | |
| 517 | WRITE8_DEVICE_HANDLER(z80pio | |
| 560 | 518 | { |
| 561 | 519 | if (offset & 2) |
| 562 | z80pio_c_w( | |
| 520 | z80pio_c_w(dev | |
| 563 | 521 | else |
| 564 | z80pio_d_w( | |
| 522 | z80pio_d_w(dev | |
| 565 | 523 | } |
| 566 | 524 | |
| 567 | READ8_HANDLER(z80pio_1_r) | |
| 525 | ||
| 526 | static DEVICE_START( z80pio ) | |
| 568 | 527 | { |
| 569 | return (offset & 2) ? z80pio_c_r(1, offset & 1) : z80pio_d_r(machine, 1, offset & 1); | |
| 528 | const z80pio_interface *intf = device->static_config; | |
| 529 | z80pio_t *z80pio = get_safe_token( device ); | |
| 530 | char unique_tag[30]; | |
| 531 | ||
| 532 | z80pio->intr = intf->intr; | |
| 533 | z80pio->port_read[0] = intf->portAread; | |
| 534 | z80pio->port_read[1] = intf->portBread; | |
| 535 | z80pio->port_write[0] = intf->portAwrite; | |
| 536 | z80pio->port_write[1] = intf->portBwrite; | |
| 537 | z80pio->rdyr[0] = intf->rdyA; | |
| 538 | z80pio->rdyr[1] = intf->rdyB; | |
| 539 | ||
| 540 | /* register for save states */ | |
| 541 | state_save_combine_module_and_tag(unique_tag, "z80pio", device->tag); | |
| 542 | ||
| 543 | state_save_register_item_array(unique_tag, 0, z80pio->vector); | |
| 544 | state_save_register_item_array(unique_tag, 0, z80pio->mode); | |
| 545 | state_save_register_item_array(unique_tag, 0, z80pio->enable); | |
| 546 | state_save_register_item_array(unique_tag, 0, z80pio->mask); | |
| 547 | state_save_register_item_array(unique_tag, 0, z80pio->dir); | |
| 548 | state_save_register_item_array(unique_tag, 0, z80pio->rdy); | |
| 549 | state_save_register_item_array(unique_tag, 0, z80pio->in); | |
| 550 | state_save_register_item_array(unique_tag, 0, z80pio->out); | |
| 551 | state_save_register_item_array(unique_tag, 0, z80pio->strobe); | |
| 552 | state_save_register_item_array(unique_tag, 0, z80pio->int_state); | |
| 553 | ||
| 554 | return DEVICE_START_OK; | |
| 570 | 555 | } |
| 571 | 556 | |
| 572 | WRITE8_HANDLER(z80pio_1_w) | |
| 557 | ||
| 558 | void z80pio_reset( const device_config *device ) | |
| 573 | 559 | { |
| 574 | if (offset & 2) | |
| 575 | z80pio_c_w(machine, 1, offset & 1, data); | |
| 576 | else | |
| 577 | z80pio_d_w(machine, 1, offset & 1, data); | |
| 560 | z80pio_t *z80pio = get_safe_token( device ); | |
| 561 | int i; | |
| 562 | ||
| 563 | for (i = 0; i < 2; i++) | |
| 564 | { | |
| 565 | z80pio->mask[i] = 0xff; /* mask all on */ | |
| 566 | z80pio->enable[i] = 0x00; /* disable */ | |
| 567 | z80pio->mode[i] = 0x01; /* mode input */ | |
| 568 | z80pio->dir[i] = 0x01; /* dir input */ | |
| 569 | set_rdy(device, i, 0); /* RDY = low */ | |
| 570 | z80pio->out[i] = 0x00; /* outdata = 0 */ | |
| 571 | z80pio->int_state[i] = 0; | |
| 572 | z80pio->strobe[i] = 0; | |
| 573 | } | |
| 574 | interrupt_check(device); | |
| 578 | 575 | } |
| 576 | ||
| 577 | ||
| 578 | static DEVICE_RESET( z80pio ) | |
| 579 | { | |
| 580 | z80pio_reset( device ); | |
| 581 | } | |
| 582 | ||
| 583 | ||
| 584 | static DEVICE_SET_INFO( z80pio ) | |
| 585 | { | |
| 586 | switch (state) | |
| 587 | { | |
| 588 | /* no parameters to set */ | |
| 589 | } | |
| 590 | } | |
| 591 | ||
| 592 | ||
| 593 | DEVICE_GET_INFO( z80pio ) | |
| 594 | { | |
| 595 | switch (state) | |
| 596 | { | |
| 597 | /* --- the following bits of info are returned as 64-bit signed integers --- */ | |
| 598 | case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(z80pio_t); break; | |
| 599 | case DEVINFO_INT_INLINE_CONFIG_BYTES: info->i = 0; break; | |
| 600 | case DEVINFO_INT_CLASS: info->i = DEVICE_CLASS_PERIPHERAL; break; | |
| 601 | ||
| 602 | /* --- the following bits of info are returned as pointers to data or functions --- */ | |
| 603 | case DEVINFO_FCT_SET_INFO: info->set_info = DEVICE_SET_INFO_NAME(z80pio); break; | |
| 604 | case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(z80pio);break; | |
| 605 | case DEVINFO_FCT_STOP: /* Nothing */ break; | |
| 606 | case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(z80pio);break; | |
| 607 | ||
| 608 | /* --- the following bits of info are returned as NULL-terminated strings --- */ | |
| 609 | case DEVINFO_STR_NAME: info->s = "Zilog Z80PIO"; break; | |
| 610 | case DEVINFO_STR_FAMILY: info->s = "Z80PIO"; break; | |
| 611 | case DEVINFO_STR_VERSION: info->s = "1.0"; break; | |
| 612 | case DEVINFO_STR_SOURCE_FILE: info->s = __FILE__; break; | |
| 613 | case DEVINFO_STR_CREDITS: info->s = "Copyright Nicola Salmoria and the MAME Team"; break; | |
| 614 | } | |
| 615 | } | |
| 616 |
| r3342 | r3343 | |
|---|---|---|
| 7 | 7 | |
| 8 | 8 | ***************************************************************************/ |
| 9 | 9 | |
| 10 | /*************************************************************************** | |
| 11 | CONSTANTS | |
| 12 | ***************************************************************************/ | |
| 10 | #ifndef __Z80PIO_H_ | |
| 11 | #define __Z80PIO_H_ | |
| 13 | 12 | |
| 14 | #define MAX_PIO 2 | |
| 15 | 13 | |
| 16 | ||
| 17 | ||
| 18 | 14 | /*************************************************************************** |
| 19 | 15 | TYPE DEFINITIONS |
| 20 | 16 | ***************************************************************************/ |
| r3342 | r3343 | |
| 22 | 18 | struct _z80pio_interface |
| 23 | 19 | { |
| 24 | 20 | void (*intr)(running_machine *machine, int which); /* callback when change interrupt status */ |
| 25 | read8_machine_func portAread; /* port A read callback */ | |
| 26 | read8_machine_func portBread; /* port B read callback */ | |
| 27 | write8_machine_func portAwrite; /* port A write callback */ | |
| 28 | write8_machine_func portBwrite; /* port B write callback */ | |
| 21 | read8_device_func portAread; /* port A read callback */ | |
| 22 | read8_device_func portBread; /* port B read callback */ | |
| 23 | write8_device_func portAwrite; /* port A write callback */ | |
| 24 | write8_device_func portBwrite; /* port B write callback */ | |
| 29 | 25 | void (*rdyA)(int data); /* portA ready active callback (do not support yet)*/ |
| 30 | 26 | void (*rdyB)(int data); /* portB ready active callback (do not support yet)*/ |
| 31 | 27 | }; |
| 32 | 28 | typedef struct _z80pio_interface z80pio_interface; |
| 33 | 29 | |
| 34 | 30 | |
| 35 | ||
| 36 | 31 | /*************************************************************************** |
| 37 | I | |
| 32 | DEVI | |
| 38 | 33 | ***************************************************************************/ |
| 39 | 34 | |
| 40 | void z80pio_init(int which, const z80pio_interface *intf); | |
| 41 | void z80pio_reset(int which); | |
| 35 | #define MDRV_Z80PIO_ADD(_tag, _intrf) \ | |
| 36 | MDRV_DEVICE_ADD(_tag, Z80PIO) \ | |
| 37 | MDRV_DEVICE_CONFIG(_intrf) | |
| 42 | 38 | |
| 39 | #define MDRV_Z80PIO_REMOVE(_tag) \ | |
| 40 | MDRV_DEVICE_REMOVE(_tag, Z80PIO) | |
| 43 | 41 | |
| 44 | 42 | |
| 43 | ||
| 45 | 44 | /*************************************************************************** |
| 45 | INITIALIZATION | |
| 46 | ***************************************************************************/ | |
| 47 | ||
| 48 | void z80pio_reset( const device_config *device ); | |
| 49 | ||
| 50 | ||
| 51 | /*************************************************************************** | |
| 46 | 52 | CONTROL REGISTER READ/WRITE |
| 47 | 53 | ***************************************************************************/ |
| 48 | 54 | |
| 49 | void z80pio_c_w(running_machine *machine, int which, int ch, UINT8 data); | |
| 50 | UINT8 z80pio_c_r(int which, int ch); | |
| 55 | WRITE8_DEVICE_HANDLER( z80pio_c_w ); | |
| 56 | READ8_DEVICE_HANDLER( z80pio_c_r ); | |
| 51 | 57 | |
| 52 | 58 | |
| 53 | ||
| 54 | 59 | /*************************************************************************** |
| 55 | 60 | DATA REGISTER READ/WRITE |
| 56 | 61 | ***************************************************************************/ |
| 57 | 62 | |
| 58 | void z80pio_d_w(running_machine *machine, int which, int ch, UINT8 data); | |
| 59 | UINT8 z80pio_d_r(running_machine *machine, int which, int ch); | |
| 63 | WRITE8_DEVICE_HANDLER( z80pio_d_w ); | |
| 64 | READ8_DEVICE_HANDLER( z80pio_d_r ); | |
| 60 | 65 | |
| 61 | 66 | |
| 62 | ||
| 63 | 67 | /*************************************************************************** |
| 64 | 68 | PORT I/O |
| 65 | 69 | ***************************************************************************/ |
| 66 | 70 | |
| 67 | void z80pio_p_w(running_machine *machine, int which, UINT8 ch, UINT8 data); | |
| 68 | int z80pio_p_r(running_machine *machine, int which, UINT8 ch); | |
| 71 | WRITE8_DEVICE_HANDLER( z80pio_p_w ); | |
| 72 | READ8_DEVICE_HANDLER( z80pio_p_r ); | |
| 69 | 73 | |
| 70 | WRITE8_HANDLER( z80pioA_0_p_w ); | |
| 71 | WRITE8_HANDLER( z80pioB_0_p_w ); | |
| 72 | READ8_HANDLER( z80pioA_0_p_r ); | |
| 73 | READ8_HANDLER( z80pioB_0_p_r ); | |
| 74 | WRITE8_HANDLER( z80pioA_1_p_w ); | |
| 75 | WRITE8_HANDLER( z80pioB_1_p_w ); | |
| 76 | READ8_HANDLER( z80pioA_1_p_r ); | |
| 77 | READ8_HANDLER( z80pioB_1_p_r ); | |
| 78 | 74 | |
| 79 | ||
| 80 | ||
| 81 | 75 | /*************************************************************************** |
| 82 | 76 | STROBE STATE MANAGEMENT |
| 83 | 77 | ***************************************************************************/ |
| 84 | 78 | |
| 85 | void z80pio_astb_w(running_machine *machine, int which, int state); | |
| 86 | void z80pio_bstb_w(running_machine *machine, int which, int state); | |
| 79 | void z80pio_astb_w(const device_config *device, int state); | |
| 80 | void z80pio_bstb_w(const device_config *device, int state); | |
| 87 | 81 | |
| 88 | 82 | |
| 89 | ||
| 90 | 83 | /*************************************************************************** |
| 91 | 84 | DAISY CHAIN INTERFACE |
| 92 | 85 | ***************************************************************************/ |
| 93 | 86 | |
| 94 | int z80pio_irq_state(int which); | |
| 95 | int z80pio_irq_ack(int which); | |
| 96 | void z80pio_irq_reti(int which); | |
| 87 | int z80pio_irq_state(const device_config *device); | |
| 88 | int z80pio_irq_ack(const device_config *device); | |
| 89 | void z80pio_irq_reti(const device_config *device); | |
| 97 | 90 | |
| 91 | ||
| 98 | 92 | /*************************************************************************** |
| 99 | 93 | READ/WRITE HANDLERS |
| 100 | 94 | ***************************************************************************/ |
| 101 | READ8_HANDLER(z80pio_0_r); | |
| 102 | WRITE8_HANDLER(z80pio_0_w); | |
| 103 | READ8_HANDLER(z80pio_1_r); | |
| 104 | WRITE8_HANDLER(z80pio_1_w); | |
| 95 | READ8_DEVICE_HANDLER(z80pio_r); | |
| 96 | WRITE8_DEVICE_HANDLER(z80pio_w); | |
| 97 | ||
| 98 | ||
| 99 | /* ----- device interface ----- */ | |
| 100 | ||
| 101 | #define Z80PIO DEVICE_GET_INFO_NAME(z80pio) | |
| 102 | DEVICE_GET_INFO( z80pio ); | |
| 103 | ||
| 104 | #endif |
| r3342 | r3343 | |
|---|---|---|
| 7 | 7 | #ifndef KC_H_ |
| 8 | 8 | #define KC_H_ |
| 9 | 9 | |
| 10 | #include "cpu/z80/z80daisy.h" | |
| 11 | #include "machine/z80pio.h" | |
| 10 | 12 | #include "devices/snapquik.h" |
| 11 | 13 | |
| 12 | 14 | |
| r3342 | r3343 | |
| 68 | 70 | READ8_HANDLER(kc85_ctc_r); |
| 69 | 71 | WRITE8_HANDLER(kc85_ctc_w); |
| 70 | 72 | |
| 73 | extern const z80pio_interface kc85_pio_intf; | |
| 74 | extern const struct z80_irq_daisy_chain kc85_daisy_chain[]; | |
| 71 | 75 | |
| 76 | ||
| 72 | 77 | /*** MODULE SYSTEM ***/ |
| 73 | 78 | /* read from xx80 port */ |
| 74 | 79 | READ8_HANDLER(kc85_module_r); |
| r3342 | r3343 | |
|---|---|---|
| 7 | 7 | #ifndef MBEE_H_ |
| 8 | 8 | #define MBEE_H_ |
| 9 | 9 | |
| 10 | #include "cpu/z80/z80daisy.h" | |
| 10 | 11 | |
| 11 | 12 | /*----------- defined in machine/mbee.c -----------*/ |
| 12 | 13 | |
| r3342 | r3343 | |
| 14 | 15 | MACHINE_START( mbee ); |
| 15 | 16 | |
| 16 | 17 | extern UINT8 *mbee_workram; |
| 18 | extern const struct z80_irq_daisy_chain mbee_daisy_chain[]; | |
| 17 | 19 | |
| 18 | 20 | INTERRUPT_GEN( mbee_interrupt ); |
| 19 | 21 |
| r3342 | r3343 | |
|---|---|---|
| 7 | 7 | #ifndef KRAMERMC_H_ |
| 8 | 8 | #define KRAMERMC_H_ |
| 9 | 9 | |
| 10 | #include "machine/z80pio.h" | |
| 10 | 11 | |
| 11 | 12 | /*----------- defined in machine/kramermc.c -----------*/ |
| 12 | 13 | |
| 13 | extern DRIVER_INIT( kramermc ); | |
| 14 | extern MACHINE_RESET( kramermc ); | |
| 14 | DRIVER_INIT( kramermc ); | |
| 15 | MACHINE_RESET( kramermc ); | |
| 15 | 16 | |
| 17 | const z80pio_interface kramermc_z80pio_intf; | |
| 18 | ||
| 16 | 19 | /*----------- defined in video/kramermc.c -----------*/ |
| 17 | 20 | |
| 18 | 21 | extern const gfx_layout kramermc_charlayout; |
| 19 | 22 | |
| 20 | extern VIDEO_START( kramermc ); | |
| 21 | extern VIDEO_UPDATE( kramermc ); | |
| 23 | VIDEO_START( kramermc ); | |
| 24 | VIDEO_UPDATE( kramermc ); | |
| 22 | 25 | |
| 23 | 26 | |
| 24 | 27 | #endif /* KRAMERMC_h_ */ |
| r3342 | r3343 | |
|---|---|---|
| 29 | 29 | static UINT8 fdc_head = 0; |
| 30 | 30 | static UINT8 fdc_den = 0; |
| 31 | 31 | static UINT8 fdc_status = 0; |
| 32 | static | |
| 32 | static co | |
| 33 | 33 | static void mbee_fdc_callback(running_machine *machine, wd17xx_state_t event, void *param); |
| 34 | 34 | |
| 35 | 35 | UINT8 *mbee_workram; |
| 36 | 36 | |
| 37 | static const z80pio_interface pio_intf = | |
| 37 | ||
| 38 | static void mbee_z80pio_reset(int which) | |
| 38 | 39 | { |
| 39 | pio_interrupt, /* callback when change interrupt status */ | |
| 40 | NULL, | |
| 41 | NULL, | |
| 42 | NULL, | |
| 43 | NULL, | |
| 44 | 0, /* portA ready active callback (do not support yet)*/ | |
| 45 | 0 /* portB ready active callback (do not support yet)*/ | |
| 46 | }; | |
| 40 | z80pio_reset( mbee_z80pio ); | |
| 41 | } | |
| 47 | 42 | |
| 48 | static | |
| 43 | static | |
| 49 | 44 | { |
| 50 | | |
| 45 | r | |
| 51 | 46 | } |
| 52 | 47 | |
| 48 | static int mbee_z80pio_irq_ack(int which) | |
| 49 | { | |
| 50 | return z80pio_irq_ack( mbee_z80pio ); | |
| 51 | } | |
| 52 | ||
| 53 | static void mbee_z80pio_irq_reti(int which) | |
| 54 | { | |
| 55 | z80pio_irq_reti( mbee_z80pio ); | |
| 56 | } | |
| 57 | ||
| 58 | const struct z80_irq_daisy_chain mbee_daisy_chain[] = | |
| 59 | { | |
| 60 | { mbee_z80pio_reset, mbee_z80pio_irq_state, mbee_z80pio_irq_ack, mbee_z80pio_irq_reti, 0 }, /* PIO number 0 */ | |
| 61 | { 0, 0, 0, 0, -1} /* end mark */ | |
| 62 | }; | |
| 63 | ||
| 64 | ||
| 53 | 65 | /* |
| 54 | 66 | On reset or power on, a circuit forces rom 8000-8FFF to appear at 0000-0FFF, while ram is disabled. |
| 55 | 67 | It gets set back to normal on the first attempt to write to memory. (/WR line goes active). |
| r3342 | r3343 | |
| 64 | 76 | |
| 65 | 77 | MACHINE_RESET( mbee ) |
| 66 | 78 | { |
| 67 | z80pio_i | |
| 79 | mbee_z80pio = device_list_find_by_tag( machine->config->devicelist, Z80PIO, "z80pio" | |
| 68 | 80 | timer_set(ATTOTIME_IN_USEC(4), NULL, 0, mbee_reset); |
| 69 | 81 | memory_set_bank(1, 1); |
| 70 | 82 | } |
| r3342 | r3343 | |
| 92 | 104 | READ8_HANDLER ( mbee_pio_r ) |
| 93 | 105 | { |
| 94 | 106 | UINT8 data=0; |
| 95 | if (offset == 0) return z80pio_d_r(machine,0,0); | |
| 96 | if (offset == 1) return z80pio_c_r(0,0); | |
| 97 | if (offset == 3) return z80pio_c_r(0,1); | |
| 98 | data = z80pio_d_r(machine,0,1) | 1; | |
| 107 | if (offset == 0) return z80pio_d_r(mbee_z80pio,0); | |
| 108 | if (offset == 1) return z80pio_c_r(mbee_z80pio,0); | |
| 109 | if (offset == 3) return z80pio_c_r(mbee_z80pio,1); | |
| 110 | data = z80pio_d_r(mbee_z80pio,1) | 1; | |
| 99 | 111 | if (cassette_input(cassette_device_image(machine)) > 0.03) |
| 100 | 112 | data &= ~1; |
| 101 | 113 | return data; |
| r3342 | r3343 | |
| 103 | 115 | |
| 104 | 116 | WRITE8_HANDLER ( mbee_pio_w ) |
| 105 | 117 | { |
| 106 | if (offset == 0) z80pio_d_w(machine, 0,0,data); | |
| 107 | if (offset == 1) z80pio_c_w(machine, 0,0,data); | |
| 108 | if (offset == 3) z80pio_c_w(machine, 0,1,data); | |
| 118 | if (offset == 0) z80pio_d_w(mbee_z80pio,0,data); | |
| 119 | if (offset == 1) z80pio_c_w(mbee_z80pio,0,data); | |
| 120 | if (offset == 3) z80pio_c_w(mbee_z80pio,1,data); | |
| 109 | 121 | |
| 110 | 122 | if( offset == 2 ) |
| 111 | 123 | { |
| 112 | z80pio_d_w(machine, 0,1,data); | |
| 113 | data = z80pio_p_r(machine,0,1); | |
| 124 | z80pio_d_w(mbee_z80pio,1,data); | |
| 125 | data = z80pio_p_r(mbee_z80pio,1); | |
| 114 | 126 | cassette_output(cassette_device_image(machine), (data & 0x02) ? -1.0 : +1.0); |
| 115 | 127 | speaker_level_w(0, (data & 0x40) ? 1 : 0); |
| 116 | 128 | } |
| r3342 | r3343 | |
| 171 | 183 | INTERRUPT_GEN( mbee_interrupt ) |
| 172 | 184 | { |
| 173 | 185 | /* once per frame, pulse the PIO B bit 7 */ |
| 174 | z80pio_p_w(machine, 0, 1, 0x80); | |
| 175 | z80pio_p_w(machine, 0, 1, 0x00); | |
| 186 | z80pio_p_w(mbee_z80pio, 1, 0x80); | |
| 187 | z80pio_p_w(mbee_z80pio, 1, 0x00); | |
| 176 | 188 | } |
| 177 | 189 | |
| 178 | 190 | DEVICE_IMAGE_LOAD( mbee_cart ) |
| r3342 | r3343 | |
|---|---|---|
| 13 | 13 | |
| 14 | 14 | UINT8 kramermc_key_row; |
| 15 | 15 | |
| 16 | READ8_HANDLER (kramermc_port_a_r) | |
| 16 | READ8_DEVICE_HANDLER (kramermc_port_a_r) | |
| 17 | 17 | { |
| 18 | 18 | return 0xff; |
| 19 | 19 | } |
| 20 | 20 | |
| 21 | READ8_HANDLER (kramermc_port_b_r) | |
| 21 | READ8_DEVICE_HANDLER (kramermc_port_b_r) | |
| 22 | 22 | { |
| 23 | 23 | static const char *keynames[] = { "LINE0", "LINE1", "LINE2", "LINE3", "LINE4", "LINE5", "LINE6", "LINE7" }; |
| 24 | 24 | |
| 25 | return input_port_read(machine, keynames[kramermc_key_row]); | |
| 25 | return input_port_read(device->machine, keynames[kramermc_key_row]); | |
| 26 | 26 | } |
| 27 | 27 | |
| 28 | WRITE8_HANDLER (kramermc_port_a_w) | |
| 28 | WRITE8_DEVICE_HANDLER (kramermc_port_a_w) | |
| 29 | 29 | { |
| 30 | 30 | kramermc_key_row = ((data >> 1) & 0x07); |
| 31 | 31 | } |
| 32 | 32 | |
| 33 | ||
| 33 | ||
| 34 | 34 | { |
| 35 | 35 | NULL, /* callback when change interrupt status */ |
| 36 | 36 | kramermc_port_a_r, |
| r3342 | r3343 | |
| 49 | 49 | MACHINE_RESET( kramermc ) |
| 50 | 50 | { |
| 51 | 51 | kramermc_key_row = 0; |
| 52 | z80pio_init(0, &pio_intf); | |
| 53 | 52 | } |
| r3342 | r3343 | |
|---|---|---|
| 19 | 19 | #define LOG(x) do { if (KC_DEBUG) logerror x; } while (0) |
| 20 | 20 | |
| 21 | 21 | static int kc85_pio_data[2]; |
| 22 | static const device_config *kc85_z80pio; | |
| 22 | 23 | |
| 23 | 24 | static void kc85_4_update_0x0c000(running_machine *machine); |
| 24 | 25 | static void kc85_4_update_0x0e000(running_machine *machine); |
| r3342 | r3343 | |
| 410 | 411 | bit = 1; |
| 411 | 412 | |
| 412 | 413 | /* update astb with bit */ |
| 413 | z80pio_astb_w( | |
| 414 | z80pio_astb_w(k | |
| 414 | 415 | } |
| 415 | 416 | |
| 416 | 417 | static void kc_cassette_init(void) |
| r3342 | r3343 | |
| 865 | 866 | LOG_KBD(("kc keyboard sending pulse: %02x\n",pulse_state)); |
| 866 | 867 | |
| 867 | 868 | /* set pulse */ |
| 868 | z80pio_bstb_w( | |
| 869 | z80pio_bstb_w(k | |
| 869 | 870 | |
| 870 | 871 | /* update counts */ |
| 871 | 872 | keyboard_data.transmit_pulse_count_remaining--; |
| r3342 | r3343 | |
| 920 | 921 | keyboard_data.transmit_pulse_count = 0; |
| 921 | 922 | |
| 922 | 923 | /* set initial state */ |
| 923 | z80pio_bstb_w( | |
| 924 | z80pio_bstb_w(k | |
| 924 | 925 | |
| 925 | 926 | |
| 926 | 927 | for (i=0; i<KC_KEYBOARD_NUM_LINES-1; i++) |
| r3342 | r3343 | |
| 1377 | 1378 | WRITE8_HANDLER ( kc85_4_pio_data_w ) |
| 1378 | 1379 | { |
| 1379 | 1380 | kc85_pio_data[offset] = data; |
| 1380 | z80pio_d_w( | |
| 1381 | z80pio_d_w(k | |
| 1381 | 1382 | |
| 1382 | 1383 | switch (offset) |
| 1383 | 1384 | { |
| r3342 | r3343 | |
| 1619 | 1620 | WRITE8_HANDLER ( kc85_3_pio_data_w ) |
| 1620 | 1621 | { |
| 1621 | 1622 | kc85_pio_data[offset] = data; |
| 1622 | z80pio_d_w( | |
| 1623 | z80pio_d_w(k | |
| 1623 | 1624 | |
| 1624 | 1625 | switch (offset) |
| 1625 | 1626 | { |
| r3342 | r3343 | |
| 1693 | 1694 | |
| 1694 | 1695 | READ8_HANDLER ( kc85_pio_data_r ) |
| 1695 | 1696 | { |
| 1696 | return z80pio_d_r( | |
| 1697 | return z80pio_d_r(k | |
| 1697 | 1698 | } |
| 1698 | 1699 | |
| 1699 | 1700 | READ8_HANDLER ( kc85_pio_control_r ) |
| 1700 | 1701 | { |
| 1701 | return z80pio_c_r(0,offset); | |
| 1702 | return z80pio_c_r(kc85_z80pio,offset); | |
| 1702 | 1703 | } |
| 1703 | 1704 | |
| 1704 | 1705 | |
| 1705 | 1706 | |
| 1706 | 1707 | WRITE8_HANDLER ( kc85_pio_control_w ) |
| 1707 | 1708 | { |
| 1708 | z80pio_c_w( | |
| 1709 | z80pio_c_w(k | |
| 1709 | 1710 | } |
| 1710 | 1711 | |
| 1711 | 1712 | |
| r3342 | r3343 | |
| 1760 | 1761 | } |
| 1761 | 1762 | } |
| 1762 | 1763 | |
| 1763 | ||
| 1764 | ||
| 1764 | 1765 | { |
| 1765 | 1766 | kc85_pio_interrupt, /* callback when change interrupt status */ |
| 1766 | 1767 | NULL, |
| r3342 | r3343 | |
| 1771 | 1772 | kc85_pio_brdy_callback /* portB ready active callback */ |
| 1772 | 1773 | }; |
| 1773 | 1774 | |
| 1775 | static void kc85_z80pio_reset(int which) | |
| 1776 | { | |
| 1777 | z80pio_reset(kc85_z80pio); | |
| 1778 | } | |
| 1779 | ||
| 1780 | /* pio is last in chain and therefore has highest priority */ | |
| 1781 | ||
| 1782 | const struct z80_irq_daisy_chain kc85_daisy_chain[] = | |
| 1783 | { | |
| 1784 | {kc85_z80pio_reset, z80ctc_irq_state, z80ctc_irq_ack, z80ctc_irq_reti, 0}, | |
| 1785 | {z80ctc_reset, z80ctc_irq_state, z80ctc_irq_ack, z80ctc_irq_reti, 0}, | |
| 1786 | {0,0,0,0,-1} | |
| 1787 | }; | |
| 1788 | ||
| 1774 | 1789 | /* used in cassette write -> K0 */ |
| 1775 | 1790 | static WRITE8_HANDLER(kc85_zc0_callback) |
| 1776 | 1791 | { |
| r3342 | r3343 | |
| 1833 | 1848 | |
| 1834 | 1849 | static void kc85_common_init(running_machine *machine) |
| 1835 | 1850 | { |
| 1836 | z80pio_init(0, &kc85_pio_intf); | |
| 1837 | 1851 | z80ctc_init(0, &kc85_ctc_intf); |
| 1838 | 1852 | |
| 1839 | 1853 | z80ctc_reset(0); |
| 1840 | z80pio_reset(0); | |
| 1841 | 1854 | |
| 1842 | 1855 | kc_cassette_init(); |
| 1843 | 1856 | kc_keyboard_init(machine); |
| r3342 | r3343 | |
| 1865 | 1878 | kc85_pio_data[0] = 0x0f; |
| 1866 | 1879 | kc85_pio_data[1] = 0x0f1; |
| 1867 | 1880 | |
| 1881 | kc85_z80pio = device_list_find_by_tag( machine->config->devicelist, Z80PIO, "z80pio" ); | |
| 1882 | ||
| 1868 | 1883 | kc85_4_update_0x04000(machine); |
| 1869 | 1884 | kc85_4_update_0x08000(machine); |
| 1870 | 1885 | kc85_4_update_0x0c000(machine); |
| r3342 | r3343 | |
|---|---|---|
| 279 | 279 | colortable_entry_set_value(machine->colortable, (((i<<5)|r)<<1)|1, r|64); |
| 280 | 280 | } |
| 281 | 281 | |
| 282 | static const struct z80_irq_daisy_chain mbee_daisy_chain[] = | |
| 282 | ||
| 283 | static void pio_interrupt(running_machine *machine, int state) | |
| 283 | 284 | { |
| 284 | { z80pio_reset, z80pio_irq_state, z80pio_irq_ack, z80pio_irq_reti, 0 }, /* PIO number 0 */ | |
| 285 | { 0, 0, 0, 0, -1} /* end mark */ | |
| 285 | cpunum_set_input_line(machine, 0, 0, state ? ASSERT_LINE : CLEAR_LINE); | |
| 286 | } | |
| 287 | ||
| 288 | static const z80pio_interface mbee_z80pio_intf = | |
| 289 | { | |
| 290 | pio_interrupt, /* callback when change interrupt status */ | |
| 291 | NULL, | |
| 292 | NULL, | |
| 293 | NULL, | |
| 294 | NULL, | |
| 295 | 0, /* portA ready active callback (do not support yet)*/ | |
| 296 | 0 /* portB ready active callback (do not support yet)*/ | |
| 286 | 297 | }; |
| 287 | 298 | |
| 288 | 299 | |
| r3342 | r3343 | |
| 297 | 308 | |
| 298 | 309 | MDRV_MACHINE_RESET( mbee ) |
| 299 | 310 | |
| 311 | MDRV_Z80PIO_ADD( "z80pio", mbee_z80pio_intf ) | |
| 312 | ||
| 300 | 313 | MDRV_GFXDECODE(mbee) |
| 301 | 314 | MDRV_SCREEN_ADD("main", RASTER) |
| 302 | 315 | MDRV_SCREEN_REFRESH_RATE(50) |
| r3342 | r3343 | |
| 336 | 349 | MDRV_MACHINE_RESET( mbee ) |
| 337 | 350 | MDRV_MACHINE_START( mbee ) |
| 338 | 351 | |
| 352 | MDRV_Z80PIO_ADD( "z80pio", mbee_z80pio_intf ) | |
| 353 | ||
| 339 | 354 | MDRV_GFXDECODE(mbeeic) |
| 340 | 355 | MDRV_SCREEN_ADD("main", RASTER) |
| 341 | 356 | MDRV_SCREEN_REFRESH_RATE(50) |
| r3342 | r3343 | |
|---|---|---|
| 91 | 91 | #include "devices/printer.h" |
| 92 | 92 | |
| 93 | 93 | static emu_timer *abc80_keyboard_timer; |
| 94 | static const device_config *abc80_z80pio; | |
| 94 | 95 | |
| 95 | 96 | static const device_config *cassette_device_image(running_machine *machine) |
| 96 | 97 | { |
| r3342 | r3343 | |
| 207 | 208 | } |
| 208 | 209 | |
| 209 | 210 | if (keycode) |
| 210 | z80pio_p_w( | |
| 211 | z80pio_p_w( | |
| 211 | 212 | else |
| 212 | z80pio_p_w( | |
| 213 | z80pio_p_w( | |
| 213 | 214 | |
| 214 | 215 | if (keycode != keylatch) program_write_byte(0xfdf5, 0x80); |
| 215 | 216 | |
| 216 | 217 | keylatch = keycode; |
| 217 | 218 | } |
| 218 | 219 | |
| 219 | // PIO | |
| 220 | 220 | |
| 221 | static READ8_HANDLER( abc80_pio_r ) | |
| 222 | { | |
| 223 | switch (offset) | |
| 224 | { | |
| 225 | case 0: | |
| 226 | return z80pio_d_r(machine, 0, 0); | |
| 227 | case 1: | |
| 228 | return z80pio_c_r(0, 0); | |
| 229 | case 2: | |
| 230 | return z80pio_d_r(machine, 0, 1); | |
| 231 | case 3: | |
| 232 | return z80pio_c_r(0, 1); | |
| 233 | } | |
| 234 | ||
| 235 | return 0xff; | |
| 236 | } | |
| 237 | ||
| 238 | static WRITE8_HANDLER( abc80_pio_w ) | |
| 239 | { | |
| 240 | switch (offset) | |
| 241 | { | |
| 242 | case 0: | |
| 243 | z80pio_d_w(machine, 0, 0, data); | |
| 244 | break; | |
| 245 | case 1: | |
| 246 | z80pio_c_w(machine, 0, 0, data); | |
| 247 | break; | |
| 248 | case 2: | |
| 249 | z80pio_d_w(machine, 0, 1, data); | |
| 250 | break; | |
| 251 | case 3: | |
| 252 | z80pio_c_w(machine, 0, 1, data); | |
| 253 | break; | |
| 254 | } | |
| 255 | } | |
| 256 | ||
| 257 | 221 | /* Memory Maps */ |
| 258 | 222 | |
| 259 | 223 | static ADDRESS_MAP_START( abc80_map, ADDRESS_SPACE_PROGRAM, 8 ) |
| r3342 | r3343 | |
| 275 | 239 | AM_RANGE(0x02, 0x05) AM_WRITE(abcbus_command_w) |
| 276 | 240 | AM_RANGE(0x06, 0x06) AM_WRITE(abc80_sound_w) |
| 277 | 241 | AM_RANGE(0x07, 0x07) AM_READ(abcbus_reset_r) |
| 278 | AM_RANGE(0x38, 0x3b) AM_READWRITE( | |
| 242 | AM_RANGE(0x38, 0x3b) AM_DEVREADWRITE( Z | |
| 279 | 243 | ADDRESS_MAP_END |
| 280 | 244 | |
| 281 | 245 | /* Input Ports */ |
| r3342 | r3343 | |
| 413 | 377 | |
| 414 | 378 | /* Machine Initialization */ |
| 415 | 379 | |
| 380 | static void abc80_z80pio_reset(int which) | |
| 381 | { | |
| 382 | z80pio_reset( abc80_z80pio ); | |
| 383 | } | |
| 384 | ||
| 385 | static int abc80_z80pio_irq_state(int which) | |
| 386 | { | |
| 387 | return z80pio_irq_state( abc80_z80pio ); | |
| 388 | } | |
| 389 | ||
| 390 | static int abc80_z80pio_irq_ack(int which) | |
| 391 | { | |
| 392 | return z80pio_irq_ack( abc80_z80pio ); | |
| 393 | } | |
| 394 | ||
| 395 | static void abc80_z80pio_irq_reti(int which) | |
| 396 | { | |
| 397 | z80pio_irq_reti( abc80_z80pio ); | |
| 398 | } | |
| 399 | ||
| 416 | 400 | static const struct z80_irq_daisy_chain abc80_daisy_chain[] = |
| 417 | 401 | { |
| 418 | { z80pio_reset, z80pio_irq_state, z80pio_irq_ack, z80pio_irq_reti, 0 }, | |
| 402 | { abc80_z80pio_reset, abc80_z80pio_irq_state, abc80_z80pio_irq_ack, abc80_z80pio_irq_reti, 0 }, | |
| 419 | 403 | { 0, 0, 0, 0, -1 } |
| 420 | 404 | }; |
| 421 | 405 | |
| r3342 | r3343 | |
| 451 | 435 | } |
| 452 | 436 | #endif |
| 453 | 437 | |
| 454 | static READ8_HANDLER( abc80_pio_port_b_r ) | |
| 438 | static READ8_DEVICE_HANDLER( abc80_pio_port_b_r ) | |
| 455 | 439 | { |
| 456 | 440 | /* |
| 457 | 441 | |
| r3342 | r3343 | |
| 468 | 452 | |
| 469 | 453 | */ |
| 470 | 454 | |
| 471 | UINT8 data = (cassette_input(cassette_device_image(machine)) > +1.0) ? 0x80 : 0; | |
| 455 | UINT8 data = (cassette_input(cassette_device_image(device->machine)) > +1.0) ? 0x80 : 0; | |
| 472 | 456 | |
| 473 | 457 | return data; |
| 474 | 458 | }; |
| 475 | 459 | |
| 476 | static WRITE8_HANDLER( abc80_pio_port_b_w ) | |
| 460 | static WRITE8_DEVICE_HANDLER( abc80_pio_port_b_w ) | |
| 477 | 461 | { |
| 478 | 462 | /* |
| 479 | 463 | |
| r3342 | r3343 | |
| 490 | 474 | |
| 491 | 475 | */ |
| 492 | 476 | |
| 493 | cassette_change_state(cassette_device_image(machine), BIT(data, 5) ? CASSETTE_MOTOR_ENABLED : CASSETTE_MOTOR_DISABLED, CASSETTE_MASK_MOTOR); | |
| 477 | cassette_change_state(cassette_device_image(device->machine), BIT(data, 5) ? CASSETTE_MOTOR_ENABLED : CASSETTE_MOTOR_DISABLED, CASSETTE_MASK_MOTOR); | |
| 494 | 478 | |
| 495 | cassette_output(cassette_device_image(machine), BIT(data, 7) ? -1.0 : +1.0); | |
| 479 | cassette_output(cassette_device_image(device->machine), BIT(data, 7) ? -1.0 : +1.0); | |
| 496 | 480 | }; |
| 497 | 481 | |
| 498 | 482 | static const z80pio_interface abc80_pio_intf = |
| r3342 | r3343 | |
| 524 | 508 | break; |
| 525 | 509 | } |
| 526 | 510 | |
| 511 | abc80_z80pio = device_list_find_by_tag( machine->config->devicelist, Z80PIO, "z80pio" ); | |
| 512 | ||
| 527 | 513 | /* register for state saving */ |
| 528 | 514 | |
| 529 | 515 | state_save_register_global(keylatch); |
| 530 | 516 | |
| 531 | /* initialize the PIO */ | |
| 532 | ||
| 533 | z80pio_init(0, &abc80_pio_intf); | |
| 534 | ||
| 535 | 517 | /* allocate the keyboard scan timer */ |
| 536 | 518 | |
| 537 | 519 | abc80_keyboard_timer = timer_alloc(abc80_keyboard_tick, NULL); |
| r3342 | r3343 | |
| 552 | 534 | |
| 553 | 535 | MDRV_MACHINE_START(abc80) |
| 554 | 536 | |
| 537 | MDRV_Z80PIO_ADD( "z80pio", abc80_pio_intf ) | |
| 538 | ||
| 555 | 539 | // video hardware |
| 556 | 540 | |
| 557 | 541 | MDRV_SCREEN_ADD("main", RASTER) |
| r3342 | r3343 | |
|---|---|---|
| 31 | 31 | |
| 32 | 32 | static ADDRESS_MAP_START( kramermc_io, ADDRESS_SPACE_IO, 8 ) |
| 33 | 33 | ADDRESS_MAP_GLOBAL_MASK(0xff) |
| 34 | AM_RANGE(0xfc, 0x0ff) AM_READWRITE(z80pio | |
| 34 | AM_RANGE(0xfc, 0x0ff) AM_DEVREADWRITE(Z80PIO, "z80pio", z80pio_r, z80pio | |
| 35 | 35 | ADDRESS_MAP_END |
| 36 | 36 | |
| 37 | 37 | /* Input ports */ |
| r3342 | r3343 | |
| 105 | 105 | |
| 106 | 106 | /* Machine driver */ |
| 107 | 107 | static MACHINE_DRIVER_START( kramermc ) |
| 108 | /* basic machine hardware */ | |
| 109 | MDRV_CPU_ADD("main", Z80, 1500000) | |
| 110 | MDRV_CPU_PROGRAM_MAP(kramermc_mem, 0) | |
| 111 | MDRV_CPU_IO_MAP(kramermc_io, 0) | |
| 112 | MDRV_MACHINE_RESET( kramermc ) | |
| 108 | /* basic machine hardware */ | |
| 109 | MDRV_CPU_ADD("main", Z80, 1500000) | |
| 110 | MDRV_CPU_PROGRAM_MAP(kramermc_mem, 0) | |
| 111 | MDRV_CPU_IO_MAP(kramermc_io, 0) | |
| 112 | MDRV_MACHINE_RESET( kramermc ) | |
| 113 | 113 | |
| 114 | /* video hardware */ | |
| 114 | MDRV_Z80PIO_ADD( "z80pio", kramermc_z80pio_intf ) | |
| 115 | ||
| 116 | /* video hardware */ | |
| 115 | 117 | MDRV_SCREEN_ADD("main", RASTER) |
| 116 | 118 | MDRV_SCREEN_REFRESH_RATE(50) |
| 117 | 119 | MDRV_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(2500)) /* not accurate */ |
| r3342 | r3343 | |
| 123 | 125 | MDRV_PALETTE_LENGTH(2) |
| 124 | 126 | MDRV_PALETTE_INIT(black_and_white) |
| 125 | 127 | |
| 126 | MDRV_VIDEO_START(kramermc) | |
| 127 | MDRV_VIDEO_UPDATE(kramermc) | |
| 128 | MDRV_VIDEO_START(kramermc) | |
| 129 | MDRV_VIDEO_UPDATE(kramermc) | |
| 128 | 130 | MACHINE_DRIVER_END |
| 129 | 131 | |
| 130 | 132 | /* ROM definition */ |
| 131 | 133 | ROM_START( kramermc ) |
| 132 | ROM_REGION( 0x10000, "main", ROMREGION_ERASEFF ) | |
| 133 | ROM_LOAD( "io-mon.kmc", 0x0000, 0x0400, CRC(ba230fc8) SHA1(197d4ede31ee8768dd4a17854ee21c468e98b3d6) ) | |
| 134 | ROM_LOAD( "debugger.kmc", 0x0400, 0x0400, CRC(5ea3d9e1) SHA1(42e5ced4f965124ae50ec7ac9861d6b668cfab99) ) | |
| 135 | ROM_LOAD( "reass.kmc", 0x0800, 0x0400, CRC(7cc8e605) SHA1(3319a96aad710441af30dace906b9725e07ca92c) ) | |
| 136 | ROM_LOAD( "basic.kmc", 0x8000, 0x3000, CRC(7531801e) SHA1(61d055495ffcc4a281ef0abc3e299ea95f42544b) ) | |
| 137 | ROM_LOAD( "editor.kmc", 0xc000, 0x0400, CRC(2fd4cb84) SHA1(505615a218865aa8becde13848a23e1241a14b96) ) | |
| 138 | ROM_LOAD( "ass.kmc", 0xc400, 0x1c00, CRC(9a09422e) SHA1(a578d2cf0ea6eb35dcd13e4107e15187de906097) ) | |
| 134 | ROM_REGION( 0x10000, "main", ROMREGION_ERASEFF ) | |
| 135 | ROM_LOAD( "io-mon.kmc", 0x0000, 0x0400, CRC(ba230fc8) SHA1(197d4ede31ee8768dd4a17854ee21c468e98b3d6) ) | |
| 136 | ROM_LOAD( "debugger.kmc", 0x0400, 0x0400, CRC(5ea3d9e1) SHA1(42e5ced4f965124ae50ec7ac9861d6b668cfab99) ) | |
| 137 | ROM_LOAD( "reass.kmc", 0x0800, 0x0400, CRC(7cc8e605) SHA1(3319a96aad710441af30dace906b9725e07ca92c) ) | |
| 138 | ROM_LOAD( "basic.kmc", 0x8000, 0x3000, CRC(7531801e) SHA1(61d055495ffcc4a281ef0abc3e299ea95f42544b) ) | |
| 139 | ROM_LOAD( "editor.kmc", 0xc000, 0x0400, CRC(2fd4cb84) SHA1(505615a218865aa8becde13848a23e1241a14b96) ) | |
| 140 | ROM_LOAD( "ass.kmc", 0xc400, 0x1c00, CRC(9a09422e) SHA1(a578d2cf0ea6eb35dcd13e4107e15187de906097) ) | |
| 139 | 141 | ROM_REGION(0x0800, "gfx1",0) |
| 140 | 142 | ROM_LOAD ("chargen.kmc", 0x0000, 0x0800, CRC(1ba52f9f) SHA1(71bbad90dd427d0132c871a4d3848ab3d4d84b8a)) |
| 141 | 143 | ROM_END |
| r3342 | r3343 | |
|---|---|---|
| 521 | 521 | |
| 522 | 522 | static MACHINE_RESET( mpf1 ) |
| 523 | 523 | { |
| 524 | // PIO | |
| 525 | z80pio_init(0, &pio_intf); | |
| 526 | z80pio_reset(0); | |
| 527 | ||
| 528 | 524 | // CTC |
| 529 | 525 | /* z80ctc_init(&ctc_intf); |
| 530 | 526 | z80ctc_reset(0);*/ |
| r3342 | r3343 | |
| 547 | 543 | |
| 548 | 544 | MDRV_MACHINE_RESET( mpf1 ) |
| 549 | 545 | |
| 546 | MDRV_Z80PIO_ADD( "z80pio", pio_intf ) | |
| 547 | ||
| 550 | 548 | MDRV_DEVICE_ADD( "ppi8255", PPI8255 ) |
| 551 | 549 | MDRV_DEVICE_CONFIG( ppi8255_intf ) |
| 552 | 550 |
| r3342 | r3343 | |
|---|---|---|
| 16 | 16 | static UINT8 current_palette; /* for super80m and super80v */ |
| 17 | 17 | static UINT8 current_charset; /* for super80m */ |
| 18 | 18 | |
| 19 | static const device_config *super80_z80pio; | |
| 20 | ||
| 19 | 21 | /* the rest are for super80v */ |
| 20 | 22 | static UINT8 *pcgram; |
| 21 | 23 | static UINT8 framecnt = 0; |
| r3342 | r3343 | |
| 357 | 359 | }; |
| 358 | 360 | |
| 359 | 361 | |
| 362 | static void super80_z80pio_reset(int which) | |
| 363 | { | |
| 364 | z80pio_reset( super80_z80pio ); | |
| 365 | } | |
| 366 | ||
| 367 | static int super80_z80pio_irq_state(int which) | |
| 368 | { | |
| 369 | return z80pio_irq_state( super80_z80pio ); | |
| 370 | } | |
| 371 | ||
| 372 | static int super80_z80pio_irq_ack(int which) | |
| 373 | { | |
| 374 | return z80pio_irq_ack( super80_z80pio ); | |
| 375 | } | |
| 376 | ||
| 377 | static void super80_z80pio_irq_reti(int which) | |
| 378 | { | |
| 379 | z80pio_irq_reti( super80_z80pio ); | |
| 380 | } | |
| 381 | ||
| 360 | 382 | static const struct z80_irq_daisy_chain super80_daisy_chain[] = |
| 361 | 383 | { |
| 362 | { z80pio_reset, z80pio_irq_state, z80pio_irq_ack, z80pio_irq_reti, 0 }, | |
| 384 | { super80_z80pio_reset, super80_z80pio_irq_state, super80_z80pio_irq_ack, super80_z80pio_irq_reti, 0 }, | |
| 363 | 385 | { 0, 0, 0, 0, -1} /* end mark */ |
| 364 | 386 | }; |
| 365 | 387 | |
| r3342 | r3343 | |
| 401 | 423 | |
| 402 | 424 | static TIMER_CALLBACK( super80_timer ) |
| 403 | 425 | { |
| 404 | UINT8 cass_ws=0, i, mask=1, out_f8=z80pio_p_r( | |
| 426 | UINT8 cass_ws=0, i, mask=1, out_f8=z80pio_p_r(sup | |
| 405 | 427 | static const char *keynames[] = { "LINE0", "LINE1", "LINE2", "LINE3", "LINE4", "LINE5", "LINE6", "LINE7" }; |
| 406 | 428 | |
| 407 | 429 | for ( i=0; i < 8;i++) |
| r3342 | r3343 | |
| 410 | 432 | mask<<=1; |
| 411 | 433 | } |
| 412 | 434 | |
| 413 | z80pio_p_w( | |
| 435 | z80pio_p_w(sup | |
| 414 | 436 | |
| 415 | 437 | cass_data[1]++; |
| 416 | 438 | cass_ws = (cassette_input(cassette_device_image(machine)) > +0.03) ? 4 : 0; |
| r3342 | r3343 | |
| 501 | 523 | current_charset = data & 1; |
| 502 | 524 | } |
| 503 | 525 | |
| 504 | static READ8_HANDLER( super80_f8_r ) { return z80pio_d_r (machine,0,0); } | |
| 505 | static READ8_HANDLER( super80_f9_r ) { return z80pio_c_r (0,0); } | |
| 506 | static READ8_HANDLER( super80_fa_r ) { return z80pio_d_r (machine,0,1); } | |
| 507 | static READ8_HANDLER( super80_fb_r ) { return z80pio_c_r (0,1); } | |
| 508 | static WRITE8_HANDLER( super80_f8_w ) { z80pio_d_w(machine, 0,0, data); } | |
| 509 | static WRITE8_HANDLER( super80_f9_w ) { z80pio_c_w(machine, 0,0, data); } | |
| 510 | static WRITE8_HANDLER( super80_fa_w ) { z80pio_d_w(machine, 0,1, data); } | |
| 511 | static WRITE8_HANDLER( super80_fb_w ) { z80pio_c_w(machine, 0,1, data); } | |
| 526 | static READ8_HANDLER( super80_f8_r ) { return z80pio_d_r (super80_z80pio,0); } | |
| 527 | static READ8_HANDLER( super80_f9_r ) { return z80pio_c_r (super80_z80pio,0); } | |
| 528 | static READ8_HANDLER( super80_fa_r ) { return z80pio_d_r (super80_z80pio,1); } | |
| 529 | static READ8_HANDLER( super80_fb_r ) { return z80pio_c_r (super80_z80pio,1); } | |
| 530 | static WRITE8_HANDLER( super80_f8_w ) { z80pio_d_w(super80_z80pio,0, data); } | |
| 531 | static WRITE8_HANDLER( super80_f9_w ) { z80pio_c_w(super80_z80pio,0, data); } | |
| 532 | static WRITE8_HANDLER( super80_fa_w ) { z80pio_d_w(super80_z80pio,1, data); } | |
| 533 | static WRITE8_HANDLER( super80_fb_w ) { z80pio_c_w(super80_z80pio,1, data); } | |
| 512 | 534 | |
| 513 | 535 | /**************************** MEMORY AND I/O MAPPINGS *****************************************************************/ |
| 514 | 536 | |
| r3342 | r3343 | |
| 921 | 943 | |
| 922 | 944 | static MACHINE_RESET( super80 ) |
| 923 | 945 | { |
| 924 | z80pio_i | |
| 946 | super80_z80pio = device_list_find_by_tag( machine->config->devicelist, Z80PIO, "z80pio" | |
| 925 | 947 | timer_set(ATTOTIME_IN_USEC(10), NULL, 0, super80_reset); |
| 926 | 948 | memory_set_bank(1, 1); |
| 927 | 949 | } |
| r3342 | r3343 | |
| 942 | 964 | |
| 943 | 965 | MDRV_MACHINE_RESET( super80 ) |
| 944 | 966 | |
| 967 | MDRV_Z80PIO_ADD( "z80pio", pio_intf ) | |
| 968 | ||
| 945 | 969 | MDRV_GFXDECODE(super80) |
| 946 | 970 | MDRV_SCREEN_ADD("main", RASTER) |
| 947 | 971 | MDRV_SCREEN_REFRESH_RATE(48.8) |
| r3342 | r3343 | |
|---|---|---|
| 108 | 108 | |
| 109 | 109 | static int einstein_ctc_trigger = 0; |
| 110 | 110 | |
| 111 | static const device_config *einstein_z80pio; | |
| 112 | ||
| 111 | 113 | /* KEYBOARD */ |
| 112 | 114 | static int einstein_keyboard_line = 0; |
| 113 | 115 | static int einstein_keyboard_data = 0x0ff; |
| r3342 | r3343 | |
| 527 | 529 | } |
| 528 | 530 | #endif |
| 529 | 531 | |
| 532 | static void einstein_z80pio_reset(int which) | |
| 533 | { | |
| 534 | z80pio_reset( einstein_z80pio ); | |
| 535 | } | |
| 536 | ||
| 537 | static int einstein_z80pio_irq_state(int which) | |
| 538 | { | |
| 539 | return z80pio_irq_state( einstein_z80pio ); | |
| 540 | } | |
| 541 | ||
| 542 | static int einstein_z80pio_irq_ack(int which) | |
| 543 | { | |
| 544 | return z80pio_irq_ack( einstein_z80pio ); | |
| 545 | } | |
| 546 | ||
| 547 | static void einstein_z80pio_irq_reti(int which) | |
| 548 | { | |
| 549 | z80pio_irq_reti( einstein_z80pio ); | |
| 550 | } | |
| 551 | ||
| 530 | 552 | static const struct z80_irq_daisy_chain einstein_daisy_chain[] = |
| 531 | 553 | { |
| 532 | 554 | {einstein_keyboard_int_reset, einstein_keyboard_interrupt, 0, einstein_keyboard_reti, 0}, |
| 533 | 555 | {z80ctc_reset, z80ctc_irq_state, z80ctc_irq_ack, z80ctc_irq_reti, 0}, |
| 534 | 556 | {einstein_adc_int_reset,einstein_adc_interrupt, 0, einstein_adc_reti, 0}, |
| 535 | {z80pio_reset, z80pio_irq_state, z80pio_irq_ack, z80pio_irq_reti, 0}, | |
| 557 | {einstein_z80pio_reset, einstein_z80pio_irq_state, einstein_z80pio_irq_ack, einstein_z80pio_irq_reti, 0}, | |
| 536 | 558 | // {einstein_fire_int_reset,einstein_fire_interrupt, einstein_fire_reti, 0}, |
| 537 | 559 | {0,0,0,0,-1} |
| 538 | 560 | }; |
| r3342 | r3343 | |
| 637 | 659 | { |
| 638 | 660 | logerror("pio w: %04x %02x\n",offset,data); |
| 639 | 661 | |
| 640 | if ((offset & 0x0 | |
| 662 | if ( ( offset & 0x03 ) == 0x02 ) | |
| 641 | 663 | { |
| 642 | switch ((offset>>1) & 0x01) | |
| 643 | { | |
| 644 | /* port A */ | |
| 645 | case 0: | |
| 646 | { | |
| 647 | /* printer is connected to port A */ | |
| 648 | centronics_write_data(0,data); | |
| 649 | } | |
| 650 | break; | |
| 651 | ||
| 652 | default: | |
| 653 | break; | |
| 654 | } | |
| 655 | ||
| 656 | z80pio_d_w( machine, 0, (offset>>1) & 0x01,data); | |
| 657 | return; | |
| 664 | /* printer is connected to port A */ | |
| 665 | centronics_write_data(0,data); | |
| 658 | 666 | } |
| 659 | 667 | |
| 660 | z80pio_ | |
| 668 | z80pio_ | |
| 661 | 669 | } |
| 662 | 670 | |
| 663 | 671 | static READ8_HANDLER(einstein_pio_r) |
| 664 | 672 | { |
| 665 | 673 | logerror("pio r: %04x\n",offset); |
| 666 | 674 | |
| 667 | if ((offset & 0x01)==0) | |
| 668 | { | |
| 669 | return z80pio_d_r( machine, 0, (offset>>1) & 0x01); | |
| 670 | } | |
| 671 | ||
| 672 | return z80pio_c_r( 0, (offset>>1) & 0x01); | |
| 675 | return z80pio_r( einstein_z80pio, offset ); | |
| 673 | 676 | } |
| 674 | 677 | |
| 675 | 678 | static READ8_HANDLER(einstein_ctc_r) |
| r3342 | r3343 | |
| 1368 | 1371 | if (data & CENTRONICS_ACKNOWLEDGE) |
| 1369 | 1372 | { |
| 1370 | 1373 | /* /ack into /astb */ |
| 1371 | z80pio_astb_w( | |
| 1374 | z80pio_astb_w( e | |
| 1372 | 1375 | } |
| 1373 | 1376 | else |
| 1374 | 1377 | { |
| 1375 | z80pio_astb_w( | |
| 1378 | z80pio_astb_w( e | |
| 1376 | 1379 | } |
| 1377 | 1380 | } |
| 1378 | 1381 | } |
| r3342 | r3343 | |
| 1425 | 1428 | { |
| 1426 | 1429 | TMS9928A_configure(&tms9928a_interface); |
| 1427 | 1430 | wd17xx_init(machine, WD_TYPE_177X, NULL, NULL); |
| 1431 | ||
| 1432 | einstein_z80pio = device_list_find_by_tag( machine->config->devicelist, Z80PIO, "z80pio" ); | |
| 1428 | 1433 | } |
| 1429 | 1434 | |
| 1430 | 1435 | static MACHINE_RESET( einstein ) |
| r3342 | r3343 | |
| 1434 | 1439 | memory_set_bankptr(4, mess_ram+0x02000); |
| 1435 | 1440 | |
| 1436 | 1441 | z80ctc_init(0, &einstein_ctc_intf); |
| 1437 | z80pio_init(0, &einstein_pio_intf); | |
| 1438 | 1442 | msm8251_init(&einstein_msm8251_intf); |
| 1439 | 1443 | |
| 1440 | 1444 | z80ctc_reset(0); |
| 1441 | z80pio_reset(0); | |
| 1442 | 1445 | |
| 1443 | 1446 | TMS9928A_reset (); |
| 1444 | 1447 | |
| r3342 | r3343 | |
| 1727 | 1730 | MDRV_MACHINE_START( einstein ) |
| 1728 | 1731 | MDRV_MACHINE_RESET( einstein ) |
| 1729 | 1732 | |
| 1733 | MDRV_Z80PIO_ADD( "z80pio", einstein_pio_intf ) | |
| 1734 | ||
| 1730 | 1735 | /* video hardware */ |
| 1731 | 1736 | MDRV_IMPORT_FROM(tms9928a) |
| 1732 | 1737 | MDRV_SCREEN_MODIFY("main") |
| r3342 | r3343 | |
|---|---|---|
| 22 | 22 | |
| 23 | 23 | static ADDRESS_MAP_START( bbcbc_io, ADDRESS_SPACE_IO, 8 ) |
| 24 | 24 | ADDRESS_MAP_GLOBAL_MASK(0xff) |
| 25 | AM_RANGE(0x40, 0x40) AM_READWRITE(z80pio | |
| 25 | AM_RANGE(0x40, 0x40) AM_DEVREADWRITE(Z80PIO, "z80pio", z80pio_p_r, z80pio | |
| 26 | 26 | AM_RANGE(0x80, 0x80) AM_READWRITE(TMS9928A_vram_r, TMS9928A_vram_w) |
| 27 | 27 | AM_RANGE(0x81, 0x81) AM_READWRITE(TMS9928A_register_r, TMS9928A_register_w) |
| 28 | 28 | ADDRESS_MAP_END |
| r3342 | r3343 | |
| 46 | 46 | }; |
| 47 | 47 | |
| 48 | 48 | /* TODO */ |
| 49 | static const z80pio_interface pio_intf = | |
| 49 | static const z80pio_interface bbcbc_z80pio_intf = | |
| 50 | 50 | { |
| 51 | 51 | NULL, |
| 52 | 52 | NULL, |
| r3342 | r3343 | |
| 75 | 75 | MDRV_MACHINE_START( bbcbc ) |
| 76 | 76 | MDRV_MACHINE_RESET( bbcbc ) |
| 77 | 77 | |
| 78 | MDRV_Z80PIO_ADD( "z80pio", bbcbc_z80pio_intf ) | |
| 79 | ||
| 78 | 80 | MDRV_CPU_VBLANK_INT("main", bbcbc_interrupt) |
| 79 | 81 | MDRV_IMPORT_FROM( tms9928a ) |
| 80 | 82 | MDRV_SCREEN_MODIFY("main") |
| r3342 | r3343 | |
|---|---|---|
| 28 | 28 | #include "devices/basicdsk.h" |
| 29 | 29 | |
| 30 | 30 | |
| 31 | /* pio is last in chain and therefore has highest priority */ | |
| 32 | ||
| 33 | static const struct z80_irq_daisy_chain kc85_daisy_chain[] = | |
| 34 | { | |
| 35 | {z80pio_reset, z80ctc_irq_state, z80ctc_irq_ack, z80ctc_irq_reti, 0}, | |
| 36 | {z80ctc_reset, z80ctc_irq_state, z80ctc_irq_ack, z80ctc_irq_reti, 0}, | |
| 37 | {0,0,0,0,-1} | |
| 38 | }; | |
| 39 | ||
| 40 | 31 | static READ8_HANDLER(kc85_4_port_r) |
| 41 | 32 | { |
| 42 | 33 | int port; |
| r3342 | r3343 | |
| 347 | 338 | |
| 348 | 339 | MDRV_MACHINE_RESET( kc85_3 ) |
| 349 | 340 | |
| 341 | MDRV_Z80PIO_ADD( "z80pio", kc85_pio_intf ) | |
| 342 | ||
| 350 | 343 | /* video hardware */ |
| 351 | 344 | MDRV_SCREEN_ADD("main", RASTER) |
| 352 | 345 | MDRV_SCREEN_REFRESH_RATE(50) |
| Previous | 15994 Revisions | Next |