src/mess/drivers/atarist.c
| r9957 | r9958 | |
| 37 | 37 | |
| 38 | 38 | */ |
| 39 | 39 | |
| 40 | #define LOG 0 |
| 41 | |
| 40 | 42 | /* Floppy Disk Controller */ |
| 41 | 43 | |
| 42 | | static void atarist_fdc_dma_transfer(running_machine *machine) |
| 44 | static void toggle_dma_fifo(running_machine *machine) |
| 43 | 45 | { |
| 46 | atarist_state *state = machine->driver_data<atarist_state>(); |
| 47 | |
| 48 | if (LOG) logerror("Toggling DMA FIFO\n"); |
| 49 | |
| 50 | state->fdc_fifo_sel = !state->fdc_fifo_sel; |
| 51 | state->fdc_fifo_index = 0; |
| 52 | } |
| 53 | |
| 54 | static void flush_dma_fifo(running_machine *machine) |
| 55 | { |
| 44 | 56 | address_space *program = cputag_get_address_space(machine, M68000_TAG, ADDRESS_SPACE_PROGRAM); |
| 45 | 57 | atarist_state *state = machine->driver_data<atarist_state>(); |
| 46 | 58 | |
| 47 | | if ((state->fdc_mode & ATARIST_FLOPPY_MODE_DMA_DISABLE) == 0) |
| 59 | if (state->fdc_fifo_empty[state->fdc_fifo_sel]) return; |
| 60 | |
| 61 | for (int i = 0; i < 8; i++) |
| 48 | 62 | { |
| 49 | | while (state->fdc_sectors > 0) |
| 63 | UINT16 data = state->fdc_fifo[state->fdc_fifo_sel][i]; |
| 64 | |
| 65 | if (LOG) logerror("Flushing DMA FIFO %u data %04x to address %06x\n", state->fdc_fifo_sel, data, state->fdc_dmabase); |
| 66 | |
| 67 | program->write_word(state->fdc_dmabase, data); |
| 68 | state->fdc_dmabase += 2; |
| 69 | } |
| 70 | |
| 71 | state->fdc_fifo_empty[state->fdc_fifo_sel] = 1; |
| 72 | } |
| 73 | |
| 74 | static void fill_dma_fifo(running_machine *machine) |
| 75 | { |
| 76 | address_space *program = cputag_get_address_space(machine, M68000_TAG, ADDRESS_SPACE_PROGRAM); |
| 77 | atarist_state *state = machine->driver_data<atarist_state>(); |
| 78 | |
| 79 | for (int i = 0; i < 8; i++) |
| 80 | { |
| 81 | UINT16 data = program->read_word(state->fdc_dmabase); |
| 82 | |
| 83 | if (LOG) logerror("Filling DMA FIFO %u with data %04x from memory address %06x\n", state->fdc_fifo_sel, data, state->fdc_dmabase); |
| 84 | |
| 85 | state->fdc_fifo[state->fdc_fifo_sel][i] = data; |
| 86 | state->fdc_dmabase += 2; |
| 87 | } |
| 88 | |
| 89 | state->fdc_fifo_empty[state->fdc_fifo_sel] = 0; |
| 90 | } |
| 91 | |
| 92 | static void atarist_fdc_dma_transfer(running_machine *machine) |
| 93 | { |
| 94 | atarist_state *state = machine->driver_data<atarist_state>(); |
| 95 | |
| 96 | if (!state->fdc_dmabytes) return; |
| 97 | |
| 98 | if (state->fdc_mode & DMA_MODE_READ_WRITE) |
| 99 | { |
| 100 | UINT16 data = state->fdc_fifo[state->fdc_fifo_sel][state->fdc_fifo_index]; |
| 101 | |
| 102 | if (state->fdc_fifo_msb) |
| 50 | 103 | { |
| 51 | | if (state->fdc_mode & ATARIST_FLOPPY_MODE_WRITE) |
| 52 | | { |
| 53 | | UINT8 data = program->read_byte(state->fdc_dmabase); |
| 104 | // write LSB to disk |
| 105 | wd17xx_data_w(state->wd1772, 0, data & 0xff); |
| 106 | |
| 107 | if (LOG) logerror("DMA Write to FDC %02x\n", data & 0xff); |
| 54 | 108 | |
| 55 | | wd17xx_data_w(state->wd1772, 0, data); |
| 56 | | } |
| 57 | | else |
| 58 | | { |
| 59 | | UINT8 data = wd17xx_data_r(state->wd1772, 0); |
| 109 | state->fdc_fifo_index++; |
| 110 | } |
| 111 | else |
| 112 | { |
| 113 | // write MSB to disk |
| 114 | wd17xx_data_w(state->wd1772, 0, data >> 8); |
| 60 | 115 | |
| 61 | | program->write_byte(state->fdc_dmabase, data); |
| 62 | | } |
| 116 | if (LOG) logerror("DMA Write to FDC %02x\n", data >> 8); |
| 117 | } |
| 63 | 118 | |
| 64 | | state->fdc_dmabase++; |
| 65 | | state->fdc_dmabytes--; |
| 119 | // toggle MSB/LSB |
| 120 | state->fdc_fifo_msb = !state->fdc_fifo_msb; |
| 66 | 121 | |
| 67 | | if (state->fdc_dmabytes == 0) |
| 122 | if (state->fdc_fifo_index == 8) |
| 123 | { |
| 124 | state->fdc_fifo_index--; |
| 125 | state->fdc_fifo_empty[state->fdc_fifo_sel] = 1; |
| 126 | |
| 127 | toggle_dma_fifo(machine); |
| 128 | |
| 129 | if (state->fdc_fifo_empty[state->fdc_fifo_sel]) |
| 68 | 130 | { |
| 69 | | state->fdc_sectors--; |
| 70 | | |
| 71 | | if (state->fdc_sectors == 0) |
| 72 | | { |
| 73 | | state->fdc_status &= ~ATARIST_FLOPPY_STATUS_SECTOR_COUNT_ZERO; |
| 74 | | } |
| 75 | | else |
| 76 | | { |
| 77 | | state->fdc_dmabytes = ATARIST_FLOPPY_BYTES_PER_SECTOR; |
| 78 | | } |
| 131 | fill_dma_fifo(machine); |
| 79 | 132 | } |
| 80 | 133 | } |
| 81 | 134 | } |
| 135 | else |
| 136 | { |
| 137 | // read from controller to FIFO |
| 138 | UINT8 data = wd17xx_data_r(state->wd1772, 0); |
| 139 | |
| 140 | state->fdc_fifo_empty[state->fdc_fifo_sel] = 0; |
| 141 | |
| 142 | if (LOG) logerror("DMA Read from FDC %02x\n", data); |
| 143 | |
| 144 | if (state->fdc_fifo_msb) |
| 145 | { |
| 146 | // write MSB to FIFO |
| 147 | state->fdc_fifo[state->fdc_fifo_sel][state->fdc_fifo_index] |= data; |
| 148 | state->fdc_fifo_index++; |
| 149 | } |
| 150 | else |
| 151 | { |
| 152 | // write LSB to FIFO |
| 153 | state->fdc_fifo[state->fdc_fifo_sel][state->fdc_fifo_index] = data << 8; |
| 154 | } |
| 155 | |
| 156 | // toggle MSB/LSB |
| 157 | state->fdc_fifo_msb = !state->fdc_fifo_msb; |
| 158 | |
| 159 | if (state->fdc_fifo_index == 8) |
| 160 | { |
| 161 | flush_dma_fifo(machine); |
| 162 | toggle_dma_fifo(machine); |
| 163 | } |
| 164 | } |
| 165 | |
| 166 | state->fdc_dmabytes--; |
| 167 | |
| 168 | if (state->fdc_dmabytes == 0) |
| 169 | { |
| 170 | state->fdc_sectors--; |
| 171 | |
| 172 | if (state->fdc_sectors) |
| 173 | { |
| 174 | state->fdc_dmabytes = DMA_SECTOR_SIZE; |
| 175 | } |
| 176 | } |
| 82 | 177 | } |
| 83 | 178 | |
| 84 | 179 | static WRITE_LINE_DEVICE_HANDLER( atarist_fdc_intrq_w ) |
| 85 | 180 | { |
| 86 | 181 | atarist_state *driver_state = device->machine->driver_data<atarist_state>(); |
| 87 | | |
| 88 | | driver_state->fdc_irq = state; |
| 182 | |
| 183 | driver_state->fdc_irq = !state; |
| 89 | 184 | } |
| 90 | 185 | |
| 91 | 186 | static WRITE_LINE_DEVICE_HANDLER( atarist_fdc_drq_w ) |
| 92 | 187 | { |
| 93 | 188 | atarist_state *driver_state = device->machine->driver_data<atarist_state>(); |
| 94 | 189 | |
| 95 | | if (state) |
| 190 | if (state && (!(driver_state->fdc_mode & DMA_MODE_ENABLED)) && (driver_state->fdc_mode & DMA_MODE_FDC_HDC_ACK)) |
| 96 | 191 | { |
| 97 | | driver_state->fdc_status |= ATARIST_FLOPPY_STATUS_FDC_DATA_REQUEST; |
| 98 | 192 | atarist_fdc_dma_transfer(device->machine); |
| 99 | 193 | } |
| 100 | | else |
| 101 | | { |
| 102 | | driver_state->fdc_status &= ~ATARIST_FLOPPY_STATUS_FDC_DATA_REQUEST; |
| 103 | | } |
| 104 | 194 | } |
| 105 | 195 | |
| 106 | 196 | static const wd17xx_interface fdc_intf = |
| r9957 | r9958 | |
| 123 | 213 | { |
| 124 | 214 | atarist_state *state = space->machine->driver_data<atarist_state>(); |
| 125 | 215 | |
| 126 | | if (state->fdc_mode & ATARIST_FLOPPY_MODE_SECTOR_COUNT) |
| 216 | UINT8 data = 0; |
| 217 | |
| 218 | if (state->fdc_mode & DMA_MODE_SECTOR_COUNT) |
| 127 | 219 | { |
| 128 | | return state->fdc_sectors; |
| 220 | if (LOG) logerror("Indeterminate DMA Sector Count Read!\n"); |
| 221 | |
| 222 | // sector count register is write only, reading it returns unpredictable values |
| 223 | data = space->machine->rand() & 0xff; |
| 129 | 224 | } |
| 130 | 225 | else |
| 131 | 226 | { |
| 132 | | if (state->fdc_mode & ATARIST_FLOPPY_MODE_HDC) |
| 227 | if (!(state->fdc_mode & DMA_MODE_FDC_HDC_CS)) |
| 133 | 228 | { |
| 134 | | // HDC not implemented |
| 135 | | state->fdc_status &= ~ATARIST_FLOPPY_STATUS_DMA_ERROR; |
| 229 | // floppy controller |
| 230 | int offset = (state->fdc_mode & DMA_MODE_ADDRESS_MASK) >> 1; |
| 136 | 231 | |
| 137 | | return 0; |
| 232 | data = wd17xx_r(state->wd1772, offset); |
| 233 | |
| 234 | if (LOG) logerror("FDC Register %u Read %02x\n", offset, data); |
| 138 | 235 | } |
| 139 | | else |
| 140 | | { |
| 141 | | return wd17xx_r(state->wd1772, (state->fdc_mode & ATARIST_FLOPPY_MODE_ADDRESS_MASK) >> 1); |
| 142 | | } |
| 143 | 236 | } |
| 237 | |
| 238 | return data; |
| 144 | 239 | } |
| 145 | 240 | |
| 146 | 241 | static WRITE16_HANDLER( atarist_fdc_data_w ) |
| 147 | 242 | { |
| 148 | 243 | atarist_state *state = space->machine->driver_data<atarist_state>(); |
| 149 | 244 | |
| 150 | | if (state->fdc_mode & ATARIST_FLOPPY_MODE_SECTOR_COUNT) |
| 245 | if (state->fdc_mode & DMA_MODE_SECTOR_COUNT) |
| 151 | 246 | { |
| 152 | | if (data == 0) |
| 247 | if (LOG) logerror("DMA Sector Count %u\n", data); |
| 248 | |
| 249 | // sector count register |
| 250 | state->fdc_sectors = data; |
| 251 | |
| 252 | if (state->fdc_sectors) |
| 153 | 253 | { |
| 154 | | state->fdc_status &= ~ATARIST_FLOPPY_STATUS_SECTOR_COUNT_ZERO; |
| 254 | state->fdc_dmabytes = DMA_SECTOR_SIZE; |
| 155 | 255 | } |
| 156 | | else |
| 256 | |
| 257 | if (state->fdc_mode & DMA_MODE_READ_WRITE) |
| 157 | 258 | { |
| 158 | | state->fdc_status |= ATARIST_FLOPPY_STATUS_SECTOR_COUNT_ZERO; |
| 259 | // fill both FIFOs with data |
| 260 | fill_dma_fifo(space->machine); |
| 261 | toggle_dma_fifo(space->machine); |
| 262 | fill_dma_fifo(space->machine); |
| 263 | toggle_dma_fifo(space->machine); |
| 159 | 264 | } |
| 160 | | |
| 161 | | state->fdc_sectors = data; |
| 162 | 265 | } |
| 163 | 266 | else |
| 164 | 267 | { |
| 165 | | if (state->fdc_mode & ATARIST_FLOPPY_MODE_HDC) |
| 268 | if (!(state->fdc_mode & DMA_MODE_FDC_HDC_CS)) |
| 166 | 269 | { |
| 167 | | // HDC not implemented |
| 168 | | state->fdc_status &= ~ATARIST_FLOPPY_STATUS_DMA_ERROR; |
| 270 | // floppy controller |
| 271 | int offset = (state->fdc_mode & DMA_MODE_ADDRESS_MASK) >> 1; |
| 272 | |
| 273 | if (LOG) logerror("FDC Register %u Write %02x\n", offset, data); |
| 274 | |
| 275 | wd17xx_w(state->wd1772, offset, data); |
| 169 | 276 | } |
| 170 | | else |
| 171 | | { |
| 172 | | wd17xx_w(state->wd1772, (state->fdc_mode & ATARIST_FLOPPY_MODE_ADDRESS_MASK) >> 1, data); |
| 173 | | } |
| 174 | 277 | } |
| 175 | 278 | } |
| 176 | 279 | |
| r9957 | r9958 | |
| 178 | 281 | { |
| 179 | 282 | atarist_state *state = space->machine->driver_data<atarist_state>(); |
| 180 | 283 | |
| 181 | | return state->fdc_status; |
| 284 | UINT16 data = 0; |
| 285 | |
| 286 | // DMA error |
| 287 | data |= 1; |
| 288 | |
| 289 | // sector count null |
| 290 | data |= !(state->fdc_sectors == 0) << 1; |
| 291 | |
| 292 | // DRQ state |
| 293 | data |= wd17xx_drq_r(state->wd1772) << 2; |
| 294 | |
| 295 | return data; |
| 182 | 296 | } |
| 183 | 297 | |
| 184 | 298 | static WRITE16_HANDLER( atarist_fdc_dma_mode_w ) |
| 185 | 299 | { |
| 186 | 300 | atarist_state *state = space->machine->driver_data<atarist_state>(); |
| 187 | 301 | |
| 188 | | if ((data & ATARIST_FLOPPY_MODE_WRITE) != (state->fdc_mode & ATARIST_FLOPPY_MODE_WRITE)) |
| 302 | if (LOG) logerror("DMA Mode %04x\n", data); |
| 303 | |
| 304 | if ((data & DMA_MODE_READ_WRITE) != (state->fdc_mode & DMA_MODE_READ_WRITE)) |
| 189 | 305 | { |
| 306 | if (LOG) logerror("DMA reset\n"); |
| 307 | |
| 308 | flush_dma_fifo(space->machine); |
| 309 | |
| 190 | 310 | state->fdc_status = 0; |
| 191 | 311 | state->fdc_sectors = 0; |
| 312 | state->fdc_fifo_sel = 0; |
| 313 | state->fdc_fifo_msb = 0; |
| 192 | 314 | } |
| 193 | 315 | |
| 194 | 316 | state->fdc_mode = data; |
| 195 | 317 | } |
| 196 | 318 | |
| 197 | | static READ16_HANDLER( atarist_fdc_dma_base_r ) |
| 319 | static READ8_HANDLER( atarist_fdc_dma_base_r ) |
| 198 | 320 | { |
| 199 | 321 | atarist_state *state = space->machine->driver_data<atarist_state>(); |
| 200 | 322 | |
| 323 | UINT8 data = 0; |
| 324 | |
| 201 | 325 | switch (offset) |
| 202 | 326 | { |
| 203 | 327 | case 0: |
| 204 | | return (state->fdc_dmabase >> 16) & 0xff; |
| 328 | data = (state->fdc_dmabase >> 16) & 0xff; |
| 329 | |
| 205 | 330 | case 1: |
| 206 | | return (state->fdc_dmabase >> 8) & 0xff; |
| 331 | data = (state->fdc_dmabase >> 8) & 0xff; |
| 332 | |
| 207 | 333 | case 2: |
| 208 | | return state->fdc_dmabase & 0xff; |
| 334 | data = state->fdc_dmabase & 0xff; |
| 209 | 335 | } |
| 210 | 336 | |
| 211 | | return 0; |
| 337 | return data; |
| 212 | 338 | } |
| 213 | 339 | |
| 214 | | static WRITE16_HANDLER( atarist_fdc_dma_base_w ) |
| 340 | static WRITE8_HANDLER( atarist_fdc_dma_base_w ) |
| 215 | 341 | { |
| 216 | 342 | atarist_state *state = space->machine->driver_data<atarist_state>(); |
| 217 | 343 | |
| 218 | 344 | switch (offset) |
| 219 | 345 | { |
| 220 | 346 | case 0: |
| 221 | | state->fdc_dmabase = (state->fdc_dmabase & 0x00ffff) | ((data & 0xff) << 16); |
| 347 | state->fdc_dmabase = (state->fdc_dmabase & 0x00ffff) | (data << 16); |
| 348 | if (LOG) logerror("DMA Address High %02x (%06x)\n", data & 0xff, state->fdc_dmabase); |
| 222 | 349 | break; |
| 350 | |
| 223 | 351 | case 1: |
| 224 | | state->fdc_dmabase = (state->fdc_dmabase & 0x0000ff) | ((data & 0xff) << 8); |
| 352 | state->fdc_dmabase = (state->fdc_dmabase & 0x0000ff) | (data << 8); |
| 353 | if (LOG) logerror("DMA Address Mid %02x (%06x)\n", data & 0xff, state->fdc_dmabase); |
| 225 | 354 | break; |
| 355 | |
| 226 | 356 | case 2: |
| 227 | 357 | state->fdc_dmabase = data & 0xff; |
| 358 | if (LOG) logerror("DMA Address Low %02x (%06x)\n", data & 0xff, state->fdc_dmabase); |
| 228 | 359 | break; |
| 229 | 360 | } |
| 230 | | |
| 231 | | state->fdc_dmabytes = ATARIST_FLOPPY_BYTES_PER_SECTOR; |
| 232 | 361 | } |
| 233 | 362 | |
| 234 | 363 | /* MMU */ |
| r9957 | r9958 | |
| 501 | 630 | |
| 502 | 631 | if (state->dmasnd_ctrl & 0x80) |
| 503 | 632 | { |
| 504 | | // logerror("DMA sound left %i\n", state->dmasnd_fifo[7 - state->dmasnd_samples]); |
| 633 | // if (LOG) logerror("DMA sound left %i\n", state->dmasnd_fifo[7 - state->dmasnd_samples]); |
| 505 | 634 | state->dmasnd_samples--; |
| 506 | 635 | |
| 507 | | // logerror("DMA sound right %i\n", state->dmasnd_fifo[7 - state->dmasnd_samples]); |
| 636 | // if (LOG) logerror("DMA sound right %i\n", state->dmasnd_fifo[7 - state->dmasnd_samples]); |
| 508 | 637 | state->dmasnd_samples--; |
| 509 | 638 | } |
| 510 | 639 | else |
| 511 | 640 | { |
| 512 | | // logerror("DMA sound mono %i\n", state->dmasnd_fifo[7 - state->dmasnd_samples]); |
| 641 | // if (LOG) logerror("DMA sound mono %i\n", state->dmasnd_fifo[7 - state->dmasnd_samples]); |
| 513 | 642 | state->dmasnd_samples--; |
| 514 | 643 | } |
| 515 | 644 | |
| r9957 | r9958 | |
| 826 | 955 | ADDRESS_MAP_END |
| 827 | 956 | |
| 828 | 957 | static ADDRESS_MAP_START( st_map, ADDRESS_SPACE_PROGRAM, 16 ) |
| 829 | | AM_RANGE(0x000000, 0x000007) AM_ROM AM_REGION(M68000_TAG, 0) |
| 958 | AM_RANGE(0x000000, 0x000007) AM_RAM |
| 830 | 959 | AM_RANGE(0x000008, 0x1fffff) AM_RAM |
| 831 | 960 | AM_RANGE(0x200000, 0x3fffff) AM_RAM |
| 832 | 961 | // AM_RANGE(0xfa0000, 0xfbffff) AM_ROM // cartridge |
| r9957 | r9958 | |
| 839 | 968 | AM_RANGE(0xff8260, 0xff8261) AM_READWRITE8(atarist_shifter_mode_r, atarist_shifter_mode_w, 0xff00) |
| 840 | 969 | AM_RANGE(0xff8604, 0xff8605) AM_READWRITE(atarist_fdc_data_r, atarist_fdc_data_w) |
| 841 | 970 | AM_RANGE(0xff8606, 0xff8607) AM_READWRITE(atarist_fdc_dma_status_r, atarist_fdc_dma_mode_w) |
| 842 | | AM_RANGE(0xff8608, 0xff860d) AM_READWRITE(atarist_fdc_dma_base_r, atarist_fdc_dma_base_w) |
| 971 | AM_RANGE(0xff8608, 0xff860d) AM_READWRITE8(atarist_fdc_dma_base_r, atarist_fdc_dma_base_w, 0x00ff) |
| 843 | 972 | AM_RANGE(0xff8800, 0xff8801) AM_DEVREADWRITE8(YM2149_TAG, ay8910_r, ay8910_data_w, 0xff00) |
| 844 | 973 | AM_RANGE(0xff8802, 0xff8803) AM_DEVWRITE8(YM2149_TAG, ay8910_data_w, 0xff00) |
| 845 | 974 | AM_RANGE(0xfffa00, 0xfffa2f) AM_DEVREADWRITE8(MC68901_TAG, mc68901_register_r, mc68901_register_w, 0xff) |
| r9957 | r9958 | |
| 864 | 993 | AM_RANGE(0xff8260, 0xff8261) AM_READWRITE8(atarist_shifter_mode_r, atarist_shifter_mode_w, 0xff00) |
| 865 | 994 | AM_RANGE(0xff8604, 0xff8605) AM_READWRITE(atarist_fdc_data_r, atarist_fdc_data_w) |
| 866 | 995 | AM_RANGE(0xff8606, 0xff8607) AM_READWRITE(atarist_fdc_dma_status_r, atarist_fdc_dma_mode_w) |
| 867 | | AM_RANGE(0xff8608, 0xff860d) AM_READWRITE(atarist_fdc_dma_base_r, atarist_fdc_dma_base_w) |
| 996 | AM_RANGE(0xff8608, 0xff860d) AM_READWRITE8(atarist_fdc_dma_base_r, atarist_fdc_dma_base_w, 0x00ff) |
| 868 | 997 | AM_RANGE(0xff8800, 0xff8801) AM_DEVREADWRITE8(YM2149_TAG, ay8910_r, ay8910_data_w, 0xff00) |
| 869 | 998 | AM_RANGE(0xff8802, 0xff8803) AM_DEVWRITE8(YM2149_TAG, ay8910_data_w, 0xff00) |
| 870 | 999 | AM_RANGE(0xff8a00, 0xff8a1f) AM_READWRITE(atarist_blitter_halftone_r, atarist_blitter_halftone_w) |
| r9957 | r9958 | |
| 906 | 1035 | AM_RANGE(0xff8264, 0xff8265) AM_READWRITE(atariste_shifter_pixelofs_r, atariste_shifter_pixelofs_w) |
| 907 | 1036 | AM_RANGE(0xff8604, 0xff8605) AM_READWRITE(atarist_fdc_data_r, atarist_fdc_data_w) |
| 908 | 1037 | AM_RANGE(0xff8606, 0xff8607) AM_READWRITE(atarist_fdc_dma_status_r, atarist_fdc_dma_mode_w) |
| 909 | | AM_RANGE(0xff8608, 0xff860d) AM_READWRITE(atarist_fdc_dma_base_r, atarist_fdc_dma_base_w) |
| 1038 | AM_RANGE(0xff8608, 0xff860d) AM_READWRITE8(atarist_fdc_dma_base_r, atarist_fdc_dma_base_w, 0x00ff) |
| 910 | 1039 | AM_RANGE(0xff8800, 0xff8801) AM_DEVREADWRITE8(YM2149_TAG, ay8910_r, ay8910_data_w, 0xff00) |
| 911 | 1040 | AM_RANGE(0xff8802, 0xff8803) AM_DEVWRITE8(YM2149_TAG, ay8910_data_w, 0xff00) |
| 912 | 1041 | AM_RANGE(0xff8900, 0xff8901) AM_READWRITE(atariste_sound_dma_control_r, atariste_sound_dma_control_w) |
| r9957 | r9958 | |
| 961 | 1090 | AM_RANGE(0xff8264, 0xff8265) AM_READWRITE(atariste_shifter_pixelofs_r, atariste_shifter_pixelofs_w) |
| 962 | 1091 | AM_RANGE(0xff8604, 0xff8605) AM_READWRITE(atarist_fdc_data_r, atarist_fdc_data_w) |
| 963 | 1092 | AM_RANGE(0xff8606, 0xff8607) AM_READWRITE(atarist_fdc_dma_status_r, atarist_fdc_dma_mode_w) |
| 964 | | AM_RANGE(0xff8608, 0xff860d) AM_READWRITE(atarist_fdc_dma_base_r, atarist_fdc_dma_base_w) |
| 1093 | AM_RANGE(0xff8608, 0xff860d) AM_READWRITE8(atarist_fdc_dma_base_r, atarist_fdc_dma_base_w, 0x00ff) |
| 965 | 1094 | AM_RANGE(0xff8800, 0xff8801) AM_DEVREADWRITE8(YM2149_TAG, ay8910_r, ay8910_data_w, 0xff00) |
| 966 | 1095 | AM_RANGE(0xff8802, 0xff8803) AM_DEVWRITE8(YM2149_TAG, ay8910_data_w, 0xff00) |
| 967 | 1096 | AM_RANGE(0xff8900, 0xff8901) AM_READWRITE(atariste_sound_dma_control_r, atariste_sound_dma_control_w) |
| r9957 | r9958 | |
| 1016 | 1145 | AM_RANGE(0xff827e, 0xff827f) AM_WRITE(stbook_lcd_control_w) |
| 1017 | 1146 | AM_RANGE(0xff8604, 0xff8605) AM_READWRITE(atarist_fdc_data_r, atarist_fdc_data_w) |
| 1018 | 1147 | AM_RANGE(0xff8606, 0xff8607) AM_READWRITE(atarist_fdc_dma_status_r, atarist_fdc_dma_mode_w) |
| 1019 | | AM_RANGE(0xff8608, 0xff860d) AM_READWRITE(atarist_fdc_dma_base_r, atarist_fdc_dma_base_w) |
| 1148 | AM_RANGE(0xff8608, 0xff860d) AM_READWRITE8(atarist_fdc_dma_base_r, atarist_fdc_dma_base_w, 0x00ff) |
| 1020 | 1149 | AM_RANGE(0xff8800, 0xff8801) AM_DEVREADWRITE8(YM3439_TAG, ay8910_r, ay8910_data_w, 0xff00) |
| 1021 | 1150 | AM_RANGE(0xff8802, 0xff8803) AM_DEVWRITE8(YM3439_TAG, ay8910_data_w, 0xff00) |
| 1022 | 1151 | AM_RANGE(0xff8900, 0xff8901) AM_READWRITE(atariste_sound_dma_control_r, atariste_sound_dma_control_w) |
| r9957 | r9958 | |
| 1497 | 1626 | { |
| 1498 | 1627 | atarist_state *state = machine->driver_data<atarist_state>(); |
| 1499 | 1628 | |
| 1500 | | state->fdc_status |= ATARIST_FLOPPY_STATUS_DMA_ERROR; |
| 1629 | state->fdc_status |= DMA_STATUS_ERROR; |
| 1501 | 1630 | |
| 1502 | 1631 | state_save_register_global(machine, state->mmu); |
| 1503 | 1632 | state_save_register_global(machine, state->fdc_dmabase); |
| r9957 | r9958 | |
| 1537 | 1666 | |
| 1538 | 1667 | /* register for state saving */ |
| 1539 | 1668 | atarist_state_save(machine); |
| 1669 | |
| 1670 | address_space *program = cputag_get_address_space(machine, M68000_TAG, ADDRESS_SPACE_PROGRAM); |
| 1671 | program->write_word(0, 0x60ae); |
| 1672 | program->write_word(2, 0x0104); |
| 1673 | program->write_word(4, 0x00fc); |
| 1674 | program->write_word(6, 0x0030); |
| 1540 | 1675 | } |
| 1541 | 1676 | |
| 1542 | 1677 | static const struct rp5c15_interface rtc_intf = |