src/mess/drivers/cdi.c
| r6256 | r6257 | |
| 13 | 13 | |
| 14 | 14 | STATUS: |
| 15 | 15 | |
| 16 | | Some games will start up, but fail horribly. |
| 16 | Some games are playable, but many suffer from bugs and/or crashes. |
| 17 | 17 | |
| 18 | 18 | TODO: |
| 19 | 19 | |
| 20 | | -Proper handling of the 68070 (68k with 32 address lines instead of 24) |
| 21 | | & handle the extra features properly (UART,DMA,Timers etc.) |
| 20 | - Proper handling of the 68070's internal devices (UART,DMA,Timers etc.) |
| 22 | 21 | |
| 23 | | -Full emulation of the 66470 and/or MCD212 Video Chip (still many unhandled features) |
| 22 | - Full emulation of the 66470 and/or MCD212 Video Chip |
| 24 | 23 | |
| 25 | | -Unknown sound chip (CD-i ADPCM); |
| 26 | | |
| 27 | 24 | *******************************************************************************/ |
| 28 | 25 | |
| 29 | | |
| 30 | 26 | #define CLOCK_A XTAL_30MHz |
| 31 | 27 | #define CLOCK_B XTAL_19_6608MHz |
| 32 | 28 | |
| r6256 | r6257 | |
| 49 | 45 | |
| 50 | 46 | #define ENABLE_UART_PRINTING (0) |
| 51 | 47 | |
| 52 | | #define VERBOSE_LEVEL (6) |
| 48 | #define VERBOSE_LEVEL (5) |
| 53 | 49 | |
| 54 | | #define ENABLE_VERBOSE_LOG (1) |
| 50 | #define ENABLE_VERBOSE_LOG (0) |
| 55 | 51 | |
| 56 | 52 | #if ENABLE_VERBOSE_LOG |
| 57 | 53 | INLINE void verboselog(running_machine *machine, int n_level, const char *s_fmt, ...) |
| r6256 | r6257 | |
| 310 | 306 | typedef struct |
| 311 | 307 | { |
| 312 | 308 | UINT16 lir; |
| 309 | UINT8 picr1; |
| 310 | UINT8 picr2; |
| 311 | |
| 313 | 312 | scc68070_i2c_regs_t i2c; |
| 314 | 313 | scc68070_uart_regs_t uart; |
| 315 | 314 | scc68070_timer_regs_t timers; |
| 316 | | UINT8 picr1; |
| 317 | | UINT8 picr2; |
| 318 | 315 | scc68070_dma_regs_t dma; |
| 319 | 316 | scc68070_mmu_regs_t mmu; |
| 320 | 317 | } scc68070_regs_t; |
| r6256 | r6257 | |
| 885 | 882 | } |
| 886 | 883 | } |
| 887 | 884 | |
| 885 | static void scc68070_init(running_machine *machine, scc68070_regs_t *scc68070) |
| 886 | { |
| 887 | int index = 0; |
| 888 | scc68070->lir = 0; |
| 889 | |
| 890 | scc68070->picr1 = 0; |
| 891 | scc68070->picr2 = 0; |
| 892 | |
| 893 | scc68070->i2c.data_register = 0; |
| 894 | scc68070->i2c.address_register = 0; |
| 895 | scc68070->i2c.status_register = 0; |
| 896 | scc68070->i2c.control_register = 0; |
| 897 | scc68070->i2c.clock_control_register = 0; |
| 898 | |
| 899 | scc68070->uart.mode_register = 0; |
| 900 | scc68070->uart.status_register = 0; |
| 901 | scc68070->uart.clock_select = 0; |
| 902 | scc68070->uart.command_register = 0; |
| 903 | scc68070->uart.transmit_holding_register = 0; |
| 904 | scc68070->uart.receive_holding_register = 0; |
| 905 | |
| 906 | scc68070->timers.timer_status_register = 0; |
| 907 | scc68070->timers.timer_control_register = 0; |
| 908 | scc68070->timers.reload_register = 0; |
| 909 | scc68070->timers.timer0 = 0; |
| 910 | scc68070->timers.timer1 = 0; |
| 911 | scc68070->timers.timer2 = 0; |
| 912 | |
| 913 | for(index = 0; index < 2; index++) |
| 914 | { |
| 915 | scc68070->dma.channel[index].channel_status = 0; |
| 916 | scc68070->dma.channel[index].channel_error = 0; |
| 917 | scc68070->dma.channel[index].device_control = 0; |
| 918 | scc68070->dma.channel[index].operation_control = 0; |
| 919 | scc68070->dma.channel[index].sequence_control = 0; |
| 920 | scc68070->dma.channel[index].channel_control = 0; |
| 921 | scc68070->dma.channel[index].transfer_counter = 0; |
| 922 | scc68070->dma.channel[index].memory_address_counter = 0; |
| 923 | scc68070->dma.channel[index].device_address_counter = 0; |
| 924 | } |
| 925 | |
| 926 | scc68070->mmu.status = 0; |
| 927 | scc68070->mmu.control = 0; |
| 928 | for(index = 0; index < 8; index++) |
| 929 | { |
| 930 | scc68070->mmu.desc[index].attr = 0; |
| 931 | scc68070->mmu.desc[index].length = 0; |
| 932 | scc68070->mmu.desc[index].segment = 0; |
| 933 | scc68070->mmu.desc[index].base = 0; |
| 934 | } |
| 935 | } |
| 936 | |
| 888 | 937 | #if ENABLE_UART_PRINTING |
| 889 | 938 | static READ16_HANDLER( uart_loopback_enable ) |
| 890 | 939 | { |
| r6256 | r6257 | |
| 896 | 945 | |
| 897 | 946 | typedef struct |
| 898 | 947 | { |
| 899 | | UINT16 busy_clear_countdown; |
| 900 | 948 | UINT16 command; // CDIC Command Register (0x303c00) |
| 901 | 949 | UINT32 time; // CDIC Time Register (0x303c02) |
| 902 | 950 | UINT16 file; // CDIC File Register (0x303c06) |
| r6256 | r6257 | |
| 910 | 958 | UINT16 interrupt_vector; // CDIC Interrupt Vector Register (0x303ffc) |
| 911 | 959 | UINT16 data_buffer; // CDIC Data Buffer Register (0x303ffe) |
| 912 | 960 | |
| 913 | | UINT8 buffer_target; |
| 914 | | |
| 915 | 961 | emu_timer *interrupt_timer; |
| 916 | 962 | cdrom_file *cd; |
| 917 | 963 | |
| r6256 | r6257 | |
| 1227 | 1273 | int bits = 4; |
| 1228 | 1274 | int index = 0; |
| 1229 | 1275 | INT16 samples[18*28*16+16]; |
| 1230 | | FILE* temp_adpcm = fopen("temp_adpcm.bin","ab"); |
| 1276 | //FILE* temp_adpcm = fopen("temp_adpcm.bin","ab"); |
| 1231 | 1277 | |
| 1232 | 1278 | //printf( "%02x\n", hdr[2] & 0x3f ); |
| 1233 | 1279 | |
| r6256 | r6257 | |
| 1235 | 1281 | { |
| 1236 | 1282 | // Don't play |
| 1237 | 1283 | //timer_adjust_oneshot(cdic_regs.audio_sample_timer, attotime_never, 0); |
| 1238 | | fclose(temp_adpcm); |
| 1284 | //fclose(temp_adpcm); |
| 1239 | 1285 | return; |
| 1240 | 1286 | } |
| 1241 | 1287 | |
| 1242 | 1288 | verboselog(machine, 0, "cdic_decode_audio_sector, got header type %02x\n", hdr[2] ); |
| 1243 | 1289 | |
| 1244 | | fseek(temp_adpcm, 0, SEEK_END); |
| 1290 | //fseek(temp_adpcm, 0, SEEK_END); |
| 1245 | 1291 | switch(hdr[2] & 0x3f) // ignore emphasis and reserved bits |
| 1246 | 1292 | { |
| 1247 | 1293 | case 0: |
| r6256 | r6257 | |
| 1328 | 1374 | cdic_decode_xa_stereo(hdr + 4, samples); |
| 1329 | 1375 | samples[18*28*8 + 0] = samples[18*28*8 + 2] = samples[18*28*8 + 4] = samples[18*28*8 + 6] = samples[18*28*8 + 8] = samples[18*28*8 + 10] = samples[18*28*8 + 12] = samples[18*28*8 + 14] = samples[18*28*8 - 2]; |
| 1330 | 1376 | samples[18*28*8 + 1] = samples[18*28*8 + 3] = samples[18*28*8 + 5] = samples[18*28*8 + 7] = samples[18*28*8 + 9] = samples[18*28*8 + 11] = samples[18*28*8 + 13] = samples[18*28*8 + 15] = samples[18*28*8 - 1]; |
| 1331 | | fwrite(samples, 1, 18*28*4*cdic_regs.audio_sample_size, temp_adpcm); |
| 1377 | //fwrite(samples, 1, 18*28*4*cdic_regs.audio_sample_size, temp_adpcm); |
| 1332 | 1378 | break; |
| 1333 | 1379 | case 8: |
| 1334 | 1380 | cdic_decode_xa_stereo8(hdr + 4, samples); |
| r6256 | r6257 | |
| 1341 | 1387 | |
| 1342 | 1388 | dmadac_transfer(&dmadac[0], 2, 1, 2, 18*28*2*cdic_regs.audio_sample_size, samples); |
| 1343 | 1389 | |
| 1344 | | fclose(temp_adpcm); |
| 1390 | //fclose(temp_adpcm); |
| 1345 | 1391 | } |
| 1346 | 1392 | |
| 1347 | 1393 | // After an appropriate delay for decoding to take place... |
| r6256 | r6257 | |
| 2017 | 2063 | } |
| 2018 | 2064 | } |
| 2019 | 2065 | |
| 2066 | static void cdic_init(running_machine *machine, cdic_regs_t *cdic) |
| 2067 | { |
| 2068 | cdic->command = 0; |
| 2069 | cdic->time = 0; |
| 2070 | cdic->file = 0; |
| 2071 | cdic->channel = 0xffffffff; |
| 2072 | cdic->audio_channel = 0xffff; |
| 2073 | cdic->audio_buffer = 0; |
| 2074 | cdic->x_buffer = 0; |
| 2075 | cdic->dma_control = 0; |
| 2076 | cdic->z_buffer = 0; |
| 2077 | cdic->interrupt_vector = 0; |
| 2078 | cdic->data_buffer = 0; |
| 2079 | |
| 2080 | cdic->audio_sample_freq = 0; |
| 2081 | cdic->audio_sample_size = 0; |
| 2082 | } |
| 2083 | |
| 2020 | 2084 | typedef struct |
| 2021 | 2085 | { |
| 2022 | 2086 | UINT8 out_buf[4]; |
| r6256 | r6257 | |
| 2394 | 2458 | } |
| 2395 | 2459 | } |
| 2396 | 2460 | |
| 2461 | static void slave_init(running_machine *machine, slave_regs_t *slave) |
| 2462 | { |
| 2463 | int index = 0; |
| 2464 | for(index = 0; index < 4; index++) |
| 2465 | { |
| 2466 | slave->channel[index].out_buf[0] = 0; |
| 2467 | slave->channel[index].out_buf[1] = 0; |
| 2468 | slave->channel[index].out_buf[2] = 0; |
| 2469 | slave->channel[index].out_buf[3] = 0; |
| 2470 | slave->channel[index].out_index = 0; |
| 2471 | slave->channel[index].out_count = 0; |
| 2472 | slave->channel[index].out_cmd = 0; |
| 2473 | } |
| 2474 | |
| 2475 | memset(slave->in_buf, 0, 17); |
| 2476 | slave->in_index = 0; |
| 2477 | slave->in_count = 0; |
| 2478 | |
| 2479 | slave->polling_active = 0; |
| 2480 | |
| 2481 | slave->xbus_interrupt_enable = 0; |
| 2482 | |
| 2483 | memset(slave->lcd_state, 0, 16); |
| 2484 | |
| 2485 | slave->real_mouse_x = 0; |
| 2486 | slave->real_mouse_y = 0; |
| 2487 | |
| 2488 | slave->fake_mouse_x = 0; |
| 2489 | slave->fake_mouse_y = 0; |
| 2490 | } |
| 2491 | |
| 2397 | 2492 | /************************* |
| 2398 | 2493 | * Video Hardware * |
| 2399 | 2494 | *************************/ |
| r6256 | r6257 | |
| 2440 | 2535 | emu_timer *scan_timer; |
| 2441 | 2536 | UINT8 region_flag_0[768]; |
| 2442 | 2537 | UINT8 region_flag_1[768]; |
| 2443 | | } mcd212_t; |
| 2538 | } mcd212_regs_t; |
| 2444 | 2539 | |
| 2445 | | static mcd212_t mcd212; |
| 2540 | static mcd212_regs_t mcd212_regs; |
| 2446 | 2541 | |
| 2447 | 2542 | #define MCD212_CURCNT_COLOR 0x00000f // Cursor color |
| 2448 | 2543 | #define MCD212_CURCNT_CUW 0x008000 // Cursor width |
| r6256 | r6257 | |
| 2578 | 2673 | case 0x10/2: |
| 2579 | 2674 | if(ACCESSING_BITS_0_7) |
| 2580 | 2675 | { |
| 2581 | | verboselog(space->machine, 12, "mcd212_r: Status Register %d: %02x & %04x\n", channel + 1, mcd212.channel[1 - (offset / 8)].csrr, mem_mask); |
| 2676 | verboselog(space->machine, 12, "mcd212_r: Status Register %d: %02x & %04x\n", channel + 1, mcd212_regs.channel[1 - (offset / 8)].csrr, mem_mask); |
| 2582 | 2677 | if(channel == 0) |
| 2583 | 2678 | { |
| 2584 | | return mcd212.channel[0].csrr; |
| 2679 | return mcd212_regs.channel[0].csrr; |
| 2585 | 2680 | } |
| 2586 | 2681 | else |
| 2587 | 2682 | { |
| 2588 | | UINT8 old_csr = mcd212.channel[1].csrr; |
| 2683 | UINT8 old_csr = mcd212_regs.channel[1].csrr; |
| 2589 | 2684 | UINT8 interrupt1 = (scc68070_regs.lir >> 4) & 7; |
| 2590 | 2685 | //UINT8 interrupt2 = scc68070_regs.lir & 7; |
| 2591 | | mcd212.channel[1].csrr &= ~(MCD212_CSR2R_IT1 | MCD212_CSR2R_IT2); |
| 2686 | mcd212_regs.channel[1].csrr &= ~(MCD212_CSR2R_IT1 | MCD212_CSR2R_IT2); |
| 2592 | 2687 | if(interrupt1) |
| 2593 | 2688 | { |
| 2594 | 2689 | cputag_set_input_line(space->machine, "maincpu", M68K_IRQ_1 + (interrupt1 - 1), CLEAR_LINE); |
| r6256 | r6257 | |
| 2607 | 2702 | break; |
| 2608 | 2703 | case 0x02/2: |
| 2609 | 2704 | case 0x12/2: |
| 2610 | | verboselog(space->machine, 2, "mcd212_r: Display Command Register %d: %04x & %04x\n", (1 - (offset / 8)) + 1, mcd212.channel[1 - (offset / 8)].dcr, mem_mask); |
| 2611 | | return mcd212.channel[1 - (offset / 8)].dcr; |
| 2705 | verboselog(space->machine, 2, "mcd212_r: Display Command Register %d: %04x & %04x\n", (1 - (offset / 8)) + 1, mcd212_regs.channel[1 - (offset / 8)].dcr, mem_mask); |
| 2706 | return mcd212_regs.channel[1 - (offset / 8)].dcr; |
| 2612 | 2707 | case 0x04/2: |
| 2613 | 2708 | case 0x14/2: |
| 2614 | | verboselog(space->machine, 2, "mcd212_r: Video Start Register %d: %04x & %04x\n", (1 - (offset / 8)) + 1, mcd212.channel[1 - (offset / 8)].vsr, mem_mask); |
| 2615 | | return mcd212.channel[1 - (offset / 8)].vsr; |
| 2709 | verboselog(space->machine, 2, "mcd212_r: Video Start Register %d: %04x & %04x\n", (1 - (offset / 8)) + 1, mcd212_regs.channel[1 - (offset / 8)].vsr, mem_mask); |
| 2710 | return mcd212_regs.channel[1 - (offset / 8)].vsr; |
| 2616 | 2711 | case 0x08/2: |
| 2617 | 2712 | case 0x18/2: |
| 2618 | | verboselog(space->machine, 2, "mcd212_r: Display Decoder Register %d: %04x & %04x\n", (1 - (offset / 8)) + 1, mcd212.channel[1 - (offset / 8)].ddr, mem_mask); |
| 2619 | | return mcd212.channel[1 - (offset / 8)].ddr; |
| 2713 | verboselog(space->machine, 2, "mcd212_r: Display Decoder Register %d: %04x & %04x\n", (1 - (offset / 8)) + 1, mcd212_regs.channel[1 - (offset / 8)].ddr, mem_mask); |
| 2714 | return mcd212_regs.channel[1 - (offset / 8)].ddr; |
| 2620 | 2715 | case 0x0a/2: |
| 2621 | 2716 | case 0x1a/2: |
| 2622 | | verboselog(space->machine, 2, "mcd212_r: DCA Pointer Register %d: %04x & %04x\n", (1 - (offset / 8)) + 1, mcd212.channel[1 - (offset / 8)].dcp, mem_mask); |
| 2623 | | return mcd212.channel[1 - (offset / 8)].dcp; |
| 2717 | verboselog(space->machine, 2, "mcd212_r: DCA Pointer Register %d: %04x & %04x\n", (1 - (offset / 8)) + 1, mcd212_regs.channel[1 - (offset / 8)].dcp, mem_mask); |
| 2718 | return mcd212_regs.channel[1 - (offset / 8)].dcp; |
| 2624 | 2719 | default: |
| 2625 | 2720 | verboselog(space->machine, 2, "mcd212_r: Unknown Register %d & %04x\n", (1 - (offset / 8)) + 1, mem_mask); |
| 2626 | 2721 | break; |
| r6256 | r6257 | |
| 2635 | 2730 | attoseconds_t period = video_screen_get_frame_period(machine->primary_screen).attoseconds; |
| 2636 | 2731 | int width = 0; |
| 2637 | 2732 | |
| 2638 | | if((mcd212.channel[0].dcr & (MCD212_DCR_CF | MCD212_DCR_FD)) && (mcd212.channel[0].csrw & MCD212_CSR1W_ST)) |
| 2733 | if((mcd212_regs.channel[0].dcr & (MCD212_DCR_CF | MCD212_DCR_FD)) && (mcd212_regs.channel[0].csrw & MCD212_CSR1W_ST)) |
| 2639 | 2734 | { |
| 2640 | 2735 | width = 360; |
| 2641 | 2736 | } |
| r6256 | r6257 | |
| 2656 | 2751 | case 0x00/2: |
| 2657 | 2752 | case 0x10/2: |
| 2658 | 2753 | verboselog(space->machine, 2, "mcd212_w: Status Register %d: %04x & %04x\n", (1 - (offset / 8)) + 1, data, mem_mask); |
| 2659 | | COMBINE_DATA(&mcd212.channel[1 - (offset / 8)].csrw); |
| 2754 | COMBINE_DATA(&mcd212_regs.channel[1 - (offset / 8)].csrw); |
| 2660 | 2755 | mcd212_update_visible_area(space->machine); |
| 2661 | 2756 | break; |
| 2662 | 2757 | case 0x02/2: |
| 2663 | 2758 | case 0x12/2: |
| 2664 | 2759 | verboselog(space->machine, 2, "mcd212_w: Display Command Register %d: %04x & %04x\n", (1 - (offset / 8)) + 1, data, mem_mask); |
| 2665 | | COMBINE_DATA(&mcd212.channel[1 - (offset / 8)].dcr); |
| 2760 | COMBINE_DATA(&mcd212_regs.channel[1 - (offset / 8)].dcr); |
| 2666 | 2761 | mcd212_update_visible_area(space->machine); |
| 2667 | 2762 | break; |
| 2668 | 2763 | case 0x04/2: |
| 2669 | 2764 | case 0x14/2: |
| 2670 | 2765 | verboselog(space->machine, 2, "mcd212_w: Video Start Register %d: %04x & %04x\n", (1 - (offset / 8)) + 1, data, mem_mask); |
| 2671 | | COMBINE_DATA(&mcd212.channel[1 - (offset / 8)].vsr); |
| 2766 | COMBINE_DATA(&mcd212_regs.channel[1 - (offset / 8)].vsr); |
| 2672 | 2767 | break; |
| 2673 | 2768 | case 0x08/2: |
| 2674 | 2769 | case 0x18/2: |
| 2675 | 2770 | verboselog(space->machine, 2, "mcd212_w: Display Decoder Register %d: %04x & %04x\n", (1 - (offset / 8)) + 1, data, mem_mask); |
| 2676 | | COMBINE_DATA(&mcd212.channel[1 - (offset / 8)].ddr); |
| 2771 | COMBINE_DATA(&mcd212_regs.channel[1 - (offset / 8)].ddr); |
| 2677 | 2772 | break; |
| 2678 | 2773 | case 0x0a/2: |
| 2679 | 2774 | case 0x1a/2: |
| 2680 | 2775 | verboselog(space->machine, 2, "mcd212_w: DCA Pointer Register %d: %04x & %04x\n", (1 - (offset / 8)) + 1, data, mem_mask); |
| 2681 | | COMBINE_DATA(&mcd212.channel[1 - (offset / 8)].dcp); |
| 2776 | COMBINE_DATA(&mcd212_regs.channel[1 - (offset / 8)].dcp); |
| 2682 | 2777 | break; |
| 2683 | 2778 | default: |
| 2684 | 2779 | verboselog(space->machine, 2, "mcd212_w: Unknown Register %d: %04x & %04x\n", (1 - (offset / 8)) + 1, data, mem_mask); |
| r6256 | r6257 | |
| 2698 | 2793 | case 0xa8: case 0xa9: case 0xaa: case 0xab: case 0xac: case 0xad: case 0xae: case 0xaf: |
| 2699 | 2794 | case 0xb0: case 0xb1: case 0xb2: case 0xb3: case 0xb4: case 0xb5: case 0xb6: case 0xb7: |
| 2700 | 2795 | case 0xb8: case 0xb9: case 0xba: case 0xbb: case 0xbc: case 0xbd: case 0xbe: case 0xbf: |
| 2701 | | verboselog(machine, 11, " %04xxxxx: %d: CLUT[%d] = %08x\n", channel * 0x20, channel, mcd212.channel[channel].clut_bank * 0x40 + (reg - 0x80), value ); |
| 2702 | | mcd212.channel[0].clut_r[mcd212.channel[channel].clut_bank * 0x40 + (reg - 0x80)] = (UINT8)(value >> 16) & 0xfc; |
| 2703 | | mcd212.channel[0].clut_g[mcd212.channel[channel].clut_bank * 0x40 + (reg - 0x80)] = (UINT8)(value >> 8) & 0xfc; |
| 2704 | | mcd212.channel[0].clut_b[mcd212.channel[channel].clut_bank * 0x40 + (reg - 0x80)] = (UINT8)(value >> 0) & 0xfc; |
| 2796 | verboselog(machine, 11, " %04xxxxx: %d: CLUT[%d] = %08x\n", channel * 0x20, channel, mcd212_regs.channel[channel].clut_bank * 0x40 + (reg - 0x80), value ); |
| 2797 | mcd212_regs.channel[0].clut_r[mcd212_regs.channel[channel].clut_bank * 0x40 + (reg - 0x80)] = (UINT8)(value >> 16) & 0xfc; |
| 2798 | mcd212_regs.channel[0].clut_g[mcd212_regs.channel[channel].clut_bank * 0x40 + (reg - 0x80)] = (UINT8)(value >> 8) & 0xfc; |
| 2799 | mcd212_regs.channel[0].clut_b[mcd212_regs.channel[channel].clut_bank * 0x40 + (reg - 0x80)] = (UINT8)(value >> 0) & 0xfc; |
| 2705 | 2800 | break; |
| 2706 | 2801 | case 0xc0: // Image Coding Method |
| 2707 | 2802 | if(channel == 0) |
| 2708 | 2803 | { |
| 2709 | 2804 | verboselog(machine, 6, " %04xxxxx: %d: Image Coding Method = %08x\n", channel * 0x20, channel, value ); |
| 2710 | | mcd212.channel[channel].image_coding_method = value; |
| 2805 | mcd212_regs.channel[channel].image_coding_method = value; |
| 2711 | 2806 | } |
| 2712 | 2807 | break; |
| 2713 | 2808 | case 0xc1: // Transparency Control |
| 2714 | 2809 | if(channel == 0) |
| 2715 | 2810 | { |
| 2716 | 2811 | verboselog(machine, 6, " %04xxxxx: %d: Transparency Control = %08x\n", channel * 0x20, channel, value ); |
| 2717 | | mcd212.channel[channel].transparency_control = value; |
| 2812 | mcd212_regs.channel[channel].transparency_control = value; |
| 2718 | 2813 | } |
| 2719 | 2814 | break; |
| 2720 | 2815 | case 0xc2: // Plane Order |
| 2721 | 2816 | if(channel == 0) |
| 2722 | 2817 | { |
| 2723 | 2818 | verboselog(machine, 6, " %04xxxxx: %d: Plane Order = %08x\n", channel * 0x20, channel, value & 7); |
| 2724 | | mcd212.channel[channel].plane_order = value & 0x00000007; |
| 2819 | mcd212_regs.channel[channel].plane_order = value & 0x00000007; |
| 2725 | 2820 | } |
| 2726 | 2821 | break; |
| 2727 | 2822 | case 0xc3: // CLUT Bank Register |
| 2728 | 2823 | verboselog(machine, 6, " %04xxxxx: %d: CLUT Bank Register = %08x\n", channel * 0x20, channel, value & 3); |
| 2729 | | mcd212.channel[channel].clut_bank = channel ? (2 | (value & 0x00000001)) : (value & 0x00000003); |
| 2824 | mcd212_regs.channel[channel].clut_bank = channel ? (2 | (value & 0x00000001)) : (value & 0x00000003); |
| 2730 | 2825 | break; |
| 2731 | 2826 | case 0xc4: // Transparent Color A |
| 2732 | 2827 | if(channel == 0) |
| 2733 | 2828 | { |
| 2734 | 2829 | verboselog(machine, 6, " %04xxxxx: %d: Transparent Color A = %08x\n", channel * 0x20, channel, value ); |
| 2735 | | mcd212.channel[channel].transparent_color_a = value & 0xfcfcfc; |
| 2830 | mcd212_regs.channel[channel].transparent_color_a = value & 0xfcfcfc; |
| 2736 | 2831 | } |
| 2737 | 2832 | break; |
| 2738 | 2833 | case 0xc6: // Transparent Color B |
| 2739 | 2834 | if(channel == 1) |
| 2740 | 2835 | { |
| 2741 | 2836 | verboselog(machine, 6, " %04xxxxx: %d: Transparent Color B = %08x\n", channel * 0x20, channel, value ); |
| 2742 | | mcd212.channel[channel].transparent_color_b = value & 0xfcfcfc; |
| 2837 | mcd212_regs.channel[channel].transparent_color_b = value & 0xfcfcfc; |
| 2743 | 2838 | } |
| 2744 | 2839 | break; |
| 2745 | 2840 | case 0xc7: // Mask Color A |
| 2746 | 2841 | if(channel == 0) |
| 2747 | 2842 | { |
| 2748 | 2843 | verboselog(machine, 6, " %04xxxxx: %d: Mask Color A = %08x\n", channel * 0x20, channel, value ); |
| 2749 | | mcd212.channel[channel].mask_color_a = value & 0xfcfcfc; |
| 2844 | mcd212_regs.channel[channel].mask_color_a = value & 0xfcfcfc; |
| 2750 | 2845 | } |
| 2751 | 2846 | break; |
| 2752 | 2847 | case 0xc9: // Mask Color B |
| 2753 | 2848 | if(channel == 1) |
| 2754 | 2849 | { |
| 2755 | 2850 | verboselog(machine, 6, " %04xxxxx: %d: Mask Color B = %08x\n", channel * 0x20, channel, value ); |
| 2756 | | mcd212.channel[channel].mask_color_b = value & 0xfcfcfc; |
| 2851 | mcd212_regs.channel[channel].mask_color_b = value & 0xfcfcfc; |
| 2757 | 2852 | } |
| 2758 | 2853 | break; |
| 2759 | 2854 | case 0xca: // Delta YUV Absolute Start Value A |
| 2760 | 2855 | if(channel == 0) |
| 2761 | 2856 | { |
| 2762 | 2857 | verboselog(machine, 6, " %04xxxxx: %d: Delta YUV Absolute Start Value A = %08x\n", channel * 0x20, channel, value ); |
| 2763 | | mcd212.channel[channel].dyuv_abs_start_a = value; |
| 2858 | mcd212_regs.channel[channel].dyuv_abs_start_a = value; |
| 2764 | 2859 | } |
| 2765 | 2860 | break; |
| 2766 | 2861 | case 0xcb: // Delta YUV Absolute Start Value B |
| 2767 | 2862 | if(channel == 1) |
| 2768 | 2863 | { |
| 2769 | 2864 | verboselog(machine, 6, " %04xxxxx: %d: Delta YUV Absolute Start Value B = %08x\n", channel * 0x20, channel, value ); |
| 2770 | | mcd212.channel[channel].dyuv_abs_start_b = value; |
| 2865 | mcd212_regs.channel[channel].dyuv_abs_start_b = value; |
| 2771 | 2866 | } |
| 2772 | 2867 | break; |
| 2773 | 2868 | case 0xcd: // Cursor Position |
| 2774 | 2869 | if(channel == 0) |
| 2775 | 2870 | { |
| 2776 | 2871 | verboselog(machine, 6, " %04xxxxx: %d: Cursor Position = %08x\n", channel * 0x20, channel, value ); |
| 2777 | | mcd212.channel[channel].cursor_position = value; |
| 2872 | mcd212_regs.channel[channel].cursor_position = value; |
| 2778 | 2873 | } |
| 2779 | 2874 | break; |
| 2780 | 2875 | case 0xce: // Cursor Control |
| 2781 | 2876 | if(channel == 0) |
| 2782 | 2877 | { |
| 2783 | 2878 | verboselog(machine, 11, " %04xxxxx: %d: Cursor Control = %08x\n", channel * 0x20, channel, value ); |
| 2784 | | mcd212.channel[channel].cursor_control = value; |
| 2879 | mcd212_regs.channel[channel].cursor_control = value; |
| 2785 | 2880 | } |
| 2786 | 2881 | break; |
| 2787 | 2882 | case 0xcf: // Cursor Pattern |
| 2788 | 2883 | if(channel == 0) |
| 2789 | 2884 | { |
| 2790 | 2885 | verboselog(machine, 11, " %04xxxxx: %d: Cursor Pattern[%d] = %04x\n", channel * 0x20, channel, (value >> 16) & 0x000f, value & 0x0000ffff); |
| 2791 | | mcd212.channel[channel].cursor_pattern[(value >> 16) & 0x000f] = value & 0x0000ffff; |
| 2886 | mcd212_regs.channel[channel].cursor_pattern[(value >> 16) & 0x000f] = value & 0x0000ffff; |
| 2792 | 2887 | } |
| 2793 | 2888 | break; |
| 2794 | 2889 | case 0xd0: // Region Control 0-7 |
| r6256 | r6257 | |
| 2800 | 2895 | case 0xd6: |
| 2801 | 2896 | case 0xd7: |
| 2802 | 2897 | verboselog(machine, 6, " %04xxxxx: %d: Region Control %d = %08x\n", channel * 0x20, channel, reg & 7, value ); |
| 2803 | | mcd212.channel[0].region_control[reg & 7] = value; |
| 2898 | mcd212_regs.channel[0].region_control[reg & 7] = value; |
| 2804 | 2899 | mcd212_update_region_arrays(machine); |
| 2805 | 2900 | break; |
| 2806 | 2901 | case 0xd8: // Backdrop Color |
| 2807 | 2902 | if(channel == 0) |
| 2808 | 2903 | { |
| 2809 | 2904 | verboselog(machine, 6, " %04xxxxx: %d: Backdrop Color = %08x\n", channel * 0x20, channel, value ); |
| 2810 | | mcd212.channel[channel].backdrop_color = value; |
| 2905 | mcd212_regs.channel[channel].backdrop_color = value; |
| 2811 | 2906 | } |
| 2812 | 2907 | break; |
| 2813 | 2908 | case 0xd9: // Mosaic Pixel Hold Factor A |
| 2814 | 2909 | if(channel == 0) |
| 2815 | 2910 | { |
| 2816 | 2911 | verboselog(machine, 6, " %04xxxxx: %d: Mosaic Pixel Hold Factor A = %08x\n", channel * 0x20, channel, value ); |
| 2817 | | mcd212.channel[channel].mosaic_hold_a = value; |
| 2912 | mcd212_regs.channel[channel].mosaic_hold_a = value; |
| 2818 | 2913 | } |
| 2819 | 2914 | break; |
| 2820 | 2915 | case 0xda: // Mosaic Pixel Hold Factor B |
| 2821 | 2916 | if(channel == 1) |
| 2822 | 2917 | { |
| 2823 | 2918 | verboselog(machine, 6, " %04xxxxx: %d: Mosaic Pixel Hold Factor B = %08x\n", channel * 0x20, channel, value ); |
| 2824 | | mcd212.channel[channel].mosaic_hold_b = value; |
| 2919 | mcd212_regs.channel[channel].mosaic_hold_b = value; |
| 2825 | 2920 | } |
| 2826 | 2921 | break; |
| 2827 | 2922 | case 0xdb: // Weight Factor A |
| 2828 | 2923 | if(channel == 0) |
| 2829 | 2924 | { |
| 2830 | 2925 | verboselog(machine, 6, " %04xxxxx: %d: Weight Factor A = %08x\n", channel * 0x20, channel, value ); |
| 2831 | | memset(mcd212.channel[channel].weight_factor_a, value & 0x000000ff, 768); |
| 2926 | memset(mcd212_regs.channel[channel].weight_factor_a, value & 0x000000ff, 768); |
| 2832 | 2927 | mcd212_update_region_arrays(machine); |
| 2833 | 2928 | } |
| 2834 | 2929 | break; |
| r6256 | r6257 | |
| 2836 | 2931 | if(channel == 1) |
| 2837 | 2932 | { |
| 2838 | 2933 | verboselog(machine, 6, " %04xxxxx: %d: Weight Factor B = %08x\n", channel * 0x20, channel, value ); |
| 2839 | | memset(mcd212.channel[channel].weight_factor_b, value & 0x000000ff, 768); |
| 2934 | memset(mcd212_regs.channel[channel].weight_factor_b, value & 0x000000ff, 768); |
| 2840 | 2935 | mcd212_update_region_arrays(machine); |
| 2841 | 2936 | } |
| 2842 | 2937 | break; |
| r6256 | r6257 | |
| 2845 | 2940 | |
| 2846 | 2941 | static void mcd212_set_vsr(int channel, UINT32 value) |
| 2847 | 2942 | { |
| 2848 | | mcd212.channel[channel].vsr = value & 0x0000ffff; |
| 2849 | | mcd212.channel[channel].dcr &= 0xffc0; |
| 2850 | | mcd212.channel[channel].dcr |= (value >> 16) & 0x003f; |
| 2943 | mcd212_regs.channel[channel].vsr = value & 0x0000ffff; |
| 2944 | mcd212_regs.channel[channel].dcr &= 0xffc0; |
| 2945 | mcd212_regs.channel[channel].dcr |= (value >> 16) & 0x003f; |
| 2851 | 2946 | } |
| 2852 | 2947 | |
| 2853 | 2948 | static UINT32 mcd212_get_vsr(int channel) |
| 2854 | 2949 | { |
| 2855 | | return ((mcd212.channel[channel].dcr & 0x3f) << 16) | mcd212.channel[channel].vsr; |
| 2950 | return ((mcd212_regs.channel[channel].dcr & 0x3f) << 16) | mcd212_regs.channel[channel].vsr; |
| 2856 | 2951 | } |
| 2857 | 2952 | |
| 2858 | 2953 | static void mcd212_set_dcp(int channel, UINT32 value) |
| 2859 | 2954 | { |
| 2860 | | mcd212.channel[channel].dcp = value & 0x0000ffff; |
| 2861 | | mcd212.channel[channel].ddr &= 0xffc0; |
| 2862 | | mcd212.channel[channel].ddr |= (value >> 16) & 0x003f; |
| 2955 | mcd212_regs.channel[channel].dcp = value & 0x0000ffff; |
| 2956 | mcd212_regs.channel[channel].ddr &= 0xffc0; |
| 2957 | mcd212_regs.channel[channel].ddr |= (value >> 16) & 0x003f; |
| 2863 | 2958 | } |
| 2864 | 2959 | |
| 2865 | 2960 | static UINT32 mcd212_get_dcp(int channel) |
| 2866 | 2961 | { |
| 2867 | | return ((mcd212.channel[channel].ddr & 0x3f) << 16) | mcd212.channel[channel].dcp; |
| 2962 | return ((mcd212_regs.channel[channel].ddr & 0x3f) << 16) | mcd212_regs.channel[channel].dcp; |
| 2868 | 2963 | } |
| 2869 | 2964 | |
| 2870 | 2965 | static void mcd212_set_display_parameters(int channel, UINT8 value) |
| 2871 | 2966 | { |
| 2872 | | mcd212.channel[channel].ddr &= 0xf0ff; |
| 2873 | | mcd212.channel[channel].ddr |= (value & 0x0f) << 8; |
| 2874 | | mcd212.channel[channel].dcr &= 0xf7ff; |
| 2875 | | mcd212.channel[channel].dcr |= (value & 0x10) << 7; |
| 2967 | mcd212_regs.channel[channel].ddr &= 0xf0ff; |
| 2968 | mcd212_regs.channel[channel].ddr |= (value & 0x0f) << 8; |
| 2969 | mcd212_regs.channel[channel].dcr &= 0xf7ff; |
| 2970 | mcd212_regs.channel[channel].dcr |= (value & 0x10) << 7; |
| 2876 | 2971 | } |
| 2877 | 2972 | |
| 2878 | 2973 | static void mcd212_process_ica(running_machine *machine, int channel) |
| r6256 | r6257 | |
| 2921 | 3016 | case 0x60: case 0x61: case 0x62: case 0x63: case 0x64: case 0x65: case 0x66: case 0x67: // INTERRUPT |
| 2922 | 3017 | case 0x68: case 0x69: case 0x6a: case 0x6b: case 0x6c: case 0x6d: case 0x6e: case 0x6f: |
| 2923 | 3018 | verboselog(machine, 11, "%08x: %08x: ICA %d: INTERRUPT\n", addr * 2 + channel * 0x200000, cmd, channel ); |
| 2924 | | mcd212.channel[1].csrr |= 1 << (2 - channel); |
| 2925 | | if(mcd212.channel[1].csrr & (MCD212_CSR2R_IT1 | MCD212_CSR2R_IT2)) |
| 3019 | mcd212_regs.channel[1].csrr |= 1 << (2 - channel); |
| 3020 | if(mcd212_regs.channel[1].csrr & (MCD212_CSR2R_IT1 | MCD212_CSR2R_IT2)) |
| 2926 | 3021 | { |
| 2927 | 3022 | UINT8 interrupt = (scc68070_regs.lir >> 4) & 7; |
| 2928 | 3023 | if(interrupt) |
| r6256 | r6257 | |
| 2932 | 3027 | } |
| 2933 | 3028 | } |
| 2934 | 3029 | /* |
| 2935 | | if(mcd212.channel[1].csrr & MCD212_CSR2R_IT2) |
| 3030 | if(mcd212_regs.channel[1].csrr & MCD212_CSR2R_IT2) |
| 2936 | 3031 | { |
| 2937 | 3032 | UINT8 interrupt = scc68070_regs.lir & 7; |
| 2938 | 3033 | if(interrupt) |
| r6256 | r6257 | |
| 2961 | 3056 | static void mcd212_process_dca(running_machine *machine, int channel) |
| 2962 | 3057 | { |
| 2963 | 3058 | UINT16 *dca = channel ? planeb : planea; |
| 2964 | | UINT32 addr = (mcd212.channel[channel].dca & 0x0007ffff) / 2; //(mcd212_get_dcp(channel) & 0x0007ffff) / 2; // mcd212.channel[channel].dca / 2; |
| 3059 | UINT32 addr = (mcd212_regs.channel[channel].dca & 0x0007ffff) / 2; //(mcd212_get_dcp(channel) & 0x0007ffff) / 2; // mcd212_regs.channel[channel].dca / 2; |
| 2965 | 3060 | UINT32 cmd = 0; |
| 2966 | 3061 | UINT32 count = 0; |
| 2967 | 3062 | UINT32 max = 64; |
| r6256 | r6257 | |
| 3010 | 3105 | case 0x60: case 0x61: case 0x62: case 0x63: case 0x64: case 0x65: case 0x66: case 0x67: // INTERRUPT |
| 3011 | 3106 | case 0x68: case 0x69: case 0x6a: case 0x6b: case 0x6c: case 0x6d: case 0x6e: case 0x6f: |
| 3012 | 3107 | verboselog(machine, 11, "%08x: %08x: DCA %d: INTERRUPT\n", addr * 2 + channel * 0x200000, cmd, channel ); |
| 3013 | | mcd212.channel[1].csrr |= 1 << (2 - channel); |
| 3014 | | if(mcd212.channel[1].csrr & (MCD212_CSR2R_IT1 | MCD212_CSR2R_IT2)) |
| 3108 | mcd212_regs.channel[1].csrr |= 1 << (2 - channel); |
| 3109 | if(mcd212_regs.channel[1].csrr & (MCD212_CSR2R_IT1 | MCD212_CSR2R_IT2)) |
| 3015 | 3110 | { |
| 3016 | 3111 | UINT8 interrupt = (scc68070_regs.lir >> 4) & 7; |
| 3017 | 3112 | if(interrupt) |
| r6256 | r6257 | |
| 3021 | 3116 | } |
| 3022 | 3117 | } |
| 3023 | 3118 | /* |
| 3024 | | if(mcd212.channel[1].csrr & MCD212_CSR2R_IT2) |
| 3119 | if(mcd212_regs.channel[1].csrr & MCD212_CSR2R_IT2) |
| 3025 | 3120 | { |
| 3026 | 3121 | UINT8 interrupt = scc68070_regs.lir & 7; |
| 3027 | 3122 | if(interrupt) |
| r6256 | r6257 | |
| 3052 | 3147 | addr += (max - count) >> 1; |
| 3053 | 3148 | } |
| 3054 | 3149 | } |
| 3055 | | mcd212.channel[channel].dca = addr * 2; |
| 3150 | mcd212_regs.channel[channel].dca = addr * 2; |
| 3056 | 3151 | } |
| 3057 | 3152 | |
| 3058 | 3153 | typedef UINT8 BYTE68K; |
| r6256 | r6257 | |
| 3143 | 3238 | |
| 3144 | 3239 | int latched_rf0 = 0; |
| 3145 | 3240 | int latched_rf1 = 0; |
| 3146 | | int latched_wfa = mcd212.channel[0].weight_factor_a[0]; |
| 3147 | | int latched_wfb = mcd212.channel[1].weight_factor_b[0]; |
| 3241 | int latched_wfa = mcd212_regs.channel[0].weight_factor_a[0]; |
| 3242 | int latched_wfb = mcd212_regs.channel[1].weight_factor_b[0]; |
| 3148 | 3243 | int reg = 0; |
| 3149 | 3244 | for(x = 0; x < 768; x++) |
| 3150 | 3245 | { |
| 3151 | | if(mcd212.channel[0].image_coding_method & MCD212_ICM_NR) |
| 3246 | if(mcd212_regs.channel[0].image_coding_method & MCD212_ICM_NR) |
| 3152 | 3247 | { |
| 3153 | 3248 | int reg = 0; |
| 3154 | 3249 | int flag = 0; |
| r6256 | r6257 | |
| 3157 | 3252 | { |
| 3158 | 3253 | for(reg = 0; reg < 4; reg++) |
| 3159 | 3254 | { |
| 3160 | | if(mcd212.channel[0].region_control[reg] == 0) |
| 3255 | if(mcd212_regs.channel[0].region_control[reg] == 0) |
| 3161 | 3256 | { |
| 3162 | 3257 | break; |
| 3163 | 3258 | } |
| 3164 | | if(x == (mcd212.channel[0].region_control[flag*4 + reg] & MCD212_RC_X)) |
| 3259 | if(x == (mcd212_regs.channel[0].region_control[flag*4 + reg] & MCD212_RC_X)) |
| 3165 | 3260 | { |
| 3166 | | switch((mcd212.channel[0].region_control[flag*4 + reg] & MCD212_RC_OP) >> MCD212_RC_OP_SHIFT) |
| 3261 | switch((mcd212_regs.channel[0].region_control[flag*4 + reg] & MCD212_RC_OP) >> MCD212_RC_OP_SHIFT) |
| 3167 | 3262 | { |
| 3168 | 3263 | case 0: // End of region control for line |
| 3169 | 3264 | break; |
| r6256 | r6257 | |
| 3172 | 3267 | case 3: // Not used |
| 3173 | 3268 | break; |
| 3174 | 3269 | case 4: // Change weight of plane A |
| 3175 | | latched_wfa = (mcd212.channel[0].region_control[flag*4 + reg] & MCD212_RC_WF) >> MCD212_RC_WF_SHIFT; |
| 3270 | latched_wfa = (mcd212_regs.channel[0].region_control[flag*4 + reg] & MCD212_RC_WF) >> MCD212_RC_WF_SHIFT; |
| 3176 | 3271 | break; |
| 3177 | 3272 | case 5: // Not used |
| 3178 | 3273 | break; |
| 3179 | 3274 | case 6: // Change weight of plane B |
| 3180 | | latched_wfb = (mcd212.channel[0].region_control[flag*4 + reg] & MCD212_RC_WF) >> MCD212_RC_WF_SHIFT; |
| 3275 | latched_wfb = (mcd212_regs.channel[0].region_control[flag*4 + reg] & MCD212_RC_WF) >> MCD212_RC_WF_SHIFT; |
| 3181 | 3276 | break; |
| 3182 | 3277 | case 7: // Not used |
| 3183 | 3278 | break; |
| r6256 | r6257 | |
| 3205 | 3300 | case 11: // Not used |
| 3206 | 3301 | break; |
| 3207 | 3302 | case 12: // Reset region flag and change weight of plane A |
| 3208 | | latched_wfa = (mcd212.channel[0].region_control[flag*4 + reg] & MCD212_RC_WF) >> MCD212_RC_WF_SHIFT; |
| 3303 | latched_wfa = (mcd212_regs.channel[0].region_control[flag*4 + reg] & MCD212_RC_WF) >> MCD212_RC_WF_SHIFT; |
| 3209 | 3304 | if(flag) |
| 3210 | 3305 | { |
| 3211 | 3306 | latched_rf1 = 0; |
| r6256 | r6257 | |
| 3216 | 3311 | } |
| 3217 | 3312 | break; |
| 3218 | 3313 | case 13: // Set region flag and change weight of plane A |
| 3219 | | latched_wfa = (mcd212.channel[0].region_control[flag*4 + reg] & MCD212_RC_WF) >> MCD212_RC_WF_SHIFT; |
| 3314 | latched_wfa = (mcd212_regs.channel[0].region_control[flag*4 + reg] & MCD212_RC_WF) >> MCD212_RC_WF_SHIFT; |
| 3220 | 3315 | if(flag) |
| 3221 | 3316 | { |
| 3222 | 3317 | latched_rf1 = 1; |
| r6256 | r6257 | |
| 3227 | 3322 | } |
| 3228 | 3323 | break; |
| 3229 | 3324 | case 14: // Reset region flag and change weight of plane B |
| 3230 | | latched_wfb = (mcd212.channel[0].region_control[flag*4 + reg] & MCD212_RC_WF) >> MCD212_RC_WF_SHIFT; |
| 3325 | latched_wfb = (mcd212_regs.channel[0].region_control[flag*4 + reg] & MCD212_RC_WF) >> MCD212_RC_WF_SHIFT; |
| 3231 | 3326 | if(flag) |
| 3232 | 3327 | { |
| 3233 | 3328 | latched_rf1 = 0; |
| r6256 | r6257 | |
| 3238 | 3333 | } |
| 3239 | 3334 | break; |
| 3240 | 3335 | case 15: // Set region flag and change weight of plane B |
| 3241 | | latched_wfb = (mcd212.channel[0].region_control[flag*4 + reg] & MCD212_RC_WF) >> MCD212_RC_WF_SHIFT; |
| 3336 | latched_wfb = (mcd212_regs.channel[0].region_control[flag*4 + reg] & MCD212_RC_WF) >> MCD212_RC_WF_SHIFT; |
| 3242 | 3337 | if(flag) |
| 3243 | 3338 | { |
| 3244 | 3339 | latched_rf1 = 1; |
| r6256 | r6257 | |
| 3257 | 3352 | { |
| 3258 | 3353 | if(reg < 8) |
| 3259 | 3354 | { |
| 3260 | | int flag = (mcd212.channel[0].region_control[reg] & MCD212_RC_RF) >> MCD212_RC_RF_SHIFT; |
| 3261 | | if(!(mcd212.channel[0].region_control[reg] & MCD212_RC_OP)) |
| 3355 | int flag = (mcd212_regs.channel[0].region_control[reg] & MCD212_RC_RF) >> MCD212_RC_RF_SHIFT; |
| 3356 | if(!(mcd212_regs.channel[0].region_control[reg] & MCD212_RC_OP)) |
| 3262 | 3357 | { |
| 3263 | 3358 | for(; x < 768; x++) |
| 3264 | 3359 | { |
| 3265 | | mcd212.channel[0].weight_factor_a[x] = latched_wfa; |
| 3266 | | mcd212.channel[1].weight_factor_b[x] = latched_wfb; |
| 3267 | | mcd212.region_flag_0[x] = latched_rf0; |
| 3268 | | mcd212.region_flag_1[x] = latched_rf1; |
| 3360 | mcd212_regs.channel[0].weight_factor_a[x] = latched_wfa; |
| 3361 | mcd212_regs.channel[1].weight_factor_b[x] = latched_wfb; |
| 3362 | mcd212_regs.region_flag_0[x] = latched_rf0; |
| 3363 | mcd212_regs.region_flag_1[x] = latched_rf1; |
| 3269 | 3364 | } |
| 3270 | 3365 | break; |
| 3271 | 3366 | } |
| 3272 | | if(x == (mcd212.channel[0].region_control[reg] & MCD212_RC_X)) |
| 3367 | if(x == (mcd212_regs.channel[0].region_control[reg] & MCD212_RC_X)) |
| 3273 | 3368 | { |
| 3274 | | switch((mcd212.channel[0].region_control[reg] & MCD212_RC_OP) >> MCD212_RC_OP_SHIFT) |
| 3369 | switch((mcd212_regs.channel[0].region_control[reg] & MCD212_RC_OP) >> MCD212_RC_OP_SHIFT) |
| 3275 | 3370 | { |
| 3276 | 3371 | case 0: // End of region control for line |
| 3277 | 3372 | break; |
| r6256 | r6257 | |
| 3280 | 3375 | case 3: // Not used |
| 3281 | 3376 | break; |
| 3282 | 3377 | case 4: // Change weight of plane A |
| 3283 | | latched_wfa = (mcd212.channel[0].region_control[reg] & MCD212_RC_WF) >> MCD212_RC_WF_SHIFT; |
| 3378 | latched_wfa = (mcd212_regs.channel[0].region_control[reg] & MCD212_RC_WF) >> MCD212_RC_WF_SHIFT; |
| 3284 | 3379 | break; |
| 3285 | 3380 | case 5: // Not used |
| 3286 | 3381 | break; |
| 3287 | 3382 | case 6: // Change weight of plane B |
| 3288 | | latched_wfb = (mcd212.channel[0].region_control[reg] & MCD212_RC_WF) >> MCD212_RC_WF_SHIFT; |
| 3383 | latched_wfb = (mcd212_regs.channel[0].region_control[reg] & MCD212_RC_WF) >> MCD212_RC_WF_SHIFT; |
| 3289 | 3384 | break; |
| 3290 | 3385 | case 7: // Not used |
| 3291 | 3386 | break; |
| r6256 | r6257 | |
| 3313 | 3408 | case 11: // Not used |
| 3314 | 3409 | break; |
| 3315 | 3410 | case 12: // Reset region flag and change weight of plane A |
| 3316 | | latched_wfa = (mcd212.channel[0].region_control[reg] & MCD212_RC_WF) >> MCD212_RC_WF_SHIFT; |
| 3411 | latched_wfa = (mcd212_regs.channel[0].region_control[reg] & MCD212_RC_WF) >> MCD212_RC_WF_SHIFT; |
| 3317 | 3412 | if(flag) |
| 3318 | 3413 | { |
| 3319 | 3414 | latched_rf1 = 0; |
| r6256 | r6257 | |
| 3324 | 3419 | } |
| 3325 | 3420 | break; |
| 3326 | 3421 | case 13: // Set region flag and change weight of plane A |
| 3327 | | latched_wfa = (mcd212.channel[0].region_control[reg] & MCD212_RC_WF) >> MCD212_RC_WF_SHIFT; |
| 3422 | latched_wfa = (mcd212_regs.channel[0].region_control[reg] & MCD212_RC_WF) >> MCD212_RC_WF_SHIFT; |
| 3328 | 3423 | if(flag) |
| 3329 | 3424 | { |
| 3330 | 3425 | latched_rf1 = 1; |
| r6256 | r6257 | |
| 3335 | 3430 | } |
| 3336 | 3431 | break; |
| 3337 | 3432 | case 14: // Reset region flag and change weight of plane B |
| 3338 | | latched_wfb = (mcd212.channel[0].region_control[reg] & MCD212_RC_WF) >> MCD212_RC_WF_SHIFT; |
| 3433 | latched_wfb = (mcd212_regs.channel[0].region_control[reg] & MCD212_RC_WF) >> MCD212_RC_WF_SHIFT; |
| 3339 | 3434 | if(flag) |
| 3340 | 3435 | { |
| 3341 | 3436 | latched_rf1 = 0; |
| r6256 | r6257 | |
| 3346 | 3441 | } |
| 3347 | 3442 | break; |
| 3348 | 3443 | case 15: // Set region flag and change weight of plane B |
| 3349 | | latched_wfb = (mcd212.channel[0].region_control[reg] & MCD212_RC_WF) >> MCD212_RC_WF_SHIFT; |
| 3444 | latched_wfb = (mcd212_regs.channel[0].region_control[reg] & MCD212_RC_WF) >> MCD212_RC_WF_SHIFT; |
| 3350 | 3445 | if(flag) |
| 3351 | 3446 | { |
| 3352 | 3447 | latched_rf1 = 1; |
| r6256 | r6257 | |
| 3361 | 3456 | } |
| 3362 | 3457 | } |
| 3363 | 3458 | } |
| 3364 | | mcd212.channel[0].weight_factor_a[x] = latched_wfa; |
| 3365 | | mcd212.channel[1].weight_factor_b[x] = latched_wfb; |
| 3366 | | mcd212.region_flag_0[x] = latched_rf0; |
| 3367 | | mcd212.region_flag_1[x] = latched_rf1; |
| 3459 | mcd212_regs.channel[0].weight_factor_a[x] = latched_wfa; |
| 3460 | mcd212_regs.channel[1].weight_factor_b[x] = latched_wfb; |
| 3461 | mcd212_regs.region_flag_0[x] = latched_rf0; |
| 3462 | mcd212_regs.region_flag_1[x] = latched_rf1; |
| 3368 | 3463 | } |
| 3369 | 3464 | } |
| 3370 | 3465 | |
| 3371 | 3466 | static int mcd212_get_screen_width(running_machine *machine) |
| 3372 | 3467 | { |
| 3373 | | if((mcd212.channel[0].dcr & (MCD212_DCR_CF | MCD212_DCR_FD)) && (mcd212.channel[0].csrw & MCD212_CSR1W_ST)) |
| 3468 | if((mcd212_regs.channel[0].dcr & (MCD212_DCR_CF | MCD212_DCR_FD)) && (mcd212_regs.channel[0].csrw & MCD212_CSR1W_ST)) |
| 3374 | 3469 | { |
| 3375 | 3470 | return 720; |
| 3376 | 3471 | } |
| r6256 | r6257 | |
| 3385 | 3480 | int x = 0; |
| 3386 | 3481 | UINT32 icm_mask = channel ? MCD212_ICM_MODE2 : MCD212_ICM_MODE1; |
| 3387 | 3482 | UINT32 icm_shift = channel ? MCD212_ICM_MODE2_SHIFT : MCD212_ICM_MODE1_SHIFT; |
| 3388 | | UINT8 icm = (mcd212.channel[0].image_coding_method & icm_mask) >> icm_shift; |
| 3389 | | UINT8 *clut_r = mcd212.channel[0].clut_r; |
| 3390 | | UINT8 *clut_g = mcd212.channel[0].clut_g; |
| 3391 | | UINT8 *clut_b = mcd212.channel[0].clut_b; |
| 3392 | | UINT8 mosaic_enable = ((mcd212.channel[channel].ddr & MCD212_DDR_FT) == MCD212_DDR_FT_MOSAIC); |
| 3393 | | UINT8 mosaic_factor = 1 << (((mcd212.channel[channel].ddr & MCD212_DDR_MT) >> MCD212_DDR_MT_SHIFT) + 1); |
| 3483 | UINT8 icm = (mcd212_regs.channel[0].image_coding_method & icm_mask) >> icm_shift; |
| 3484 | UINT8 *clut_r = mcd212_regs.channel[0].clut_r; |
| 3485 | UINT8 *clut_g = mcd212_regs.channel[0].clut_g; |
| 3486 | UINT8 *clut_b = mcd212_regs.channel[0].clut_b; |
| 3487 | UINT8 mosaic_enable = ((mcd212_regs.channel[channel].ddr & MCD212_DDR_FT) == MCD212_DDR_FT_MOSAIC); |
| 3488 | UINT8 mosaic_factor = 1 << (((mcd212_regs.channel[channel].ddr & MCD212_DDR_MT) >> MCD212_DDR_MT_SHIFT) + 1); |
| 3394 | 3489 | int mosaic_index = 0; |
| 3395 | 3490 | int width = mcd212_get_screen_width(machine); |
| 3396 | 3491 | |
| r6256 | r6257 | |
| 3409 | 3504 | { |
| 3410 | 3505 | UINT8 byte = data[(vsr & 0x0007ffff) ^ 1]; |
| 3411 | 3506 | vsr++; |
| 3412 | | switch(mcd212.channel[channel].ddr & MCD212_DDR_FT) |
| 3507 | switch(mcd212_regs.channel[channel].ddr & MCD212_DDR_FT) |
| 3413 | 3508 | { |
| 3414 | 3509 | case MCD212_DDR_FT_BMP: |
| 3415 | 3510 | case MCD212_DDR_FT_BMP2: |
| 3416 | 3511 | case MCD212_DDR_FT_MOSAIC: |
| 3417 | | if(mcd212.channel[channel].dcr & MCD212_DCR_CM) |
| 3512 | if(mcd212_regs.channel[channel].dcr & MCD212_DCR_CM) |
| 3418 | 3513 | { |
| 3419 | 3514 | // 4-bit Bitmap |
| 3420 | 3515 | verboselog(machine, 0, "Unsupported display mode: 4-bit Bitmap\n" ); |
| r6256 | r6257 | |
| 3430 | 3525 | switch(channel) |
| 3431 | 3526 | { |
| 3432 | 3527 | case 0: |
| 3433 | | bY = (mcd212.channel[0].dyuv_abs_start_a >> 16) & 0x000000ff; |
| 3434 | | bU = (mcd212.channel[0].dyuv_abs_start_a >> 8) & 0x000000ff; |
| 3435 | | bV = (mcd212.channel[0].dyuv_abs_start_a >> 0) & 0x000000ff; |
| 3528 | bY = (mcd212_regs.channel[0].dyuv_abs_start_a >> 16) & 0x000000ff; |
| 3529 | bU = (mcd212_regs.channel[0].dyuv_abs_start_a >> 8) & 0x000000ff; |
| 3530 | bV = (mcd212_regs.channel[0].dyuv_abs_start_a >> 0) & 0x000000ff; |
| 3436 | 3531 | break; |
| 3437 | 3532 | case 1: |
| 3438 | | bY = (mcd212.channel[1].dyuv_abs_start_b >> 16) & 0x000000ff; |
| 3439 | | bU = (mcd212.channel[1].dyuv_abs_start_b >> 8) & 0x000000ff; |
| 3440 | | bV = (mcd212.channel[1].dyuv_abs_start_b >> 0) & 0x000000ff; |
| 3533 | bY = (mcd212_regs.channel[1].dyuv_abs_start_b >> 16) & 0x000000ff; |
| 3534 | bU = (mcd212_regs.channel[1].dyuv_abs_start_b >> 8) & 0x000000ff; |
| 3535 | bV = (mcd212_regs.channel[1].dyuv_abs_start_b >> 0) & 0x000000ff; |
| 3441 | 3536 | break; |
| 3442 | 3537 | default: |
| 3443 | 3538 | bY = bU = bV = 0x80; |
| r6256 | r6257 | |
| 3596 | 3691 | done = 1; |
| 3597 | 3692 | break; |
| 3598 | 3693 | case MCD212_DDR_FT_RLE: |
| 3599 | | if(mcd212.channel[channel].dcr & MCD212_DCR_CM) |
| 3694 | if(mcd212_regs.channel[channel].dcr & MCD212_DCR_CM) |
| 3600 | 3695 | { |
| 3601 | 3696 | verboselog(machine, 0, "Unsupported display mode: 4-bit RLE\n" ); |
| 3602 | 3697 | done = 1; |
| r6256 | r6257 | |
| 3686 | 3781 | |
| 3687 | 3782 | static void mcd212_draw_cursor(running_machine *machine, UINT32 *scanline, int y) |
| 3688 | 3783 | { |
| 3689 | | if(mcd212.channel[0].cursor_control & MCD212_CURCNT_EN) |
| 3784 | if(mcd212_regs.channel[0].cursor_control & MCD212_CURCNT_EN) |
| 3690 | 3785 | { |
| 3691 | | UINT16 curx = mcd212.channel[0].cursor_position & 0x3ff; |
| 3692 | | UINT16 cury = ((mcd212.channel[0].cursor_position >> 12) & 0x3ff) + 22; |
| 3786 | UINT16 curx = mcd212_regs.channel[0].cursor_position & 0x3ff; |
| 3787 | UINT16 cury = ((mcd212_regs.channel[0].cursor_position >> 12) & 0x3ff) + 22; |
| 3693 | 3788 | UINT32 x = 0; |
| 3694 | 3789 | if(y >= cury && y < (cury + 16)) |
| 3695 | 3790 | { |
| 3696 | | UINT32 color = mcd212_4bpp_color[mcd212.channel[0].cursor_control & MCD212_CURCNT_COLOR]; |
| 3791 | UINT32 color = mcd212_4bpp_color[mcd212_regs.channel[0].cursor_control & MCD212_CURCNT_COLOR]; |
| 3697 | 3792 | y -= cury; |
| 3698 | | if(mcd212.channel[0].cursor_control & MCD212_CURCNT_CUW) |
| 3793 | if(mcd212_regs.channel[0].cursor_control & MCD212_CURCNT_CUW) |
| 3699 | 3794 | { |
| 3700 | 3795 | for(x = curx; x < curx + 64 && x < 768; x++) |
| 3701 | 3796 | { |
| 3702 | | if(mcd212.channel[0].cursor_pattern[y] & (1 << (15 - ((x - curx) >> 2)))) |
| 3797 | if(mcd212_regs.channel[0].cursor_pattern[y] & (1 << (15 - ((x - curx) >> 2)))) |
| 3703 | 3798 | { |
| 3704 | 3799 | scanline[(x++)/2] = color; |
| 3705 | 3800 | scanline[(x++)/2] = color; |
| r6256 | r6257 | |
| 3715 | 3810 | { |
| 3716 | 3811 | for(x = curx; x < curx + 32 && x < 768; x++) |
| 3717 | 3812 | { |
| 3718 | | if(mcd212.channel[0].cursor_pattern[y] & (1 << (15 - ((x - curx) >> 1)))) |
| 3813 | if(mcd212_regs.channel[0].cursor_pattern[y] & (1 << (15 - ((x - curx) >> 1)))) |
| 3719 | 3814 | { |
| 3720 | 3815 | scanline[(x++)/2] = color; |
| 3721 | 3816 | scanline[x/2] = color; |
| r6256 | r6257 | |
| 3732 | 3827 | static void mcd212_mix_lines(running_machine *machine, UINT8 *plane_a_r, UINT8 *plane_a_g, UINT8 *plane_a_b, UINT8 *plane_b_r, UINT8 *plane_b_g, UINT8 *plane_b_b, UINT32 *out) |
| 3733 | 3828 | { |
| 3734 | 3829 | int x = 0; |
| 3735 | | UINT32 backdrop = mcd212_4bpp_color[mcd212.channel[0].backdrop_color]; |
| 3736 | | UINT8 transparency_mode_a = (mcd212.channel[0].transparency_control >> 0) & 0x0f; |
| 3737 | | UINT8 transparency_mode_b = (mcd212.channel[0].transparency_control >> 8) & 0x0f; |
| 3738 | | UINT8 transparent_color_a_r = (UINT8)(mcd212.channel[0].transparent_color_a >> 16); |
| 3739 | | UINT8 transparent_color_a_g = (UINT8)(mcd212.channel[0].transparent_color_a >> 8); |
| 3740 | | UINT8 transparent_color_a_b = (UINT8)(mcd212.channel[0].transparent_color_a >> 0); |
| 3741 | | UINT8 transparent_color_b_r = (UINT8)(mcd212.channel[1].transparent_color_b >> 16); |
| 3742 | | UINT8 transparent_color_b_g = (UINT8)(mcd212.channel[1].transparent_color_b >> 8); |
| 3743 | | UINT8 transparent_color_b_b = (UINT8)(mcd212.channel[1].transparent_color_b >> 0); |
| 3744 | | UINT8 image_coding_method_a = mcd212.channel[0].image_coding_method & 0x0000000f; |
| 3745 | | UINT8 image_coding_method_b = (mcd212.channel[0].image_coding_method >> 8) & 0x0000000f; |
| 3830 | UINT32 backdrop = mcd212_4bpp_color[mcd212_regs.channel[0].backdrop_color]; |
| 3831 | UINT8 transparency_mode_a = (mcd212_regs.channel[0].transparency_control >> 0) & 0x0f; |
| 3832 | UINT8 transparency_mode_b = (mcd212_regs.channel[0].transparency_control >> 8) & 0x0f; |
| 3833 | UINT8 transparent_color_a_r = (UINT8)(mcd212_regs.channel[0].transparent_color_a >> 16); |
| 3834 | UINT8 transparent_color_a_g = (UINT8)(mcd212_regs.channel[0].transparent_color_a >> 8); |
| 3835 | UINT8 transparent_color_a_b = (UINT8)(mcd212_regs.channel[0].transparent_color_a >> 0); |
| 3836 | UINT8 transparent_color_b_r = (UINT8)(mcd212_regs.channel[1].transparent_color_b >> 16); |
| 3837 | UINT8 transparent_color_b_g = (UINT8)(mcd212_regs.channel[1].transparent_color_b >> 8); |
| 3838 | UINT8 transparent_color_b_b = (UINT8)(mcd212_regs.channel[1].transparent_color_b >> 0); |
| 3839 | UINT8 image_coding_method_a = mcd212_regs.channel[0].image_coding_method & 0x0000000f; |
| 3840 | UINT8 image_coding_method_b = (mcd212_regs.channel[0].image_coding_method >> 8) & 0x0000000f; |
| 3746 | 3841 | UINT8 dyuv_enable_a = (image_coding_method_a == 5); |
| 3747 | 3842 | UINT8 dyuv_enable_b = (image_coding_method_b == 5); |
| 3748 | | UINT8 mosaic_enable_a = (mcd212.channel[0].mosaic_hold_a & 0x800000) >> 23; |
| 3749 | | UINT8 mosaic_enable_b = (mcd212.channel[1].mosaic_hold_b & 0x800000) >> 23; |
| 3750 | | UINT8 mosaic_count_a = (mcd212.channel[0].mosaic_hold_a & 0x0000ff) << 1; |
| 3751 | | UINT8 mosaic_count_b = (mcd212.channel[1].mosaic_hold_b & 0x0000ff) << 1; |
| 3843 | UINT8 mosaic_enable_a = (mcd212_regs.channel[0].mosaic_hold_a & 0x800000) >> 23; |
| 3844 | UINT8 mosaic_enable_b = (mcd212_regs.channel[1].mosaic_hold_b & 0x800000) >> 23; |
| 3845 | UINT8 mosaic_count_a = (mcd212_regs.channel[0].mosaic_hold_a & 0x0000ff) << 1; |
| 3846 | UINT8 mosaic_count_b = (mcd212_regs.channel[1].mosaic_hold_b & 0x0000ff) << 1; |
| 3752 | 3847 | for(x = 0; x < 768; x++) |
| 3753 | 3848 | { |
| 3754 | 3849 | out[x] = backdrop; |
| 3755 | | if(!(mcd212.channel[0].transparency_control & MCD212_TCR_DISABLE_MX)) |
| 3850 | if(!(mcd212_regs.channel[0].transparency_control & MCD212_TCR_DISABLE_MX)) |
| 3756 | 3851 | { |
| 3757 | | UINT8 abr = MCD212_LIM(((MCD212_LIM((INT32)plane_a_r[x] - 16) * mcd212.channel[0].weight_factor_a[x]) >> 6) + ((MCD212_LIM((INT32)plane_b_r[x] - 16) * mcd212.channel[1].weight_factor_b[x]) >> 6) + 16); |
| 3758 | | UINT8 abg = MCD212_LIM(((MCD212_LIM((INT32)plane_a_g[x] - 16) * mcd212.channel[0].weight_factor_a[x]) >> 6) + ((MCD212_LIM((INT32)plane_b_g[x] - 16) * mcd212.channel[1].weight_factor_b[x]) >> 6) + 16); |
| 3759 | | UINT8 abb = MCD212_LIM(((MCD212_LIM((INT32)plane_a_b[x] - 16) * mcd212.channel[0].weight_factor_a[x]) >> 6) + ((MCD212_LIM((INT32)plane_b_b[x] - 16) * mcd212.channel[1].weight_factor_b[x]) >> 6) + 16); |
| 3852 | UINT8 abr = MCD212_LIM(((MCD212_LIM((INT32)plane_a_r[x] - 16) * mcd212_regs.channel[0].weight_factor_a[x]) >> 6) + ((MCD212_LIM((INT32)plane_b_r[x] - 16) * mcd212_regs.channel[1].weight_factor_b[x]) >> 6) + 16); |
| 3853 | UINT8 abg = MCD212_LIM(((MCD212_LIM((INT32)plane_a_g[x] - 16) * mcd212_regs.channel[0].weight_factor_a[x]) >> 6) + ((MCD212_LIM((INT32)plane_b_g[x] - 16) * mcd212_regs.channel[1].weight_factor_b[x]) >> 6) + 16); |
| 3854 | UINT8 abb = MCD212_LIM(((MCD212_LIM((INT32)plane_a_b[x] - 16) * mcd212_regs.channel[0].weight_factor_a[x]) >> 6) + ((MCD212_LIM((INT32)plane_b_b[x] - 16) * mcd212_regs.channel[1].weight_factor_b[x]) >> 6) + 16); |
| 3760 | 3855 | out[x] = (abr << 16) | (abg << 8) | abb; |
| 3761 | 3856 | } |
| 3762 | 3857 | else |
| r6256 | r6257 | |
| 3778 | 3873 | plane_enable_a = (plane_a_r_cur != transparent_color_a_r || plane_a_g_cur != transparent_color_a_g || plane_a_b_cur != transparent_color_a_b); |
| 3779 | 3874 | break; |
| 3780 | 3875 | case 3: |
| 3781 | | plane_enable_a = !mcd212.region_flag_0[x]; |
| 3876 | plane_enable_a = !mcd212_regs.region_flag_0[x]; |
| 3782 | 3877 | break; |
| 3783 | 3878 | case 4: |
| 3784 | | plane_enable_a = !mcd212.region_flag_1[x]; |
| 3879 | plane_enable_a = !mcd212_regs.region_flag_1[x]; |
| 3785 | 3880 | break; |
| 3786 | 3881 | case 5: |
| 3787 | | plane_enable_a = (plane_a_r_cur != transparent_color_a_r || plane_a_g_cur != transparent_color_a_g || plane_a_b_cur != transparent_color_a_b) && (dyuv_enable_a || mcd212.region_flag_0[x] == 0); |
| 3882 | plane_enable_a = (plane_a_r_cur != transparent_color_a_r || plane_a_g_cur != transparent_color_a_g || plane_a_b_cur != transparent_color_a_b) && (dyuv_enable_a || mcd212_regs.region_flag_0[x] == 0); |
| 3788 | 3883 | break; |
| 3789 | 3884 | case 6: |
| 3790 | | plane_enable_a = (plane_a_r_cur != transparent_color_a_r || plane_a_g_cur != transparent_color_a_g || plane_a_b_cur != transparent_color_a_b) && (dyuv_enable_a || mcd212.region_flag_1[x] == 0); |
| 3885 | plane_enable_a = (plane_a_r_cur != transparent_color_a_r || plane_a_g_cur != transparent_color_a_g || plane_a_b_cur != transparent_color_a_b) && (dyuv_enable_a || mcd212_regs.region_flag_1[x] == 0); |
| 3791 | 3886 | break; |
| 3792 | 3887 | case 8: |
| 3793 | 3888 | plane_enable_a = 1; |
| r6256 | r6257 | |
| 3796 | 3891 | plane_enable_a = (plane_a_r_cur == transparent_color_a_r && plane_a_g_cur == transparent_color_a_g && plane_a_b_cur == transparent_color_a_b); |
| 3797 | 3892 | break; |
| 3798 | 3893 | case 11: |
| 3799 | | plane_enable_a = mcd212.region_flag_0[x]; |
| 3894 | plane_enable_a = mcd212_regs.region_flag_0[x]; |
| 3800 | 3895 | break; |
| 3801 | 3896 | case 12: |
| 3802 | | plane_enable_a = mcd212.region_flag_1[x]; |
| 3897 | plane_enable_a = mcd212_regs.region_flag_1[x]; |
| 3803 | 3898 | break; |
| 3804 | 3899 | case 13: |
| 3805 | | plane_enable_a = (plane_a_r_cur == transparent_color_a_r && plane_a_g_cur == transparent_color_a_g && plane_a_b_cur == transparent_color_a_b) || dyuv_enable_a || mcd212.region_flag_0[x] == 1; |
| 3900 | plane_enable_a = (plane_a_r_cur == transparent_color_a_r && plane_a_g_cur == transparent_color_a_g && plane_a_b_cur == transparent_color_a_b) || dyuv_enable_a || mcd212_regs.region_flag_0[x] == 1; |
| 3806 | 3901 | break; |
| 3807 | 3902 | case 14: |
| 3808 | | plane_enable_a = (plane_a_r_cur == transparent_color_a_r && plane_a_g_cur == transparent_color_a_g && plane_a_b_cur == transparent_color_a_b) || dyuv_enable_a || mcd212.region_flag_1[x] == 1; |
| 3903 | plane_enable_a = (plane_a_r_cur == transparent_color_a_r && plane_a_g_cur == transparent_color_a_g && plane_a_b_cur == transparent_color_a_b) || dyuv_enable_a || mcd212_regs.region_flag_1[x] == 1; |
| 3809 | 3904 | break; |
| 3810 | 3905 | default: |
| 3811 | 3906 | verboselog(machine, 0, "Unhandled transparency mode for plane A: %d\n", transparency_mode_a); |
| r6256 | r6257 | |
| 3821 | 3916 | plane_enable_b = (plane_b_r_cur != transparent_color_b_r || plane_b_g_cur != transparent_color_b_g || plane_b_b_cur != transparent_color_b_b); |
| 3822 | 3917 | break; |
| 3823 | 3918 | case 3: |
| 3824 | | plane_enable_b = !mcd212.region_flag_0[x]; |
| 3919 | plane_enable_b = !mcd212_regs.region_flag_0[x]; |
| 3825 | 3920 | break; |
| 3826 | 3921 | case 4: |
| 3827 | | plane_enable_b = !mcd212.region_flag_1[x]; |
| 3922 | plane_enable_b = !mcd212_regs.region_flag_1[x]; |
| 3828 | 3923 | break; |
| 3829 | 3924 | case 5: |
| 3830 | | plane_enable_b = (plane_b_r_cur != transparent_color_b_r || plane_b_g_cur != transparent_color_b_g || plane_b_b_cur != transparent_color_b_b) && (dyuv_enable_b || mcd212.region_flag_0[x] == 0); |
| 3925 | plane_enable_b = (plane_b_r_cur != transparent_color_b_r || plane_b_g_cur != transparent_color_b_g || plane_b_b_cur != transparent_color_b_b) && (dyuv_enable_b || mcd212_regs.region_flag_0[x] == 0); |
| 3831 | 3926 | break; |
| 3832 | 3927 | case 6: |
| 3833 | | plane_enable_b = (plane_b_r_cur != transparent_color_b_r || plane_b_g_cur != transparent_color_b_g || plane_b_b_cur != transparent_color_b_b) && (dyuv_enable_b || mcd212.region_flag_1[x] == 0); |
| 3928 | plane_enable_b = (plane_b_r_cur != transparent_color_b_r || plane_b_g_cur != transparent_color_b_g || plane_b_b_cur != transparent_color_b_b) && (dyuv_enable_b || mcd212_regs.region_flag_1[x] == 0); |
| 3834 | 3929 | break; |
| 3835 | 3930 | case 8: |
| 3836 | 3931 | plane_enable_b = 1; |
| r6256 | r6257 | |
| 3839 | 3934 | plane_enable_b = (plane_b_r_cur == transparent_color_b_r && plane_b_g_cur == transparent_color_b_g && plane_b_b_cur == transparent_color_b_b); |
| 3840 | 3935 | break; |
| 3841 | 3936 | case 11: |
| 3842 | | plane_enable_b = mcd212.region_flag_0[x]; |
| 3937 | plane_enable_b = mcd212_regs.region_flag_0[x]; |
| 3843 | 3938 | break; |
| 3844 | 3939 | case 12: |
| 3845 | | plane_enable_b = mcd212.region_flag_1[x]; |
| 3940 | plane_enable_b = mcd212_regs.region_flag_1[x]; |
| 3846 | 3941 | break; |
| 3847 | 3942 | case 13: |
| 3848 | | plane_enable_b = (plane_b_r_cur == transparent_color_b_r && plane_b_g_cur == transparent_color_b_g && plane_b_b_cur == transparent_color_b_b) || dyuv_enable_b || mcd212.region_flag_0[x] == 1; |
| 3943 | plane_enable_b = (plane_b_r_cur == transparent_color_b_r && plane_b_g_cur == transparent_color_b_g && plane_b_b_cur == transparent_color_b_b) || dyuv_enable_b || mcd212_regs.region_flag_0[x] == 1; |
| 3849 | 3944 | break; |
| 3850 | 3945 | case 14: |
| 3851 | | plane_enable_b = (plane_b_r_cur == transparent_color_b_r && plane_b_g_cur == transparent_color_b_g && plane_b_b_cur == transparent_color_b_b) || dyuv_enable_b || mcd212.region_flag_1[x] == 1; |
| 3946 | plane_enable_b = (plane_b_r_cur == transparent_color_b_r && plane_b_g_cur == transparent_color_b_g && plane_b_b_cur == transparent_color_b_b) || dyuv_enable_b || mcd212_regs.region_flag_1[x] == 1; |
| 3852 | 3947 | break; |
| 3853 | 3948 | default: |
| 3854 | 3949 | verboselog(machine, 0, "Unhandled transparency mode for plane B: %d\n", transparency_mode_b); |
| 3855 | 3950 | plane_enable_b = 1; |
| 3856 | 3951 | break; |
| 3857 | 3952 | } |
| 3858 | | plane_a_r_cur = MCD212_LIM(((MCD212_LIM((INT32)plane_a_r_cur - 16) * mcd212.channel[0].weight_factor_a[x]) >> 6) + 16); |
| 3859 | | plane_a_g_cur = MCD212_LIM(((MCD212_LIM((INT32)plane_a_g_cur - 16) * mcd212.channel[0].weight_factor_a[x]) >> 6) + 16); |
| 3860 | | plane_a_b_cur = MCD212_LIM(((MCD212_LIM((INT32)plane_a_b_cur - 16) * mcd212.channel[0].weight_factor_a[x]) >> 6) + 16); |
| 3861 | | plane_b_r_cur = MCD212_LIM(((MCD212_LIM((INT32)plane_b_r_cur - 16) * mcd212.channel[1].weight_factor_b[x]) >> 6) + 16); |
| 3862 | | plane_b_g_cur = MCD212_LIM(((MCD212_LIM((INT32)plane_b_g_cur - 16) * mcd212.channel[1].weight_factor_b[x]) >> 6) + 16); |
| 3863 | | plane_b_b_cur = MCD212_LIM(((MCD212_LIM((INT32)plane_b_b_cur - 16) * mcd212.channel[1].weight_factor_b[x]) >> 6) + 16); |
| 3864 | | switch(mcd212.channel[0].plane_order) |
| 3953 | plane_a_r_cur = MCD212_LIM(((MCD212_LIM((INT32)plane_a_r_cur - 16) * mcd212_regs.channel[0].weight_factor_a[x]) >> 6) + 16); |
| 3954 | plane_a_g_cur = MCD212_LIM(((MCD212_LIM((INT32)plane_a_g_cur - 16) * mcd212_regs.channel[0].weight_factor_a[x]) >> 6) + 16); |
| 3955 | plane_a_b_cur = MCD212_LIM(((MCD212_LIM((INT32)plane_a_b_cur - 16) * mcd212_regs.channel[0].weight_factor_a[x]) >> 6) + 16); |
| 3956 | plane_b_r_cur = MCD212_LIM(((MCD212_LIM((INT32)plane_b_r_cur - 16) * mcd212_regs.channel[1].weight_factor_b[x]) >> 6) + 16); |
| 3957 | plane_b_g_cur = MCD212_LIM(((MCD212_LIM((INT32)plane_b_g_cur - 16) * mcd212_regs.channel[1].weight_factor_b[x]) >> 6) + 16); |
| 3958 | plane_b_b_cur = MCD212_LIM(((MCD212_LIM((INT32)plane_b_b_cur - 16) * mcd212_regs.channel[1].weight_factor_b[x]) >> 6) + 16); |
| 3959 | switch(mcd212_regs.channel[0].plane_order) |
| 3865 | 3960 | { |
| 3866 | 3961 | case MCD212_POR_AB: |
| 3867 | 3962 | if(plane_enable_a) |
| r6256 | r6257 | |
| 3911 | 4006 | static TIMER_CALLBACK( mcd212_perform_scan ) |
| 3912 | 4007 | { |
| 3913 | 4008 | int scanline = video_screen_get_vpos(machine->primary_screen); |
| 3914 | | if(/*mcd212.channel[0].dcr & MCD212_DCR_DE*/1) |
| 4009 | if(/*mcd212_regs.channel[0].dcr & MCD212_DCR_DE*/1) |
| 3915 | 4010 | { |
| 3916 | 4011 | if(scanline == 0) |
| 3917 | 4012 | { |
| 3918 | 4013 | // Process ICA |
| 3919 | 4014 | int index = 0; |
| 3920 | 4015 | verboselog(machine, 6, "Frame Start\n" ); |
| 3921 | | mcd212.channel[0].csrr &= 0x7f; |
| 4016 | mcd212_regs.channel[0].csrr &= 0x7f; |
| 3922 | 4017 | for(index = 0; index < 2; index++) |
| 3923 | 4018 | { |
| 3924 | | if(mcd212.channel[index].dcr & MCD212_DCR_ICA) |
| 4019 | if(mcd212_regs.channel[index].dcr & MCD212_DCR_ICA) |
| 3925 | 4020 | { |
| 3926 | 4021 | mcd212_process_ica(machine, index); |
| 3927 | 4022 | } |
| r6256 | r6257 | |
| 3935 | 4030 | else if(scanline >= 22) |
| 3936 | 4031 | { |
| 3937 | 4032 | int index = 0; |
| 3938 | | mcd212.channel[0].csrr |= 0x80; |
| 4033 | mcd212_regs.channel[0].csrr |= 0x80; |
| 3939 | 4034 | // Process VSR |
| 3940 | 4035 | mcd212_draw_scanline(machine, scanline); |
| 3941 | 4036 | // Process DCA |
| 3942 | 4037 | for(index = 0; index < 2; index++) |
| 3943 | 4038 | { |
| 3944 | | if(mcd212.channel[index].dcr & MCD212_DCR_DCA) |
| 4039 | if(mcd212_regs.channel[index].dcr & MCD212_DCR_DCA) |
| 3945 | 4040 | { |
| 3946 | 4041 | if(scanline == 22) |
| 3947 | 4042 | { |
| 3948 | | mcd212.channel[index].dca = mcd212_get_dcp(index); |
| 4043 | mcd212_regs.channel[index].dca = mcd212_get_dcp(index); |
| 3949 | 4044 | } |
| 3950 | 4045 | mcd212_process_dca(machine, index); |
| 3951 | 4046 | } |
| 3952 | 4047 | } |
| 3953 | 4048 | if(scanline == 261) |
| 3954 | 4049 | { |
| 3955 | | mcd212.channel[0].csrr ^= 0x20; |
| 4050 | mcd212_regs.channel[0].csrr ^= 0x20; |
| 3956 | 4051 | } |
| 3957 | 4052 | } |
| 3958 | 4053 | } |
| 3959 | | timer_adjust_oneshot(mcd212.scan_timer, video_screen_get_time_until_pos(machine->primary_screen, ( scanline + 1 ) % 262, 0), 0); |
| 4054 | timer_adjust_oneshot(mcd212_regs.scan_timer, video_screen_get_time_until_pos(machine->primary_screen, ( scanline + 1 ) % 262, 0), 0); |
| 3960 | 4055 | } |
| 3961 | 4056 | |
| 4057 | static void mcd212_init(running_machine *machine, mcd212_regs_t *mcd212) |
| 4058 | { |
| 4059 | int index = 0; |
| 4060 | for(index = 0; index < 2; index++) |
| 4061 | { |
| 4062 | mcd212->channel[index].csrr = 0; |
| 4063 | mcd212->channel[index].csrw = 0; |
| 4064 | mcd212->channel[index].dcr = 0; |
| 4065 | mcd212->channel[index].vsr = 0; |
| 4066 | mcd212->channel[index].ddr = 0; |
| 4067 | mcd212->channel[index].dcp = 0; |
| 4068 | mcd212->channel[index].dca = 0; |
| 4069 | memset(mcd212->channel[index].clut_r, 0, 768); |
| 4070 | memset(mcd212->channel[index].clut_g, 0, 768); |
| 4071 | memset(mcd212->channel[index].clut_b, 0, 768); |
| 4072 | mcd212->channel[index].image_coding_method = 0; |
| 4073 | mcd212->channel[index].transparency_control = 0; |
| 4074 | mcd212->channel[index].plane_order = 0; |
| 4075 | mcd212->channel[index].clut_bank = 0; |
| 4076 | mcd212->channel[index].transparent_color_a = 0; |
| 4077 | mcd212->channel[index].transparent_color_b = 0; |
| 4078 | mcd212->channel[index].mask_color_a = 0; |
| 4079 | mcd212->channel[index].mask_color_b = 0; |
| 4080 | mcd212->channel[index].dyuv_abs_start_a = 0; |
| 4081 | mcd212->channel[index].dyuv_abs_start_b = 0; |
| 4082 | mcd212->channel[index].cursor_position = 0; |
| 4083 | mcd212->channel[index].cursor_control = 0; |
| 4084 | memset((UINT8*)&mcd212->channel[index].cursor_pattern, 0, 16 * sizeof(UINT32)); |
| 4085 | memset((UINT8*)&mcd212->channel[index].region_control, 0, 8 * sizeof(UINT32)); |
| 4086 | mcd212->channel[index].backdrop_color = 0; |
| 4087 | mcd212->channel[index].mosaic_hold_a = 0; |
| 4088 | mcd212->channel[index].mosaic_hold_b = 0; |
| 4089 | memset(mcd212->channel[index].weight_factor_a, 0, 768); |
| 4090 | memset(mcd212->channel[index].weight_factor_b, 0, 768); |
| 4091 | } |
| 4092 | memset(mcd212->region_flag_0, 0, 768); |
| 4093 | memset(mcd212->region_flag_1, 0, 768); |
| 4094 | } |
| 4095 | |
| 3962 | 4096 | static VIDEO_START(cdi) |
| 3963 | 4097 | { |
| 3964 | 4098 | WORD68K w = 0; |
| r6256 | r6257 | |
| 3993 | 4127 | } |
| 3994 | 4128 | |
| 3995 | 4129 | VIDEO_START_CALL(generic_bitmapped); |
| 3996 | | mcd212.channel[0].csrr = 0x00; |
| 3997 | | mcd212.channel[1].csrr = 0x00; |
| 3998 | | mcd212.channel[0].clut_bank = 0; |
| 3999 | | mcd212.channel[1].clut_bank = 0; |
| 4000 | | mcd212.scan_timer = timer_alloc(machine, mcd212_perform_scan, 0); |
| 4001 | | timer_adjust_oneshot(mcd212.scan_timer, video_screen_get_time_until_pos(machine->primary_screen, 0, 0), 0); |
| 4130 | mcd212_init(machine, &mcd212_regs); |
| 4131 | mcd212_regs.scan_timer = timer_alloc(machine, mcd212_perform_scan, 0); |
| 4132 | timer_adjust_oneshot(mcd212_regs.scan_timer, video_screen_get_time_until_pos(machine->primary_screen, 0, 0), 0); |
| 4002 | 4133 | |
| 4003 | 4134 | lcdbitmap = video_screen_auto_bitmap_alloc(devtag_get_device(machine, "lcd")); |
| 4004 | 4135 | } |
| r6256 | r6257 | |
| 4094 | 4225 | |
| 4095 | 4226 | static MACHINE_RESET( cdi ) |
| 4096 | 4227 | { |
| 4097 | | UINT16 *src = (UINT16*)memory_region( machine, "maincpu" ); |
| 4228 | UINT16 *src = (UINT16*)memory_region(machine, "maincpu"); |
| 4098 | 4229 | UINT16 *dst = planea; |
| 4099 | 4230 | const device_config *cdrom_dev = devtag_get_device(machine, "cdrom"); |
| 4100 | 4231 | memcpy(dst, src, 0x8); |
| 4101 | 4232 | |
| 4233 | scc68070_init(machine, &scc68070_regs); |
| 4234 | cdic_init(machine, &cdic_regs); |
| 4235 | slave_init(machine, &slave_regs); |
| 4236 | |
| 4102 | 4237 | scc68070_regs.timers.timer0_timer = timer_alloc(machine, scc68070_timer0_callback, 0); |
| 4103 | 4238 | timer_adjust_oneshot(scc68070_regs.timers.timer0_timer, attotime_never, 0); |
| 4104 | 4239 | |
| r6256 | r6257 | |
| 4114 | 4249 | cdic_regs.audio_sample_timer = timer_alloc(machine, audio_sample_trigger, 0); |
| 4115 | 4250 | timer_adjust_oneshot(cdic_regs.audio_sample_timer, attotime_never, 0); |
| 4116 | 4251 | |
| 4117 | | /* |
| 4118 | | memset(cdic_regs.audio_stream_samples, 0, 18*28*16*CDIC_BUFFERED_SECTORS * sizeof(INT16)); |
| 4119 | | cdic_regs.audio_stream_queued = 0; |
| 4120 | | cdic_regs.audio_stream_index = 0; |
| 4121 | | cdic_regs.audio_stream_end = 0; |
| 4122 | | cdic_regs.audio_stream_playing = 0; |
| 4123 | | */ |
| 4124 | | |
| 4125 | 4252 | if( cdrom_dev ) |
| 4126 | 4253 | { |
| 4127 | 4254 | cdic_regs.cd = mess_cd_get_cdrom_file(cdrom_dev); |
| r6256 | r6257 | |
| 4130 | 4257 | |
| 4131 | 4258 | device_reset(cputag_get_cpu(machine, "maincpu")); |
| 4132 | 4259 | |
| 4133 | | cdic_regs.z_buffer = 0; |
| 4134 | | cdic_regs.channel = 0xffffffff; |
| 4135 | | cdic_regs.audio_channel = 0xffff; |
| 4136 | | |
| 4137 | 4260 | dmadac[0] = devtag_get_device(machine, "dac1"); |
| 4138 | 4261 | dmadac[1] = devtag_get_device(machine, "dac2"); |
| 4139 | 4262 | |