src/mess/machine/zx8302.c
| r1705 | r1706 | |
| 1 | | #include "driver.h"
|
| 2 | | #include "zx8302.h"
|
| 3 | | #include <time.h>
|
| 4 | | |
| 5 | | #define ZX8302_BAUD_19200 0x00
|
| 6 | | #define ZX8302_BAUD_9600 0x01
|
| 7 | | #define ZX8302_BAUD_4800 0x02
|
| 8 | | #define ZX8302_BAUD_2400 0x03
|
| 9 | | #define ZX8302_BAUD_1200 0x04
|
| 10 | | #define ZX8302_BAUD_600 0x05
|
| 11 | | #define ZX8302_BAUD_300 0x06
|
| 12 | | #define ZX8302_BAUD_75 0x07
|
| 13 | | #define ZX8302_BAUD_MASK 0x07
|
| 14 | | |
| 15 | | #define ZX8302_MODE_SER1 0x00
|
| 16 | | #define ZX8302_MODE_SER2 0x08
|
| 17 | | #define ZX8302_MODE_MDV 0x10
|
| 18 | | #define ZX8302_MODE_NET 0x18
|
| 19 | | #define ZX8302_MODE_MASK 0x18
|
| 20 | | |
| 21 | | #define ZX8302_INT_GAP 0x01
|
| 22 | | #define ZX8302_INT_INTERFACE 0x02
|
| 23 | | #define ZX8302_INT_TRANSMIT 0x04
|
| 24 | | #define ZX8302_INT_FRAME 0x08
|
| 25 | | #define ZX8302_INT_EXTERNAL 0x10
|
| 26 | | |
| 27 | | #define ZX8302_STATUS_NETWORK_PORT 0x01
|
| 28 | | #define ZX8302_STATUS_TX_BUFFER_FULL 0x02
|
| 29 | | #define ZX8302_STATUS_RX_BUFFER_FULL 0x04
|
| 30 | | #define ZX8302_STATUS_MICRODRIVE_GAP 0x08
|
| 31 | | |
| 32 | | #define ZX8302_TXD_START 0
|
| 33 | | #define ZX8302_TXD_STOP 9
|
| 34 | | #define ZX8302_TXD_STOP2 10
|
| 35 | | |
| 36 | | #define MDV_SECTOR_COUNT 255
|
| 37 | | #define MDV_SECTOR_LENGTH 686
|
| 38 | | #define MDV_IMAGE_LENGTH (MDV_SECTOR_COUNT * MDV_SECTOR_LENGTH)
|
| 39 | | |
| 40 | | #define MDV_PREAMBLE_LENGTH 12
|
| 41 | | #define MDV_GAP_LENGTH 120
|
| 42 | | |
| 43 | | #define MDV_OFFSET_HEADER_PREAMBLE 0
|
| 44 | | #define MDV_OFFSET_HEADER MDV_OFFSET_HEADER_PREAMBLE + MDV_PREAMBLE_LENGTH
|
| 45 | | #define MDV_OFFSET_DATA_PREAMBLE 28
|
| 46 | | #define MDV_OFFSET_DATA MDV_OFFSET_DATA_PREAMBLE + MDV_PREAMBLE_LENGTH
|
| 47 | | #define MDV_OFFSET_GAP 566
|
| 48 | | |
| 49 | | static struct ZX8302
|
| 50 | | {
|
| 51 | | const zx8302_interface *intf;
|
| 52 | | |
| 53 | | UINT8 tcr;
|
| 54 | | UINT8 tdr;
|
| 55 | | UINT8 irq;
|
| 56 | | UINT32 ctr;
|
| 57 | | UINT8 idr;
|
| 58 | | UINT8 status;
|
| 59 | | int tx_bits;
|
| 60 | | int ser1_rxd, ser1_cts;
|
| 61 | | int ser2_txd, ser2_dtr;
|
| 62 | | int netout, netin;
|
| 63 | | int mdrdw, mdselck, mdseld, erase;
|
| 64 | | int mdv_motor, mdv_offset;
|
| 65 | | } zx8302;
|
| 66 | | |
| 67 | | static emu_timer *zx8302_txd_timer, *zx8302_ipc_timer, *zx8302_rtc_timer, *zx8302_gap_timer;
|
| 68 | | |
| 69 | | static UINT8 *mdv_image;
|
| 70 | | |
| 71 | | /* Interrupts */
|
| 72 | | |
| 73 | | READ8_HANDLER( zx8302_irq_status_r )
|
| 74 | | {
|
| 75 | | return zx8302.irq;
|
| 76 | | }
|
| 77 | | |
| 78 | | WRITE8_HANDLER( zx8302_irq_acknowledge_w )
|
| 79 | | {
|
| 80 | | zx8302.irq &= ~data;
|
| 81 | | |
| 82 | | if (!zx8302.irq)
|
| 83 | | {
|
| 84 | | zx8302.intf->irq_callback(CLEAR_LINE);
|
| 85 | | }
|
| 86 | | }
|
| 87 | | |
| 88 | | static void zx8302_interrupt(UINT8 line)
|
| 89 | | {
|
| 90 | | zx8302.irq |= line;
|
| 91 | | zx8302.intf->irq_callback(HOLD_LINE);
|
| 92 | | }
|
| 93 | | |
| 94 | | INTERRUPT_GEN( zx8302_int ) // remove this!
|
| 95 | | {
|
| 96 | | zx8302_interrupt(ZX8302_INT_FRAME);
|
| 97 | | }
|
| 98 | | |
| 99 | | void zx8302_vsync_w(void)
|
| 100 | | {
|
| 101 | | zx8302_interrupt(ZX8302_INT_FRAME);
|
| 102 | | }
|
| 103 | | |
| 104 | | /* IPC */
|
| 105 | | |
| 106 | | static TIMER_CALLBACK( zx8302_ipc_tick )
|
| 107 | | {
|
| 108 | | *zx8302.intf->baudx4 = !(*zx8302.intf->baudx4);
|
| 109 | | }
|
| 110 | | |
| 111 | | static TIMER_CALLBACK( zx8302_delayed_ipc_command )
|
| 112 | | {
|
| 113 | | zx8302.idr = param;
|
| 114 | | *zx8302.intf->comdata = BIT(zx8302.idr, 1);
|
| 115 | | }
|
| 116 | | |
| 117 | | WRITE8_HANDLER( zx8302_ipc_command_w )
|
| 118 | | {
|
| 119 | | timer_set(ATTOTIME_IN_NSEC(480), NULL, data, zx8302_delayed_ipc_command);
|
| 120 | | *zx8302.intf->comdata = BIT(data, 0);
|
| 121 | | }
|
| 122 | | |
| 123 | | /* Serial */
|
| 124 | | |
| 125 | | static void zx8302_txd(int level)
|
| 126 | | {
|
| 127 | | switch (zx8302.tcr & ZX8302_MODE_MASK)
|
| 128 | | {
|
| 129 | | case ZX8302_MODE_SER1:
|
| 130 | | zx8302.ser1_rxd = level;
|
| 131 | | break;
|
| 132 | | |
| 133 | | case ZX8302_MODE_SER2:
|
| 134 | | zx8302.ser2_txd = level;
|
| 135 | | break;
|
| 136 | | |
| 137 | | case ZX8302_MODE_MDV:
|
| 138 | | // TODO
|
| 139 | | break;
|
| 140 | | |
| 141 | | case ZX8302_MODE_NET:
|
| 142 | | zx8302.netout = level;
|
| 143 | | break;
|
| 144 | | }
|
| 145 | | }
|
| 146 | | |
| 147 | | static TIMER_CALLBACK( zx8302_txd_tick )
|
| 148 | | {
|
| 149 | | switch (zx8302.tx_bits)
|
| 150 | | {
|
| 151 | | case ZX8302_TXD_START:
|
| 152 | | if (!(zx8302.irq & ZX8302_INT_TRANSMIT))
|
| 153 | | {
|
| 154 | | zx8302_txd(0);
|
| 155 | | zx8302.tx_bits++;
|
| 156 | | }
|
| 157 | | break;
|
| 158 | | |
| 159 | | default:
|
| 160 | | zx8302_txd(BIT(zx8302.tdr, 0));
|
| 161 | | zx8302.tdr >>= 1;
|
| 162 | | zx8302.tx_bits++;
|
| 163 | | break;
|
| 164 | | |
| 165 | | case ZX8302_TXD_STOP:
|
| 166 | | zx8302_txd(1);
|
| 167 | | zx8302.tx_bits++;
|
| 168 | | break;
|
| 169 | | |
| 170 | | case ZX8302_TXD_STOP2:
|
| 171 | | zx8302_txd(1);
|
| 172 | | zx8302.tx_bits = ZX8302_TXD_START;
|
| 173 | | zx8302.status &= ~ZX8302_STATUS_TX_BUFFER_FULL;
|
| 174 | | zx8302_interrupt(ZX8302_INT_TRANSMIT);
|
| 175 | | break;
|
| 176 | | }
|
| 177 | | }
|
| 178 | | |
| 179 | | WRITE8_HANDLER( zx8302_data_w )
|
| 180 | | {
|
| 181 | | zx8302.tdr = data;
|
| 182 | | zx8302.status |= ZX8302_STATUS_TX_BUFFER_FULL;
|
| 183 | | }
|
| 184 | | |
| 185 | | WRITE8_HANDLER( zx8302_control_w )
|
| 186 | | {
|
| 187 | | int baud = (19200 >> (data & ZX8302_BAUD_MASK));
|
| 188 | | int baudx4 = baud * 4;
|
| 189 | | |
| 190 | | zx8302.tcr = data;
|
| 191 | | |
| 192 | | timer_adjust_periodic(zx8302_txd_timer, attotime_zero, 0, ATTOTIME_IN_HZ(baud));
|
| 193 | | timer_adjust_periodic(zx8302_ipc_timer, attotime_zero, 0, ATTOTIME_IN_HZ(baudx4));
|
| 194 | | }
|
| 195 | | |
| 196 | | /* Real Time Clock */
|
| 197 | | |
| 198 | | static TIMER_CALLBACK( zx8302_rtc_tick )
|
| 199 | | {
|
| 200 | | zx8302.ctr++;
|
| 201 | | }
|
| 202 | | |
| 203 | | READ8_HANDLER( zx8302_rtc_r )
|
| 204 | | {
|
| 205 | | switch (offset)
|
| 206 | | {
|
| 207 | | case 0:
|
| 208 | | return (zx8302.ctr >> 24) & 0xff;
|
| 209 | | case 1:
|
| 210 | | return (zx8302.ctr >> 16) & 0xff;
|
| 211 | | case 2:
|
| 212 | | return (zx8302.ctr >> 8) & 0xff;
|
| 213 | | case 3:
|
| 214 | | return zx8302.ctr;
|
| 215 | | }
|
| 216 | | |
| 217 | | return 0;
|
| 218 | | }
|
| 219 | | |
| 220 | | WRITE8_HANDLER( zx8302_rtc_w )
|
| 221 | | {
|
| 222 | | // TODO
|
| 223 | | }
|
| 224 | | |
| 225 | | /* Microdrive */
|
| 226 | | |
| 227 | | static TIMER_CALLBACK( zx8302_gap_tick )
|
| 228 | | {
|
| 229 | | if (zx8302.mdv_motor)
|
| 230 | | {
|
| 231 | | zx8302_interrupt(ZX8302_INT_GAP);
|
| 232 | | }
|
| 233 | | }
|
| 234 | | |
| 235 | | static UINT8 zx8302_get_microdrive_status(void)
|
| 236 | | {
|
| 237 | | UINT8 status = 0;
|
| 238 | | |
| 239 | | if (zx8302.mdv_motor)
|
| 240 | | {
|
| 241 | | switch (zx8302.mdv_offset % MDV_SECTOR_LENGTH)
|
| 242 | | {
|
| 243 | | case MDV_OFFSET_HEADER_PREAMBLE:
|
| 244 | | zx8302.status &= ~ZX8302_STATUS_MICRODRIVE_GAP;
|
| 245 | | zx8302.mdv_offset += MDV_PREAMBLE_LENGTH;
|
| 246 | | break;
|
| 247 | | |
| 248 | | case MDV_OFFSET_HEADER:
|
| 249 | | zx8302.status |= ZX8302_STATUS_RX_BUFFER_FULL;
|
| 250 | | break;
|
| 251 | | |
| 252 | | case MDV_OFFSET_DATA_PREAMBLE:
|
| 253 | | zx8302.status &= ~ZX8302_STATUS_RX_BUFFER_FULL;
|
| 254 | | zx8302.mdv_offset += MDV_PREAMBLE_LENGTH;
|
| 255 | | break;
|
| 256 | | |
| 257 | | case MDV_OFFSET_DATA:
|
| 258 | | zx8302.status |= ZX8302_STATUS_RX_BUFFER_FULL;
|
| 259 | | break;
|
| 260 | | |
| 261 | | case MDV_OFFSET_GAP:
|
| 262 | | zx8302.status &= ~ZX8302_STATUS_RX_BUFFER_FULL;
|
| 263 | | zx8302.status |= ZX8302_STATUS_MICRODRIVE_GAP;
|
| 264 | | zx8302.mdv_offset += MDV_GAP_LENGTH;
|
| 265 | | break;
|
| 266 | | }
|
| 267 | | }
|
| 268 | | |
| 269 | | return status;
|
| 270 | | }
|
| 271 | | |
| 272 | | READ8_HANDLER( zx8302_mdv_track_r )
|
| 273 | | {
|
| 274 | | UINT8 data = mdv_image[zx8302.mdv_offset];
|
| 275 | | |
| 276 | | zx8302.mdv_offset++;
|
| 277 | | |
| 278 | | if (zx8302.mdv_offset == MDV_IMAGE_LENGTH)
|
| 279 | | {
|
| 280 | | zx8302.mdv_offset = 0;
|
| 281 | | }
|
| 282 | | |
| 283 | | return data;
|
| 284 | | }
|
| 285 | | |
| 286 | | /*
|
| 287 | | static int zx8302_get_selected_microdrive(void)
|
| 288 | | {
|
| 289 | | int i;
|
| 290 | | |
| 291 | | for (i = 0; i < 8; i++)
|
| 292 | | {
|
| 293 | | if (BIT(zx8302.mdv_motor, i)) return 8 - i;
|
| 294 | | }
|
| 295 | | |
| 296 | | return 0;
|
| 297 | | }
|
| 298 | | */
|
| 299 | | |
| 300 | | WRITE8_HANDLER( zx8302_mdv_control_w )
|
| 301 | | {
|
| 302 | | /*
|
| 303 | | |
| 304 | | bit description
|
| 305 | | |
| 306 | | 0 MDSELDH
|
| 307 | | 1 MDSELCKH
|
| 308 | | 2 MDRDWL
|
| 309 | | 3 ERASE
|
| 310 | | 4
|
| 311 | | 5
|
| 312 | | 6
|
| 313 | | 7
|
| 314 | | |
| 315 | | */
|
| 316 | | |
| 317 | | zx8302.mdseld = BIT(data, 0);
|
| 318 | | zx8302.mdselck = BIT(data, 1);
|
| 319 | | zx8302.mdrdw = BIT(data, 2) ? 0 : 1;
|
| 320 | | zx8302.erase = BIT(data, 3);
|
| 321 | | |
| 322 | | // Microdrive selection shift register
|
| 323 | | |
| 324 | | if (zx8302.mdselck)
|
| 325 | | {
|
| 326 | | zx8302.mdv_motor >>= 1;
|
| 327 | | zx8302.mdv_motor |= (zx8302.mdseld << 7);
|
| 328 | | |
| 329 | | zx8302.mdv_offset = 0;
|
| 330 | | zx8302.status &= ~ZX8302_STATUS_RX_BUFFER_FULL;
|
| 331 | | }
|
| 332 | | }
|
| 333 | | |
| 334 | | static DEVICE_LOAD( zx8302_microdrive )
|
| 335 | | {
|
| 336 | | int filesize = image_length(image);
|
| 337 | | |
| 338 | | if (filesize == MDV_IMAGE_LENGTH)
|
| 339 | | {
|
| 340 | | if (image_fread(image, mdv_image, filesize) == filesize)
|
| 341 | | {
|
| 342 | | return INIT_PASS;
|
| 343 | | }
|
| 344 | | }
|
| 345 | | |
| 346 | | return INIT_FAIL;
|
| 347 | | }
|
| 348 | | |
| 349 | | void zx8302_microdrive_getinfo(const device_class *devclass, UINT32 state, union devinfo *info)
|
| 350 | | {
|
| 351 | | switch(state)
|
| 352 | | {
|
| 353 | | /* --- the following bits of info are returned as 64-bit signed integers --- */
|
| 354 | | case DEVINFO_INT_TYPE: info->i = IO_CASSETTE; break;
|
| 355 | | case DEVINFO_INT_COUNT: info->i = 1; break;
|
| 356 | | |
| 357 | | case DEVINFO_INT_READABLE: info->i = 1; break;
|
| 358 | | case DEVINFO_INT_WRITEABLE: info->i = 0; break;
|
| 359 | | case DEVINFO_INT_CREATABLE: info->i = 0; break;
|
| 360 | | |
| 361 | | /* --- the following bits of info are returned as pointers to data or functions --- */
|
| 362 | | case DEVINFO_PTR_LOAD: info->load = device_load_zx8302_microdrive; break;
|
| 363 | | |
| 364 | | /* --- the following bits of info are returned as NULL-terminated strings --- */
|
| 365 | | case DEVINFO_STR_FILE_EXTENSIONS: strcpy(info->s = device_temp_str(), "mdv"); break;
|
| 366 | | }
|
| 367 | | }
|
| 368 | | |
| 369 | | /* Status */
|
| 370 | | |
| 371 | | READ8_HANDLER( zx8302_status_r )
|
| 372 | | {
|
| 373 | | /*
|
| 374 | | |
| 375 | | bit description
|
| 376 | | |
| 377 | | 0 Network port
|
| 378 | | 1 Transmit buffer full
|
| 379 | | 2 Receive buffer full
|
| 380 | | 3 Microdrive GAP
|
| 381 | | 4 SER1 DTR
|
| 382 | | 5 SER2 CTS
|
| 383 | | 6 Latched COMCTL
|
| 384 | | 7 Latched COMDATA
|
| 385 | | |
| 386 | | */
|
| 387 | | |
| 388 | | UINT8 data = 0;
|
| 389 | | |
| 390 | | data |= *zx8302.intf->comdata << 7;
|
| 391 | | data |= *zx8302.intf->comctl << 6;
|
| 392 | | data |= zx8302.ser1_cts << 5;
|
| 393 | | data |= zx8302.ser2_dtr << 4;
|
| 394 | | data |= zx8302_get_microdrive_status();
|
| 395 | | data |= zx8302.status;
|
| 396 | | |
| 397 | | *zx8302.intf->comctl = 1;
|
| 398 | | |
| 399 | | return data;
|
| 400 | | }
|
| 401 | | |
| 402 | | /* Configuration */
|
| 403 | | |
| 404 | | void zx8302_config(const zx8302_interface *intf)
|
| 405 | | {
|
| 406 | | state_save_register_global(zx8302.tcr);
|
| 407 | | state_save_register_global(zx8302.tdr);
|
| 408 | | state_save_register_global(zx8302.irq);
|
| 409 | | state_save_register_global(zx8302.ctr);
|
| 410 | | state_save_register_global(zx8302.idr);
|
| 411 | | state_save_register_global(zx8302.tx_bits);
|
| 412 | | state_save_register_global(zx8302.ser1_rxd);
|
| 413 | | state_save_register_global(zx8302.ser1_cts);
|
| 414 | | state_save_register_global(zx8302.ser2_txd);
|
| 415 | | state_save_register_global(zx8302.ser2_dtr);
|
| 416 | | state_save_register_global(zx8302.netout);
|
| 417 | | state_save_register_global(zx8302.netin);
|
| 418 | | state_save_register_global(zx8302.mdrdw);
|
| 419 | | state_save_register_global(zx8302.mdselck);
|
| 420 | | state_save_register_global(zx8302.mdseld);
|
| 421 | | state_save_register_global(zx8302.erase);
|
| 422 | | state_save_register_global(zx8302.mdv_motor);
|
| 423 | | state_save_register_global(zx8302.mdv_offset);
|
| 424 | | |
| 425 | | memset(&zx8302, 0, sizeof(zx8302));
|
| 426 | | |
| 427 | | zx8302_txd_timer = timer_alloc(zx8302_txd_tick, NULL);
|
| 428 | | zx8302_ipc_timer = timer_alloc(zx8302_ipc_tick, NULL);
|
| 429 | | zx8302_rtc_timer = timer_alloc(zx8302_rtc_tick, NULL);
|
| 430 | | zx8302_gap_timer = timer_alloc(zx8302_gap_tick, NULL);
|
| 431 | | |
| 432 | | zx8302.intf = intf;
|
| 433 | | |
| 434 | | timer_adjust_periodic(zx8302_rtc_timer, attotime_zero, 0, ATTOTIME_IN_HZ(intf->rtc_clock/32768));
|
| 435 | | timer_adjust_periodic(zx8302_gap_timer, attotime_zero, 0, ATTOTIME_IN_MSEC(31));
|
| 436 | | |
| 437 | | *zx8302.intf->comctl = 1;
|
| 438 | | *zx8302.intf->comdata = 1;
|
| 439 | | |
| 440 | | zx8302.ctr = time(NULL) + 283996800;
|
| 441 | | |
| 442 | | mdv_image = auto_malloc(MDV_IMAGE_LENGTH);
|
| 443 | | }
|
src/mess/drivers/ql.c
| r1705 | r1706 | |
| 6 | 6 | #include "includes/serial.h" |
| 7 | 7 | #include "sound/speaker.h" |
| 8 | 8 | #include "video/zx8301.h" |
| 9 | | #include "machine/zx8302.h" |
| 9 | #include <time.h> |
| 10 | 10 | |
| 11 | 11 | /* |
| 12 | 12 | |
| r1705 | r1706 | |
| 17 | 17 | |
| 18 | 18 | TODO: |
| 19 | 19 | |
| 20 | - separate ZX8302 into it's own module |
| 20 | 21 | - microdrive simulation |
| 21 | 22 | - RTC register write |
| 22 | 23 | - serial data latching? |
| r1705 | r1706 | |
| 35 | 36 | #define X3 XTAL_4_436MHz |
| 36 | 37 | #define X4 XTAL_11MHz |
| 37 | 38 | |
| 39 | /* Peripheral Chip (ZX8302) */ |
| 40 | |
| 41 | #define ZX8302_BAUD_19200 0x00 |
| 42 | #define ZX8302_BAUD_9600 0x01 |
| 43 | #define ZX8302_BAUD_4800 0x02 |
| 44 | #define ZX8302_BAUD_2400 0x03 |
| 45 | #define ZX8302_BAUD_1200 0x04 |
| 46 | #define ZX8302_BAUD_600 0x05 |
| 47 | #define ZX8302_BAUD_300 0x06 |
| 48 | #define ZX8302_BAUD_75 0x07 |
| 49 | #define ZX8302_BAUD_MASK 0x07 |
| 50 | |
| 51 | #define ZX8302_MODE_SER1 0x00 |
| 52 | #define ZX8302_MODE_SER2 0x08 |
| 53 | #define ZX8302_MODE_MDV 0x10 |
| 54 | #define ZX8302_MODE_NET 0x18 |
| 55 | #define ZX8302_MODE_MASK 0x18 |
| 56 | |
| 57 | #define ZX8302_INT_GAP 0x01 |
| 58 | #define ZX8302_INT_INTERFACE 0x02 |
| 59 | #define ZX8302_INT_TRANSMIT 0x04 |
| 60 | #define ZX8302_INT_FRAME 0x08 |
| 61 | #define ZX8302_INT_EXTERNAL 0x10 |
| 62 | |
| 63 | #define ZX8302_STATUS_NETWORK_PORT 0x01 |
| 64 | #define ZX8302_STATUS_TX_BUFFER_FULL 0x02 |
| 65 | #define ZX8302_STATUS_RX_BUFFER_FULL 0x04 |
| 66 | #define ZX8302_STATUS_MICRODRIVE_GAP 0x08 |
| 67 | |
| 68 | #define ZX8302_TXD_START 0 |
| 69 | #define ZX8302_TXD_STOP 9 |
| 70 | #define ZX8302_TXD_STOP2 10 |
| 71 | |
| 72 | #define MDV_SECTOR_COUNT 255 |
| 73 | #define MDV_SECTOR_LENGTH 686 |
| 74 | #define MDV_IMAGE_LENGTH (MDV_SECTOR_COUNT * MDV_SECTOR_LENGTH) |
| 75 | |
| 76 | #define MDV_PREAMBLE_LENGTH 12 |
| 77 | #define MDV_GAP_LENGTH 120 |
| 78 | |
| 79 | #define MDV_OFFSET_HEADER_PREAMBLE 0 |
| 80 | #define MDV_OFFSET_HEADER MDV_OFFSET_HEADER_PREAMBLE + MDV_PREAMBLE_LENGTH |
| 81 | #define MDV_OFFSET_DATA_PREAMBLE 28 |
| 82 | #define MDV_OFFSET_DATA MDV_OFFSET_DATA_PREAMBLE + MDV_PREAMBLE_LENGTH |
| 83 | #define MDV_OFFSET_GAP 566 |
| 84 | |
| 85 | static struct ZX8302 |
| 86 | { |
| 87 | int comdata, comdata_l; |
| 88 | int comctl; |
| 89 | int baudx4; |
| 90 | UINT8 tcr; |
| 91 | UINT8 tdr; |
| 92 | UINT8 irq; |
| 93 | UINT32 ctr; |
| 94 | UINT8 idr; |
| 95 | UINT8 status; |
| 96 | int ipc_bits, tx_bits; |
| 97 | int ser1_rxd, ser1_cts; |
| 98 | int ser2_txd, ser2_dtr; |
| 99 | int netout, netin; |
| 100 | int mdrdw, mdselck, mdseld, erase; |
| 101 | int mdv_motor, mdv_offset; |
| 102 | } zx8302; |
| 103 | |
| 104 | static emu_timer *zx8302_txd_timer, *zx8302_ipc_timer, *zx8302_rtc_timer, *zx8302_gap_timer; |
| 105 | |
| 106 | static UINT8 *mdv_image; |
| 107 | |
| 108 | static void zx8302_interrupt(UINT8 line) |
| 109 | { |
| 110 | zx8302.irq |= line; |
| 111 | cpunum_set_input_line(Machine, 0, MC68000_IRQ_2, HOLD_LINE); |
| 112 | } |
| 113 | |
| 114 | static void zx8302_txd(int level) |
| 115 | { |
| 116 | switch (zx8302.tcr & ZX8302_MODE_MASK) |
| 117 | { |
| 118 | case ZX8302_MODE_SER1: |
| 119 | zx8302.ser1_rxd = level; |
| 120 | break; |
| 121 | |
| 122 | case ZX8302_MODE_SER2: |
| 123 | zx8302.ser2_txd = level; |
| 124 | break; |
| 125 | |
| 126 | case ZX8302_MODE_MDV: |
| 127 | // TODO |
| 128 | break; |
| 129 | |
| 130 | case ZX8302_MODE_NET: |
| 131 | zx8302.netout = level; |
| 132 | break; |
| 133 | } |
| 134 | } |
| 135 | |
| 136 | static TIMER_CALLBACK( zx8302_txd_tick ) |
| 137 | { |
| 138 | switch (zx8302.tx_bits) |
| 139 | { |
| 140 | case ZX8302_TXD_START: |
| 141 | if (!(zx8302.irq & ZX8302_INT_TRANSMIT)) |
| 142 | { |
| 143 | zx8302_txd(0); |
| 144 | zx8302.tx_bits++; |
| 145 | } |
| 146 | break; |
| 147 | |
| 148 | default: |
| 149 | zx8302_txd(BIT(zx8302.tdr, 0)); |
| 150 | zx8302.tdr >>= 1; |
| 151 | zx8302.tx_bits++; |
| 152 | break; |
| 153 | |
| 154 | case ZX8302_TXD_STOP: |
| 155 | zx8302_txd(1); |
| 156 | zx8302.tx_bits++; |
| 157 | break; |
| 158 | |
| 159 | case ZX8302_TXD_STOP2: |
| 160 | zx8302_txd(1); |
| 161 | zx8302.tx_bits = ZX8302_TXD_START; |
| 162 | zx8302.status &= ~ZX8302_STATUS_TX_BUFFER_FULL; |
| 163 | zx8302_interrupt(ZX8302_INT_TRANSMIT); |
| 164 | break; |
| 165 | } |
| 166 | } |
| 167 | |
| 168 | static TIMER_CALLBACK( zx8302_ipc_tick ) |
| 169 | { |
| 170 | zx8302.baudx4 = zx8302.baudx4 ? 0 : 1; |
| 171 | } |
| 172 | |
| 173 | static TIMER_CALLBACK( zx8302_rtc_tick ) |
| 174 | { |
| 175 | zx8302.ctr++; |
| 176 | } |
| 177 | |
| 178 | static TIMER_CALLBACK( zx8302_gap_tick ) |
| 179 | { |
| 180 | if (zx8302.mdv_motor) |
| 181 | { |
| 182 | zx8302_interrupt(ZX8302_INT_GAP); |
| 183 | } |
| 184 | } |
| 185 | |
| 186 | static READ8_HANDLER( zx8302_rtc_r ) |
| 187 | { |
| 188 | switch (offset) |
| 189 | { |
| 190 | case 0: |
| 191 | return (zx8302.ctr >> 24) & 0xff; |
| 192 | case 1: |
| 193 | return (zx8302.ctr >> 16) & 0xff; |
| 194 | case 2: |
| 195 | return (zx8302.ctr >> 8) & 0xff; |
| 196 | case 3: |
| 197 | return zx8302.ctr; |
| 198 | } |
| 199 | |
| 200 | return 0; |
| 201 | } |
| 202 | |
| 203 | static WRITE8_HANDLER( zx8302_rtc_w ) |
| 204 | { |
| 205 | // TODO |
| 206 | } |
| 207 | |
| 208 | static WRITE8_HANDLER( zx8302_control_w ) |
| 209 | { |
| 210 | int baud = (19200 >> (data & ZX8302_BAUD_MASK)); |
| 211 | int baudx4 = baud * 4; |
| 212 | |
| 213 | zx8302.tcr = data; |
| 214 | |
| 215 | timer_adjust_periodic(zx8302_txd_timer, attotime_zero, 0, ATTOTIME_IN_HZ(baud)); |
| 216 | timer_adjust_periodic(zx8302_ipc_timer, attotime_zero, 0, ATTOTIME_IN_HZ(baudx4)); |
| 217 | } |
| 218 | |
| 219 | static UINT8 zx8302_get_microdrive_status(void) |
| 220 | { |
| 221 | UINT8 status = 0; |
| 222 | |
| 223 | if (zx8302.mdv_motor) |
| 224 | { |
| 225 | switch (zx8302.mdv_offset % MDV_SECTOR_LENGTH) |
| 226 | { |
| 227 | case MDV_OFFSET_HEADER_PREAMBLE: |
| 228 | zx8302.status &= ~ZX8302_STATUS_MICRODRIVE_GAP; |
| 229 | zx8302.mdv_offset += MDV_PREAMBLE_LENGTH; |
| 230 | break; |
| 231 | |
| 232 | case MDV_OFFSET_HEADER: |
| 233 | zx8302.status |= ZX8302_STATUS_RX_BUFFER_FULL; |
| 234 | break; |
| 235 | |
| 236 | case MDV_OFFSET_DATA_PREAMBLE: |
| 237 | zx8302.status &= ~ZX8302_STATUS_RX_BUFFER_FULL; |
| 238 | zx8302.mdv_offset += MDV_PREAMBLE_LENGTH; |
| 239 | break; |
| 240 | |
| 241 | case MDV_OFFSET_DATA: |
| 242 | zx8302.status |= ZX8302_STATUS_RX_BUFFER_FULL; |
| 243 | break; |
| 244 | |
| 245 | case MDV_OFFSET_GAP: |
| 246 | zx8302.status &= ~ZX8302_STATUS_RX_BUFFER_FULL; |
| 247 | zx8302.status |= ZX8302_STATUS_MICRODRIVE_GAP; |
| 248 | zx8302.mdv_offset += MDV_GAP_LENGTH; |
| 249 | break; |
| 250 | } |
| 251 | } |
| 252 | |
| 253 | return status; |
| 254 | } |
| 255 | |
| 256 | static READ8_HANDLER( zx8302_mdv_track_r ) |
| 257 | { |
| 258 | UINT8 data = mdv_image[zx8302.mdv_offset]; |
| 259 | |
| 260 | zx8302.mdv_offset++; |
| 261 | |
| 262 | if (zx8302.mdv_offset == MDV_IMAGE_LENGTH) |
| 263 | { |
| 264 | zx8302.mdv_offset = 0; |
| 265 | } |
| 266 | |
| 267 | return data; |
| 268 | } |
| 269 | |
| 270 | static READ8_HANDLER( zx8302_status_r ) |
| 271 | { |
| 272 | /* |
| 273 | |
| 274 | bit description |
| 275 | |
| 276 | 0 Network port |
| 277 | 1 Transmit buffer full |
| 278 | 2 Receive buffer full |
| 279 | 3 Microdrive GAP |
| 280 | 4 SER1 DTR |
| 281 | 5 SER2 CTS |
| 282 | 6 Latched COMCTL |
| 283 | 7 Latched COMDATA |
| 284 | |
| 285 | */ |
| 286 | |
| 287 | UINT8 data = 0; |
| 288 | |
| 289 | data |= zx8302.comdata_l << 7; |
| 290 | data |= zx8302.comctl << 6; |
| 291 | data |= zx8302.ser1_cts << 5; |
| 292 | data |= zx8302.ser2_dtr << 4; |
| 293 | data |= zx8302_get_microdrive_status(); |
| 294 | data |= zx8302.status; |
| 295 | |
| 296 | zx8302.comctl = 1; |
| 297 | |
| 298 | return data; |
| 299 | } |
| 300 | |
| 301 | static TIMER_CALLBACK( zx8302_delayed_ipc_command ) |
| 302 | { |
| 303 | zx8302.idr = param; |
| 304 | zx8302.comdata = BIT(param, 0); |
| 305 | } |
| 306 | |
| 307 | static WRITE8_HANDLER( zx8302_ipc_command_w ) |
| 308 | { |
| 309 | timer_set(ATTOTIME_IN_NSEC(480), NULL, data, zx8302_delayed_ipc_command); |
| 310 | } |
| 311 | |
| 312 | /* |
| 313 | static int zx8302_get_selected_microdrive(void) |
| 314 | { |
| 315 | int i; |
| 316 | |
| 317 | for (i = 0; i < 8; i++) |
| 318 | { |
| 319 | if (BIT(zx8302.mdv_motor, i)) return 8 - i; |
| 320 | } |
| 321 | |
| 322 | return 0; |
| 323 | } |
| 324 | */ |
| 325 | |
| 326 | static WRITE8_HANDLER( zx8302_mdv_control_w ) |
| 327 | { |
| 328 | /* |
| 329 | |
| 330 | bit description |
| 331 | |
| 332 | 0 MDSELDH |
| 333 | 1 MDSELCKH |
| 334 | 2 MDRDWL |
| 335 | 3 ERASE |
| 336 | 4 |
| 337 | 5 |
| 338 | 6 |
| 339 | 7 |
| 340 | |
| 341 | */ |
| 342 | |
| 343 | zx8302.mdseld = BIT(data, 0); |
| 344 | zx8302.mdselck = BIT(data, 1); |
| 345 | zx8302.mdrdw = BIT(data, 2) ? 0 : 1; |
| 346 | zx8302.erase = BIT(data, 3); |
| 347 | |
| 348 | // Microdrive selection shift register |
| 349 | |
| 350 | if (zx8302.mdselck) |
| 351 | { |
| 352 | zx8302.mdv_motor >>= 1; |
| 353 | zx8302.mdv_motor |= (zx8302.mdseld << 7); |
| 354 | |
| 355 | zx8302.mdv_offset = 0; |
| 356 | zx8302.status &= ~ZX8302_STATUS_RX_BUFFER_FULL; |
| 357 | } |
| 358 | } |
| 359 | |
| 360 | static READ8_HANDLER( zx8302_irq_status_r ) |
| 361 | { |
| 362 | return zx8302.irq; |
| 363 | } |
| 364 | |
| 365 | static WRITE8_HANDLER( zx8302_irq_acknowledge_w ) |
| 366 | { |
| 367 | zx8302.irq &= ~data; |
| 368 | |
| 369 | if (!zx8302.irq) |
| 370 | { |
| 371 | cpunum_set_input_line(Machine, 0, MC68000_IRQ_2, CLEAR_LINE); |
| 372 | } |
| 373 | } |
| 374 | |
| 375 | static WRITE8_HANDLER( zx8302_data_w ) |
| 376 | { |
| 377 | zx8302.tdr = data; |
| 378 | zx8302.status |= ZX8302_STATUS_TX_BUFFER_FULL; |
| 379 | } |
| 380 | |
| 381 | static INTERRUPT_GEN( zx8302_int ) |
| 382 | { |
| 383 | zx8302_interrupt(ZX8302_INT_FRAME); |
| 384 | } |
| 385 | |
| 38 | 386 | /* Intelligent Peripheral Controller (IPC) */ |
| 39 | 387 | |
| 40 | | static int zx8302_comdata, zx8302_comctl, zx8302_baudx4; |
| 41 | | |
| 42 | 388 | static struct IPC |
| 43 | 389 | { |
| 44 | 390 | UINT8 keylatch; |
| 45 | 391 | int ser1_txd, ser1_dtr; |
| 46 | 392 | int ser2_rxd, ser2_cts; |
| 47 | 393 | int ipl; |
| 48 | | int comdata; |
| 49 | 394 | } ipc; |
| 50 | 395 | |
| 51 | 396 | static WRITE8_HANDLER( ipc_link_hack_w ) |
| r1705 | r1706 | |
| 79 | 424 | { |
| 80 | 425 | case 0x759: |
| 81 | 426 | // transmit data bit to IPC |
| 82 | | ipc.comdata = zx8302_comdata; |
| 427 | zx8302.comdata = BIT(zx8302.idr, 1); |
| 83 | 428 | break; |
| 84 | 429 | |
| 85 | 430 | case 0x75b: |
| 86 | 431 | // end transmit |
| 87 | | zx8302_comdata = 1; |
| 88 | | zx8302_comctl = 0; |
| 432 | zx8302.comdata = 1; |
| 433 | zx8302.comctl = 0; |
| 89 | 434 | break; |
| 90 | 435 | |
| 91 | 436 | case 0x775: |
| 92 | 437 | // latch data bit from IPC |
| 93 | | zx8302_comdata = ipc.comdata; |
| 94 | | zx8302_comctl = 0; |
| 438 | zx8302.comdata_l = zx8302.comdata; |
| 439 | zx8302.comctl = 0; |
| 95 | 440 | break; |
| 96 | 441 | } |
| 97 | 442 | } |
| r1705 | r1706 | |
| 169 | 514 | ipc.ser2_cts = BIT(data, 4); |
| 170 | 515 | ipc.ser1_dtr = BIT(data, 5); |
| 171 | 516 | |
| 172 | | ipc.comdata = BIT(data, 7); |
| 517 | zx8302.comdata = BIT(data, 7); |
| 173 | 518 | } |
| 174 | 519 | |
| 175 | 520 | static READ8_HANDLER( ipc_port2_r ) |
| r1705 | r1706 | |
| 193 | 538 | |
| 194 | 539 | cpunum_set_input_line(Machine, 1, INPUT_LINE_IRQ0, irq); |
| 195 | 540 | |
| 196 | | return (ipc.comdata << 7) | irq; |
| 541 | return (zx8302.comdata << 7) | irq; |
| 197 | 542 | } |
| 198 | 543 | |
| 199 | 544 | static READ8_HANDLER( ipc_t1_r ) |
| 200 | 545 | { |
| 201 | | return zx8302_baudx4; |
| 546 | return zx8302.baudx4; |
| 202 | 547 | } |
| 203 | 548 | |
| 204 | 549 | static READ8_HANDLER( ipc_bus_r ) |
| r1705 | r1706 | |
| 232 | 577 | |
| 233 | 578 | static READ8_HANDLER( ipc_ea_r ) |
| 234 | 579 | { |
| 235 | | // connected to ground via a 1K resistor, but needs to be 1 because the logic is reversed in i8039.c |
| 580 | // connected to ground via a 10K resistor, but needs to be 1 because the logic is reversed in i8039.c |
| 236 | 581 | |
| 237 | 582 | return 1; |
| 238 | 583 | } |
| r1705 | r1706 | |
| 502 | 847 | PORT_INCLUDE(ql) |
| 503 | 848 | INPUT_PORTS_END |
| 504 | 849 | |
| 505 | | /* Machine Start */ |
| 506 | | /* |
| 507 | | static void zx8302_interrupt(int state) |
| 508 | | { |
| 509 | | cpunum_set_input_line(Machine, 0, MC68000_IRQ_2, state); |
| 510 | | } |
| 850 | /* Machine Drivers */ |
| 511 | 851 | |
| 512 | | static const struct zx8302_interface zx8302_intf = |
| 513 | | { |
| 514 | | X1, |
| 515 | | X2, |
| 516 | | &zx8302_comdata, |
| 517 | | &zx8302_comctl, |
| 518 | | &zx8302_baudx4, |
| 519 | | zx8302_interrupt |
| 520 | | }; |
| 521 | | */ |
| 522 | 852 | static MACHINE_START( ql ) |
| 523 | 853 | { |
| 524 | 854 | // ZX8302 |
| 525 | 855 | |
| 526 | | // zx8302_config(&zx8302_intf); |
| 856 | state_save_register_global(zx8302.comdata); |
| 857 | state_save_register_global(zx8302.comdata_l); |
| 858 | state_save_register_global(zx8302.comctl); |
| 859 | state_save_register_global(zx8302.baudx4); |
| 860 | state_save_register_global(zx8302.tcr); |
| 861 | state_save_register_global(zx8302.tdr); |
| 862 | state_save_register_global(zx8302.irq); |
| 863 | state_save_register_global(zx8302.ctr); |
| 864 | state_save_register_global(zx8302.idr); |
| 865 | state_save_register_global(zx8302.ipc_bits); |
| 866 | state_save_register_global(zx8302.tx_bits); |
| 867 | state_save_register_global(zx8302.ser1_rxd); |
| 868 | state_save_register_global(zx8302.ser1_cts); |
| 869 | state_save_register_global(zx8302.ser2_txd); |
| 870 | state_save_register_global(zx8302.ser2_dtr); |
| 871 | state_save_register_global(zx8302.netout); |
| 872 | state_save_register_global(zx8302.netin); |
| 873 | state_save_register_global(zx8302.mdrdw); |
| 874 | state_save_register_global(zx8302.mdselck); |
| 875 | state_save_register_global(zx8302.mdseld); |
| 876 | state_save_register_global(zx8302.erase); |
| 877 | state_save_register_global(zx8302.mdv_motor); |
| 878 | state_save_register_global(zx8302.mdv_offset); |
| 527 | 879 | |
| 880 | memset(&zx8302, 0, sizeof(zx8302)); |
| 881 | zx8302.comctl = 1; |
| 882 | zx8302.comdata = 1; |
| 883 | |
| 884 | zx8302_txd_timer = timer_alloc(zx8302_txd_tick, NULL); |
| 885 | zx8302_ipc_timer = timer_alloc(zx8302_ipc_tick, NULL); |
| 886 | zx8302_rtc_timer = timer_alloc(zx8302_rtc_tick, NULL); |
| 887 | zx8302_gap_timer = timer_alloc(zx8302_gap_tick, NULL); |
| 888 | |
| 889 | timer_adjust_periodic(zx8302_rtc_timer, attotime_zero, 0, ATTOTIME_IN_HZ(X2/32768)); |
| 890 | timer_adjust_periodic(zx8302_gap_timer, attotime_zero, 0, ATTOTIME_IN_MSEC(31)); |
| 891 | |
| 892 | zx8302.ctr = time(NULL) + 283996800; |
| 893 | |
| 894 | mdv_image = auto_malloc(MDV_IMAGE_LENGTH); |
| 895 | |
| 528 | 896 | // IPC |
| 529 | 897 | |
| 530 | 898 | state_save_register_global(ipc.keylatch); |
| r1705 | r1706 | |
| 533 | 901 | state_save_register_global(ipc.ser2_rxd); |
| 534 | 902 | state_save_register_global(ipc.ser2_cts); |
| 535 | 903 | state_save_register_global(ipc.ipl); |
| 536 | | state_save_register_global(ipc.comdata); |
| 537 | | state_save_register_global(zx8302_comdata); |
| 538 | | state_save_register_global(zx8302_comctl); |
| 539 | | state_save_register_global(zx8302_baudx4); |
| 540 | 904 | |
| 541 | 905 | memset(&ipc, 0, sizeof(ipc)); |
| 542 | 906 | } |
| 543 | 907 | |
| 544 | | /* Machine Drivers */ |
| 545 | | |
| 546 | 908 | static MACHINE_DRIVER_START( ql ) |
| 547 | 909 | // basic machine hardware |
| 548 | 910 | MDRV_CPU_ADD(M68008, X1/2) |
| r1705 | r1706 | |
| 703 | 1065 | |
| 704 | 1066 | /* System Configuration */ |
| 705 | 1067 | |
| 1068 | static DEVICE_LOAD( ql_microdrive ) |
| 1069 | { |
| 1070 | int filesize = image_length(image); |
| 1071 | |
| 1072 | if (filesize == MDV_IMAGE_LENGTH) |
| 1073 | { |
| 1074 | if (image_fread(image, mdv_image, filesize) == filesize) |
| 1075 | { |
| 1076 | return INIT_PASS; |
| 1077 | } |
| 1078 | } |
| 1079 | |
| 1080 | return INIT_FAIL; |
| 1081 | } |
| 1082 | |
| 1083 | static void ql_microdrive_getinfo(const device_class *devclass, UINT32 state, union devinfo *info) |
| 1084 | { |
| 1085 | switch(state) |
| 1086 | { |
| 1087 | /* --- the following bits of info are returned as 64-bit signed integers --- */ |
| 1088 | case DEVINFO_INT_TYPE: info->i = IO_CASSETTE; break; |
| 1089 | case DEVINFO_INT_COUNT: info->i = 1; break; |
| 1090 | |
| 1091 | case DEVINFO_INT_READABLE: info->i = 1; break; |
| 1092 | case DEVINFO_INT_WRITEABLE: info->i = 0; break; |
| 1093 | case DEVINFO_INT_CREATABLE: info->i = 0; break; |
| 1094 | |
| 1095 | /* --- the following bits of info are returned as pointers to data or functions --- */ |
| 1096 | case DEVINFO_PTR_LOAD: info->load = device_load_ql_microdrive; break; |
| 1097 | |
| 1098 | /* --- the following bits of info are returned as NULL-terminated strings --- */ |
| 1099 | case DEVINFO_STR_FILE_EXTENSIONS: strcpy(info->s = device_temp_str(), "mdv"); break; |
| 1100 | } |
| 1101 | } |
| 1102 | |
| 706 | 1103 | static DEVICE_LOAD( ql_serial ) |
| 707 | 1104 | { |
| 708 | 1105 | /* filename specified */ |
| r1705 | r1706 | |
| 779 | 1176 | SYSTEM_CONFIG_START( ql ) |
| 780 | 1177 | CONFIG_RAM_DEFAULT (128 * 1024) |
| 781 | 1178 | CONFIG_RAM (640 * 1024) |
| 782 | | CONFIG_DEVICE(zx8302_microdrive_getinfo) |
| 1179 | CONFIG_DEVICE(ql_microdrive_getinfo) |
| 783 | 1180 | CONFIG_DEVICE(ql_serial_getinfo) |
| 784 | 1181 | CONFIG_DEVICE(ql_cartslot_getinfo) |
| 785 | 1182 | SYSTEM_CONFIG_END |