src/mess/machine/vic1112.c
| r7035 | r7036 | |
| 27 | 27 | typedef struct _vic1112_t vic1112_t; |
| 28 | 28 | struct _vic1112_t |
| 29 | 29 | { |
| 30 | int via0_irq; /* VIA #0 interrupt request */ |
| 31 | int via1_irq; /* VIA #1 interrupt request */ |
| 32 | |
| 33 | /* devices */ |
| 30 | 34 | const device_config *via0; |
| 31 | 35 | const device_config *via1; |
| 32 | 36 | const device_config *bus; |
| r7035 | r7036 | |
| 71 | 75 | via6522_interface vic1112_via0_intf |
| 72 | 76 | -------------------------------------------------*/ |
| 73 | 77 | |
| 74 | | static WRITE_LINE_DEVICE_HANDLER( via_irq_w ) |
| 78 | static WRITE_LINE_DEVICE_HANDLER( via0_irq_w ) |
| 75 | 79 | { |
| 76 | | cpu_set_input_line(device->machine->firstcpu, M6502_IRQ_LINE, state); |
| 80 | vic1112_t *vic1112 = get_safe_token(device->owner); |
| 81 | |
| 82 | vic1112->via0_irq = state; |
| 83 | |
| 84 | cpu_set_input_line(device->machine->firstcpu, M6502_IRQ_LINE, (vic1112->via0_irq | vic1112->via1_irq) ? ASSERT_LINE : CLEAR_LINE); |
| 77 | 85 | } |
| 78 | 86 | |
| 79 | 87 | static READ8_DEVICE_HANDLER( via0_pb_r ) |
| r7035 | r7036 | |
| 96 | 104 | vic1112_t *vic1112 = get_safe_token(device->owner); |
| 97 | 105 | UINT8 data = 0; |
| 98 | 106 | |
| 107 | /* end or identify */ |
| 108 | data |= ieee488_eoi_r(vic1112->bus) << 3; |
| 109 | |
| 99 | 110 | /* data valid in */ |
| 100 | 111 | data |= ieee488_dav_r(vic1112->bus) << 4; |
| 101 | 112 | |
| r7035 | r7036 | |
| 159 | 170 | DEVCB_NULL, |
| 160 | 171 | DEVCB_NULL, |
| 161 | 172 | |
| 162 | | DEVCB_LINE(via_irq_w) |
| 173 | DEVCB_LINE(via0_irq_w) |
| 163 | 174 | }; |
| 164 | 175 | |
| 165 | 176 | /*------------------------------------------------- |
| 166 | 177 | via6522_interface vic1112_via1_intf |
| 167 | 178 | -------------------------------------------------*/ |
| 168 | 179 | |
| 169 | | static READ8_DEVICE_HANDLER( via1_pa_r ) |
| 180 | static WRITE_LINE_DEVICE_HANDLER( via1_irq_w ) |
| 170 | 181 | { |
| 182 | vic1112_t *vic1112 = get_safe_token(device->owner); |
| 183 | |
| 184 | vic1112->via1_irq = state; |
| 185 | |
| 186 | cpu_set_input_line(device->machine->firstcpu, M6502_IRQ_LINE, (vic1112->via0_irq | vic1112->via1_irq) ? ASSERT_LINE : CLEAR_LINE); |
| 187 | } |
| 188 | |
| 189 | static WRITE8_DEVICE_HANDLER( via1_pa_w ) |
| 190 | { |
| 171 | 191 | /* |
| 172 | 192 | |
| 173 | 193 | bit description |
| 174 | 194 | |
| 175 | | PA0 DI1 |
| 176 | | PA1 DI2 |
| 177 | | PA2 DI3 |
| 178 | | PA3 DI4 |
| 179 | | PA4 DI5 |
| 180 | | PA5 DI6 |
| 181 | | PA6 DI7 |
| 182 | | PA7 DI8 |
| 195 | PA0 DO1 |
| 196 | PA1 DO2 |
| 197 | PA2 DO3 |
| 198 | PA3 DO4 |
| 199 | PA4 DO5 |
| 200 | PA5 DO6 |
| 201 | PA6 DO7 |
| 202 | PA7 DO8 |
| 183 | 203 | |
| 184 | 204 | */ |
| 185 | 205 | |
| 186 | 206 | vic1112_t *vic1112 = get_safe_token(device->owner); |
| 187 | 207 | |
| 188 | | return ieee488_dio_r(vic1112->bus, 0); |
| 208 | ieee488_dio_w(vic1112->bus, device->owner, data); |
| 189 | 209 | } |
| 190 | 210 | |
| 191 | | static WRITE8_DEVICE_HANDLER( via1_pb_w ) |
| 211 | static READ8_DEVICE_HANDLER( via1_pb_r ) |
| 192 | 212 | { |
| 193 | 213 | /* |
| 194 | 214 | |
| 195 | 215 | bit description |
| 196 | 216 | |
| 197 | | PB0 DO1 |
| 198 | | PB1 DO2 |
| 199 | | PB2 DO3 |
| 200 | | PB3 DO4 |
| 201 | | PB4 DO5 |
| 202 | | PB5 DO6 |
| 203 | | PB6 DO7 |
| 204 | | PB7 DO8 |
| 217 | PB0 DI1 |
| 218 | PB1 DI2 |
| 219 | PB2 DI3 |
| 220 | PB3 DI4 |
| 221 | PB4 DI5 |
| 222 | PB5 DI6 |
| 223 | PB6 DI7 |
| 224 | PB7 DI8 |
| 205 | 225 | |
| 206 | 226 | */ |
| 207 | 227 | |
| 208 | 228 | vic1112_t *vic1112 = get_safe_token(device->owner); |
| 209 | 229 | |
| 210 | | ieee488_dio_w(vic1112->bus, 0, data); |
| 230 | return ieee488_dio_r(vic1112->bus, 0); |
| 211 | 231 | } |
| 212 | 232 | |
| 213 | 233 | static WRITE_LINE_DEVICE_HANDLER( via1_ca2_w ) |
| r7035 | r7036 | |
| 228 | 248 | |
| 229 | 249 | static const via6522_interface vic1112_via1_intf = |
| 230 | 250 | { |
| 231 | | DEVCB_HANDLER(via1_pa_r), |
| 232 | 251 | DEVCB_NULL, |
| 252 | DEVCB_HANDLER(via1_pb_r), |
| 233 | 253 | DEVCB_NULL, |
| 234 | 254 | DEVCB_NULL, /* _SRQ IN */ |
| 235 | 255 | DEVCB_NULL, |
| 236 | 256 | DEVCB_NULL, |
| 237 | 257 | |
| 258 | DEVCB_HANDLER(via1_pa_w), |
| 238 | 259 | DEVCB_NULL, |
| 239 | | DEVCB_HANDLER(via1_pb_w), |
| 240 | 260 | DEVCB_NULL, |
| 241 | 261 | DEVCB_NULL, |
| 242 | 262 | DEVCB_LINE(via1_ca2_w), |
| 243 | 263 | DEVCB_LINE(via1_cb2_w), |
| 244 | 264 | |
| 245 | | DEVCB_LINE(via_irq_w) |
| 265 | DEVCB_LINE(via1_irq_w) |
| 246 | 266 | }; |
| 247 | 267 | |
| 248 | 268 | /*------------------------------------------------- |
| r7035 | r7036 | |
| 283 | 303 | device_set_clock(vic1112->via1, cpu_get_clock(device->machine->firstcpu)); |
| 284 | 304 | |
| 285 | 305 | /* map VIAs to memory */ |
| 286 | | memory_install_readwrite8_device_handler(program, vic1112->via0, 0x9200, 0x920f, 0, 0, via_r, via_w); |
| 287 | | memory_install_readwrite8_device_handler(program, vic1112->via1, 0x9210, 0x921f, 0, 0, via_r, via_w); |
| 306 | memory_install_readwrite8_device_handler(program, vic1112->via0, 0x9800, 0x980f, 0, 0, via_r, via_w); |
| 307 | memory_install_readwrite8_device_handler(program, vic1112->via1, 0x9810, 0x981f, 0, 0, via_r, via_w); |
| 288 | 308 | |
| 289 | 309 | /* map ROM to memory */ |
| 290 | | memory_install_rom(program, 0xb000, 0xb7ff, 0, 0, memory_region(device->machine, VIC1112_TAG)); |
| 310 | memory_install_rom(program, 0xb000, 0xb7ff, 0, 0, memory_region(device->machine, "vic1112:vic1112")); |
| 311 | |
| 312 | /* register for state saving */ |
| 313 | state_save_register_device_item(device, 0, vic1112->via0_irq); |
| 314 | state_save_register_device_item(device, 0, vic1112->via1_irq); |
| 291 | 315 | } |
| 292 | 316 | |
| 293 | 317 | /*------------------------------------------------- |
src/mess/machine/c1541.c
| r7035 | r7036 | |
| 198 | 198 | /* serial bus */ |
| 199 | 199 | int data_out; /* serial bus data output */ |
| 200 | 200 | |
| 201 | /* IEEE-488 bus */ |
| 202 | int nrfd_out; /* not ready for data */ |
| 203 | int ndac_out; /* not data accepted */ |
| 204 | |
| 201 | 205 | /* devices */ |
| 202 | 206 | const device_config *cpu; |
| 203 | 207 | const device_config *via0; |
| r7035 | r7036 | |
| 323 | 327 | WRITE_LINE_DEVICE_HANDLER( c2031_ieee488_atn_w ) |
| 324 | 328 | { |
| 325 | 329 | c1541_t *c1541 = get_safe_token(device); |
| 330 | int nrfd = c1541->nrfd_out; |
| 331 | int ndac = c1541->ndac_out; |
| 326 | 332 | |
| 327 | | via_ca1_w(c1541->via0, state); |
| 333 | via_ca1_w(c1541->via0, !state); |
| 334 | |
| 335 | if (!state ^ c1541->atna) |
| 336 | { |
| 337 | nrfd = ndac = 0; |
| 338 | } |
| 339 | |
| 340 | ieee488_nrfd_w(c1541->bus, device, nrfd); |
| 341 | ieee488_ndac_w(c1541->bus, device, ndac); |
| 328 | 342 | } |
| 329 | 343 | |
| 330 | 344 | /*------------------------------------------------- |
| r7035 | r7036 | |
| 592 | 606 | |
| 593 | 607 | c1541_t *c1541 = get_safe_token(device->owner); |
| 594 | 608 | |
| 595 | | ieee488_dio_w(c1541->bus, 0, data); |
| 609 | ieee488_dio_w(c1541->bus, device->owner, data); |
| 596 | 610 | } |
| 597 | 611 | |
| 598 | 612 | static READ8_DEVICE_HANDLER( c2031_via0_pb_r ) |
| r7035 | r7036 | |
| 613 | 627 | */ |
| 614 | 628 | |
| 615 | 629 | c1541_t *c1541 = get_safe_token(device->owner); |
| 630 | |
| 616 | 631 | UINT8 data = 0; |
| 617 | 632 | |
| 618 | 633 | /* not ready for data */ |
| r7035 | r7036 | |
| 628 | 643 | data |= ieee488_dav_r(c1541->bus) << 6; |
| 629 | 644 | |
| 630 | 645 | /* attention */ |
| 631 | | data |= ieee488_atn_r(c1541->bus) << 7; |
| 646 | data |= !ieee488_atn_r(c1541->bus) << 7; |
| 632 | 647 | |
| 633 | 648 | return data; |
| 634 | 649 | } |
| r7035 | r7036 | |
| 652 | 667 | |
| 653 | 668 | c1541_t *c1541 = get_safe_token(device->owner); |
| 654 | 669 | |
| 655 | | /* attention acknowledge */ |
| 670 | int atna = BIT(data, 0); |
| 671 | int nrfd = BIT(data, 1); |
| 672 | int ndac = BIT(data, 2); |
| 656 | 673 | |
| 657 | 674 | /* not ready for data */ |
| 658 | | ieee488_nrfd_w(c1541->bus, device->owner, BIT(data, 1)); |
| 675 | c1541->nrfd_out = nrfd; |
| 659 | 676 | |
| 660 | 677 | /* not data accepted */ |
| 661 | | ieee488_ndac_w(c1541->bus, device->owner, BIT(data, 2)); |
| 678 | c1541->ndac_out = ndac; |
| 662 | 679 | |
| 663 | 680 | /* end or identify */ |
| 664 | 681 | ieee488_eoi_w(c1541->bus, device->owner, BIT(data, 3)); |
| 682 | |
| 683 | /* attention acknowledge */ |
| 684 | c1541->atna = atna; |
| 685 | |
| 686 | if (!ieee488_atn_r(c1541->bus) ^ atna) |
| 687 | { |
| 688 | nrfd = ndac = 0; |
| 689 | } |
| 690 | |
| 691 | ieee488_nrfd_w(c1541->bus, device->owner, nrfd); |
| 692 | ieee488_ndac_w(c1541->bus, device->owner, ndac); |
| 665 | 693 | } |
| 666 | 694 | |
| 667 | 695 | static READ_LINE_DEVICE_HANDLER( c2031_via0_ca1_r ) |
| r7035 | r7036 | |
| 673 | 701 | |
| 674 | 702 | static READ_LINE_DEVICE_HANDLER( c2031_via0_ca2_r ) |
| 675 | 703 | { |
| 704 | c1541_t *c1541 = get_safe_token(device->owner); |
| 705 | int state = 0; |
| 706 | |
| 676 | 707 | /* device # selection */ |
| 677 | | return 0; |
| 708 | switch (c1541->address) |
| 709 | { |
| 710 | case 8: state = (c1541->atna | c1541->nrfd_out); break; |
| 711 | case 9: state = c1541->atna; break; |
| 712 | case 10: state = c1541->nrfd_out; break; |
| 713 | case 11: state = 0; break; |
| 714 | } |
| 715 | |
| 716 | return state; |
| 678 | 717 | } |
| 679 | 718 | |
| 680 | 719 | static const via6522_interface c2031_via0_intf = |
| r7035 | r7036 | |
| 1112 | 1151 | state_save_register_device_item(device, 0, c1541->via0_irq); |
| 1113 | 1152 | state_save_register_device_item(device, 0, c1541->via1_irq); |
| 1114 | 1153 | state_save_register_device_item(device, 0, c1541->data_out); |
| 1154 | state_save_register_device_item(device, 0, c1541->nrfd_out); |
| 1155 | state_save_register_device_item(device, 0, c1541->ndac_out); |
| 1115 | 1156 | } |
| 1116 | 1157 | |
| 1117 | 1158 | /*------------------------------------------------- |
src/mess/machine/ieee488.c
| r7035 | r7036 | |
| 1 | 1 | /********************************************************************** |
| 2 | 2 | |
| 3 | | IEEE-488.1 bus emulation |
| 3 | IEEE-488.1 General Purpose Interface Bus emulation |
| 4 | (aka HP-IB, GPIB, CBM IEEE) |
| 4 | 5 | |
| 5 | 6 | Copyright MESS Team. |
| 6 | 7 | Visit http://mamedev.org for licensing and usage restrictions. |
| r7035 | r7036 | |
| 41 | 42 | ieee488_daisy_state *next; /* next device */ |
| 42 | 43 | const device_config *device; /* associated device */ |
| 43 | 44 | |
| 44 | | int line[SIGNAL_COUNT]; /* serial signal states */ |
| 45 | int line[SIGNAL_COUNT]; /* control lines' state */ |
| 46 | UINT8 dio; /* data lines' state */ |
| 45 | 47 | |
| 46 | 48 | devcb_resolved_write_line out_line_func[SIGNAL_COUNT]; |
| 47 | 49 | }; |
| r7035 | r7036 | |
| 50 | 52 | struct _ieee488_t |
| 51 | 53 | { |
| 52 | 54 | ieee488_daisy_state *daisy_state; |
| 53 | | UINT8 dio; |
| 54 | 55 | }; |
| 55 | 56 | |
| 56 | 57 | /*************************************************************************** |
| r7035 | r7036 | |
| 80 | 81 | |
| 81 | 82 | for ( ; daisy != NULL; daisy = daisy->next) |
| 82 | 83 | { |
| 83 | | if (!daisy->line[line]) |
| 84 | | { |
| 85 | | state = 0; |
| 86 | | break; |
| 87 | | } |
| 84 | state &= daisy->line[line]; |
| 88 | 85 | } |
| 89 | 86 | |
| 90 | 87 | return state; |
| 91 | 88 | } |
| 92 | 89 | |
| 90 | INLINE int get_data(const device_config *bus) |
| 91 | { |
| 92 | ieee488_t *ieee488 = get_safe_token(bus); |
| 93 | ieee488_daisy_state *daisy = ieee488->daisy_state; |
| 94 | UINT8 data = 0xff; |
| 95 | |
| 96 | for ( ; daisy != NULL; daisy = daisy->next) |
| 97 | { |
| 98 | data &= daisy->dio; |
| 99 | } |
| 100 | |
| 101 | return data; |
| 102 | } |
| 103 | |
| 93 | 104 | INLINE void set_signal(const device_config *bus, const device_config *device, int line, int state) |
| 94 | 105 | { |
| 95 | 106 | ieee488_t *ieee488 = get_safe_token(bus); |
| 96 | 107 | ieee488_daisy_state *daisy = ieee488->daisy_state; |
| 97 | | int data = 1; |
| 108 | int new_state = 1; |
| 98 | 109 | |
| 99 | 110 | for ( ; daisy != NULL; daisy = daisy->next) |
| 100 | 111 | { |
| r7035 | r7036 | |
| 109 | 120 | } |
| 110 | 121 | } |
| 111 | 122 | |
| 112 | | data = get_signal(bus, line); |
| 123 | new_state = get_signal(bus, line); |
| 113 | 124 | daisy = ieee488->daisy_state; |
| 114 | 125 | |
| 115 | 126 | for ( ; daisy != NULL; daisy = daisy->next) |
| 116 | 127 | { |
| 117 | | devcb_call_write_line(&daisy->out_line_func[line], data); |
| 128 | devcb_call_write_line(&daisy->out_line_func[line], new_state); |
| 118 | 129 | } |
| 119 | 130 | |
| 120 | 131 | if (LOG) logerror("IEEE-488: EOI %u DAV %u NRFD %u NDAC %u IFC %u SRQ %u ATN %u REN %u DIO %02x\n", |
| 121 | 132 | get_signal(bus, EOI), get_signal(bus, DAV), get_signal(bus, NRFD), get_signal(bus, NDAC), |
| 122 | | get_signal(bus, IFC), get_signal(bus, SRQ), get_signal(bus, ATN), get_signal(bus, REN), ieee488->dio); |
| 133 | get_signal(bus, IFC), get_signal(bus, SRQ), get_signal(bus, ATN), get_signal(bus, REN), get_data(bus)); |
| 123 | 134 | } |
| 124 | 135 | |
| 136 | INLINE void set_data(const device_config *bus, const device_config *device, UINT8 data) |
| 137 | { |
| 138 | ieee488_t *ieee488 = get_safe_token(bus); |
| 139 | ieee488_daisy_state *daisy = ieee488->daisy_state; |
| 140 | |
| 141 | for ( ; daisy != NULL; daisy = daisy->next) |
| 142 | { |
| 143 | if (!strcmp(daisy->device->tag, device->tag)) |
| 144 | { |
| 145 | if (LOG) logerror("IEEE-488: '%s' DIO %02x\n", device->tag, data); |
| 146 | daisy->dio = data; |
| 147 | break; |
| 148 | } |
| 149 | } |
| 150 | |
| 151 | if (LOG) logerror("IEEE-488: EOI %u DAV %u NRFD %u NDAC %u IFC %u SRQ %u ATN %u REN %u DIO %02x\n", |
| 152 | get_signal(bus, EOI), get_signal(bus, DAV), get_signal(bus, NRFD), get_signal(bus, NDAC), |
| 153 | get_signal(bus, IFC), get_signal(bus, SRQ), get_signal(bus, ATN), get_signal(bus, REN), get_data(bus)); |
| 154 | } |
| 155 | |
| 125 | 156 | /*************************************************************************** |
| 126 | 157 | IMPLEMENTATION |
| 127 | 158 | ***************************************************************************/ |
| 128 | 159 | |
| 129 | | void ieee488_eoi_w(const device_config *ieee488, const device_config *device, int state) |
| 160 | void ieee488_eoi_w(const device_config *bus, const device_config *device, int state) |
| 130 | 161 | { |
| 131 | | set_signal(ieee488, device, EOI, state); |
| 162 | set_signal(bus, device, EOI, state); |
| 132 | 163 | } |
| 133 | 164 | |
| 134 | 165 | READ_LINE_DEVICE_HANDLER( ieee488_eoi_r ) |
| r7035 | r7036 | |
| 136 | 167 | return get_signal(device, EOI); |
| 137 | 168 | } |
| 138 | 169 | |
| 139 | | void ieee488_dav_w(const device_config *ieee488, const device_config *device, int state) |
| 170 | void ieee488_dav_w(const device_config *bus, const device_config *device, int state) |
| 140 | 171 | { |
| 141 | | set_signal(ieee488, device, DAV, state); |
| 172 | set_signal(bus, device, DAV, state); |
| 142 | 173 | } |
| 143 | 174 | |
| 144 | 175 | READ_LINE_DEVICE_HANDLER( ieee488_dav_r ) |
| r7035 | r7036 | |
| 146 | 177 | return get_signal(device, DAV); |
| 147 | 178 | } |
| 148 | 179 | |
| 149 | | void ieee488_nrfd_w(const device_config *ieee488, const device_config *device, int state) |
| 180 | void ieee488_nrfd_w(const device_config *bus, const device_config *device, int state) |
| 150 | 181 | { |
| 151 | | set_signal(ieee488, device, NRFD, state); |
| 182 | set_signal(bus, device, NRFD, state); |
| 152 | 183 | } |
| 153 | 184 | |
| 154 | 185 | READ_LINE_DEVICE_HANDLER( ieee488_nrfd_r ) |
| r7035 | r7036 | |
| 156 | 187 | return get_signal(device, NRFD); |
| 157 | 188 | } |
| 158 | 189 | |
| 159 | | void ieee488_ndac_w(const device_config *ieee488, const device_config *device, int state) |
| 190 | void ieee488_ndac_w(const device_config *bus, const device_config *device, int state) |
| 160 | 191 | { |
| 161 | | set_signal(ieee488, device, NDAC, state); |
| 192 | set_signal(bus, device, NDAC, state); |
| 162 | 193 | } |
| 163 | 194 | |
| 164 | 195 | READ_LINE_DEVICE_HANDLER( ieee488_ndac_r ) |
| r7035 | r7036 | |
| 166 | 197 | return get_signal(device, NDAC); |
| 167 | 198 | } |
| 168 | 199 | |
| 169 | | void ieee488_ifc_w(const device_config *ieee488, const device_config *device, int state) |
| 200 | void ieee488_ifc_w(const device_config *bus, const device_config *device, int state) |
| 170 | 201 | { |
| 171 | | set_signal(ieee488, device, IFC, state); |
| 202 | set_signal(bus, device, IFC, state); |
| 172 | 203 | } |
| 173 | 204 | |
| 174 | 205 | READ_LINE_DEVICE_HANDLER( ieee488_ifc_r ) |
| r7035 | r7036 | |
| 176 | 207 | return get_signal(device, IFC); |
| 177 | 208 | } |
| 178 | 209 | |
| 179 | | void ieee488_srq_w(const device_config *ieee488, const device_config *device, int state) |
| 210 | void ieee488_srq_w(const device_config *bus, const device_config *device, int state) |
| 180 | 211 | { |
| 181 | | set_signal(ieee488, device, SRQ, state); |
| 212 | set_signal(bus, device, SRQ, state); |
| 182 | 213 | } |
| 183 | 214 | |
| 184 | 215 | READ_LINE_DEVICE_HANDLER( ieee488_srq_r ) |
| r7035 | r7036 | |
| 186 | 217 | return get_signal(device, SRQ); |
| 187 | 218 | } |
| 188 | 219 | |
| 189 | | void ieee488_atn_w(const device_config *ieee488, const device_config *device, int state) |
| 220 | void ieee488_atn_w(const device_config *bus, const device_config *device, int state) |
| 190 | 221 | { |
| 191 | | set_signal(ieee488, device, ATN, state); |
| 222 | set_signal(bus, device, ATN, state); |
| 192 | 223 | } |
| 193 | 224 | |
| 194 | 225 | READ_LINE_DEVICE_HANDLER( ieee488_atn_r ) |
| r7035 | r7036 | |
| 196 | 227 | return get_signal(device, ATN); |
| 197 | 228 | } |
| 198 | 229 | |
| 199 | | void ieee488_ren_w(const device_config *ieee488, const device_config *device, int state) |
| 230 | void ieee488_ren_w(const device_config *bus, const device_config *device, int state) |
| 200 | 231 | { |
| 201 | | set_signal(ieee488, device, REN, state); |
| 232 | set_signal(bus, device, REN, state); |
| 202 | 233 | } |
| 203 | 234 | |
| 204 | 235 | READ_LINE_DEVICE_HANDLER( ieee488_ren_r ) |
| r7035 | r7036 | |
| 208 | 239 | |
| 209 | 240 | READ8_DEVICE_HANDLER( ieee488_dio_r ) |
| 210 | 241 | { |
| 211 | | ieee488_t *ieee488 = get_safe_token(device); |
| 212 | | |
| 213 | | return ieee488->dio; |
| 242 | return get_data(device); |
| 214 | 243 | } |
| 215 | 244 | |
| 216 | | WRITE8_DEVICE_HANDLER( ieee488_dio_w ) |
| 245 | void ieee488_dio_w(const device_config *bus, const device_config *device, UINT8 data) |
| 217 | 246 | { |
| 218 | | ieee488_t *ieee488 = get_safe_token(device); |
| 219 | | |
| 220 | | ieee488->dio = data; |
| 247 | set_data(bus, device, data); |
| 221 | 248 | } |
| 222 | 249 | |
| 223 | 250 | /*------------------------------------------------- |
| r7035 | r7036 | |
| 239 | 266 | { |
| 240 | 267 | *tailptr = auto_alloc(device->machine, ieee488_daisy_state); |
| 241 | 268 | |
| 269 | /* find device */ |
| 242 | 270 | (*tailptr)->next = NULL; |
| 243 | 271 | (*tailptr)->device = devtag_get_device(device->machine, daisy->tag); |
| 244 | 272 | |
| r7035 | r7036 | |
| 248 | 276 | fatalerror("Unable to locate device '%s'", daisy->tag); |
| 249 | 277 | } |
| 250 | 278 | |
| 251 | | for (i = SRQ; i < SIGNAL_COUNT; i++) |
| 279 | /* set control lines to 'false' state */ |
| 280 | for (i = EOI; i < SIGNAL_COUNT; i++) |
| 252 | 281 | { |
| 253 | 282 | (*tailptr)->line[i] = 1; |
| 254 | 283 | } |
| 255 | 284 | |
| 285 | /* set data lines to 'false' state */ |
| 286 | (*tailptr)->dio = 0xff; |
| 287 | |
| 288 | /* resolve callbacks */ |
| 256 | 289 | devcb_resolve_write_line(&(*tailptr)->out_line_func[EOI], &daisy->out_eoi_func, device); |
| 257 | 290 | devcb_resolve_write_line(&(*tailptr)->out_line_func[DAV], &daisy->out_dav_func, device); |
| 258 | 291 | devcb_resolve_write_line(&(*tailptr)->out_line_func[NRFD], &daisy->out_nrfd_func, device); |
| r7035 | r7036 | |
| 270 | 303 | astring_free(tempstring); |
| 271 | 304 | |
| 272 | 305 | /* register for state saving */ |
| 273 | | state_save_register_device_item(device, 0, ieee488->dio); |
| 306 | // state_save_register_device_item(device, 0, ieee488->); |
| 274 | 307 | } |
| 275 | 308 | |
| 276 | 309 | /*------------------------------------------------- |
src/mess/machine/ieee488.h
| r7035 | r7036 | |
| 1 | 1 | /********************************************************************** |
| 2 | 2 | |
| 3 | | IEEE-488.1 bus emulation |
| 3 | IEEE-488.1 General Purpose Interface Bus emulation |
| 4 | (aka HP-IB, GPIB, CBM IEEE) |
| 4 | 5 | |
| 5 | 6 | Copyright MESS Team. |
| 6 | 7 | Visit http://mamedev.org for licensing and usage restrictions. |
| r7035 | r7036 | |
| 52 | 53 | DEVICE_GET_INFO( ieee488 ); |
| 53 | 54 | |
| 54 | 55 | /* end or identify */ |
| 55 | | void ieee488_eoi_w(const device_config *ieee488, const device_config *device, int state); |
| 56 | void ieee488_eoi_w(const device_config *bus, const device_config *device, int state); |
| 56 | 57 | READ_LINE_DEVICE_HANDLER( ieee488_eoi_r ); |
| 57 | 58 | |
| 58 | 59 | /* data valid */ |
| 59 | | void ieee488_dav_w(const device_config *ieee488, const device_config *device, int state); |
| 60 | void ieee488_dav_w(const device_config *bus, const device_config *device, int state); |
| 60 | 61 | READ_LINE_DEVICE_HANDLER( ieee488_dav_r ); |
| 61 | 62 | |
| 62 | 63 | /* not ready for data */ |
| 63 | | void ieee488_nrfd_w(const device_config *ieee488, const device_config *device, int state); |
| 64 | void ieee488_nrfd_w(const device_config *bus, const device_config *device, int state); |
| 64 | 65 | READ_LINE_DEVICE_HANDLER( ieee488_nrfd_r ); |
| 65 | 66 | |
| 66 | 67 | /* not data accepted */ |
| 67 | | void ieee488_ndac_w(const device_config *ieee488, const device_config *device, int state); |
| 68 | void ieee488_ndac_w(const device_config *bus, const device_config *device, int state); |
| 68 | 69 | READ_LINE_DEVICE_HANDLER( ieee488_ndac_r ); |
| 69 | 70 | |
| 70 | 71 | /* interface clear */ |
| 71 | | void ieee488_ifc_w(const device_config *ieee488, const device_config *device, int state); |
| 72 | void ieee488_ifc_w(const device_config *bus, const device_config *device, int state); |
| 72 | 73 | READ_LINE_DEVICE_HANDLER( ieee488_ifc_r ); |
| 73 | 74 | |
| 74 | 75 | /* service request */ |
| 75 | | void ieee488_srq_w(const device_config *ieee488, const device_config *device, int state); |
| 76 | void ieee488_srq_w(const device_config *bus, const device_config *device, int state); |
| 76 | 77 | READ_LINE_DEVICE_HANDLER( ieee488_srq_r ); |
| 77 | 78 | |
| 78 | 79 | /* attention */ |
| 79 | | void ieee488_atn_w(const device_config *ieee488, const device_config *device, int state); |
| 80 | void ieee488_atn_w(const device_config *bus, const device_config *device, int state); |
| 80 | 81 | READ_LINE_DEVICE_HANDLER( ieee488_atn_r ); |
| 81 | 82 | |
| 82 | 83 | /* remote enable */ |
| 83 | | void ieee488_ren_w(const device_config *ieee488, const device_config *device, int state); |
| 84 | void ieee488_ren_w(const device_config *bus, const device_config *device, int state); |
| 84 | 85 | READ_LINE_DEVICE_HANDLER( ieee488_ren_r ); |
| 85 | 86 | |
| 86 | 87 | /* data */ |
| 87 | 88 | READ8_DEVICE_HANDLER( ieee488_dio_r ); |
| 88 | | WRITE8_DEVICE_HANDLER( ieee488_dio_w ); |
| 89 | void ieee488_dio_w(const device_config *bus, const device_config *device, UINT8 data); |
| 89 | 90 | |
| 90 | 91 | #endif |