src/mame/machine/dc.c
| r7924 | r7925 | |
| 20 | 20 | #define DEBUG_MAPLE (0) |
| 21 | 21 | #define DEBUG_MAPLE_REGS (0) |
| 22 | 22 | #define DEBUG_AICA_DMA (0) |
| 23 | #define DEBUG_PVRCTRL (0) |
| 23 | 24 | |
| 24 | | #define ENABLE_MAPLE_IRQ (0) |
| 25 | static UINT8 mp_mux_data; |
| 25 | 26 | |
| 26 | 27 | #if DEBUG_SYSCTRL |
| 27 | 28 | static const char *const sysctrl_names[] = |
| r7924 | r7925 | |
| 165 | 166 | 0x05200083,0x5245544e,0x53495250,0x43205345,0x544c2c4f,0x20202e44,0x38393931,0x5c525043 |
| 166 | 167 | }; |
| 167 | 168 | |
| 169 | static struct { |
| 170 | UINT32 aica_addr; |
| 171 | UINT32 root_addr; |
| 172 | UINT32 size; |
| 173 | UINT8 dir; |
| 174 | UINT8 flag; |
| 175 | UINT8 indirect; |
| 176 | UINT8 start; |
| 177 | UINT8 sel; |
| 178 | }wave_dma; |
| 179 | |
| 180 | static struct { |
| 181 | UINT32 pvr_addr; |
| 182 | UINT32 sys_addr; |
| 183 | UINT32 size; |
| 184 | UINT8 sel; |
| 185 | UINT8 dir; |
| 186 | UINT8 flag; |
| 187 | UINT8 start; |
| 188 | }pvr_dma; |
| 189 | |
| 190 | static TIMER_CALLBACK( aica_dma_irq ) |
| 191 | { |
| 192 | wave_dma.start = g2bus_regs[SB_ADST] = 0; |
| 193 | dc_sysctrl_regs[SB_ISTNRM] |= IST_DMA_AICA; |
| 194 | dc_update_interrupt_status(machine); |
| 195 | } |
| 196 | |
| 197 | static TIMER_CALLBACK( pvr_dma_irq ) |
| 198 | { |
| 199 | pvr_dma.start = pvrctrl_regs[SB_PDST] = 0; |
| 200 | dc_sysctrl_regs[SB_ISTNRM] |= IST_DMA_PVR; |
| 201 | dc_update_interrupt_status(machine); |
| 202 | } |
| 203 | |
| 204 | static TIMER_CALLBACK( gdrom_dma_irq ) |
| 205 | { |
| 206 | g1bus_regs[SB_GDST] = 0; |
| 207 | dc_sysctrl_regs[SB_ISTNRM] |= IST_DMA_GDROM; |
| 208 | dc_update_interrupt_status(machine); |
| 209 | } |
| 210 | |
| 211 | static TIMER_CALLBACK( maple_dma_irq ) |
| 212 | { |
| 213 | maple_regs[SB_MDST] = 0; |
| 214 | dc_sysctrl_regs[SB_ISTNRM] |= IST_DMA_MAPLE; |
| 215 | dc_update_interrupt_status(machine); |
| 216 | } |
| 217 | |
| 218 | static void wave_dma_execute(const address_space *space) |
| 219 | { |
| 220 | UINT32 src,dst,size; |
| 221 | dst = wave_dma.aica_addr; |
| 222 | src = wave_dma.root_addr; |
| 223 | size = 0; |
| 224 | |
| 225 | /* 0 rounding size = 32 Mbytes */ |
| 226 | if(wave_dma.size == 0) { wave_dma.size = 0x200000; } |
| 227 | |
| 228 | if(wave_dma.dir == 0) |
| 229 | { |
| 230 | for(;size<wave_dma.size;size+=4) |
| 231 | { |
| 232 | memory_write_dword_64le(space,dst,memory_read_dword(space,src)); |
| 233 | src+=4; |
| 234 | dst+=4; |
| 235 | } |
| 236 | } |
| 237 | else |
| 238 | { |
| 239 | for(;size<wave_dma.size;size+=4) |
| 240 | { |
| 241 | memory_write_dword_64le(space,src,memory_read_dword(space,dst)); |
| 242 | src+=4; |
| 243 | dst+=4; |
| 244 | } |
| 245 | } |
| 246 | |
| 247 | /* update the params*/ |
| 248 | wave_dma.aica_addr = g2bus_regs[SB_ADSTAG] = dst; |
| 249 | wave_dma.root_addr = g2bus_regs[SB_ADSTAR] = src; |
| 250 | wave_dma.size = g2bus_regs[SB_ADLEN] = 0; |
| 251 | wave_dma.flag = (wave_dma.indirect & 1) ? 1 : 0; |
| 252 | /* Note: if you trigger an instant DMA IRQ trigger, sfz3upper doesn't play any bgm. */ |
| 253 | /* TODO: timing of this */ |
| 254 | timer_set(space->machine, ATTOTIME_IN_USEC(300), NULL, 0, aica_dma_irq); |
| 255 | } |
| 256 | |
| 257 | static void pvr_dma_execute(const address_space *space) |
| 258 | { |
| 259 | UINT32 src,dst,size; |
| 260 | dst = pvr_dma.pvr_addr; |
| 261 | src = pvr_dma.sys_addr; |
| 262 | size = 0; |
| 263 | |
| 264 | /* used so far by usagui and sprtjam*/ |
| 265 | //printf("PVR-DMA start\n"); |
| 266 | //printf("%08x %08x %08x\n",pvr_dma.pvr_addr,pvr_dma.sys_addr,pvr_dma.size); |
| 267 | //printf("src %s dst %08x\n",pvr_dma.dir ? "->" : "<-",pvr_dma.sel); |
| 268 | |
| 269 | /* 0 rounding size = 16 Mbytes */ |
| 270 | if(pvr_dma.size == 0) { pvr_dma.size = 0x100000; } |
| 271 | |
| 272 | if(pvr_dma.dir == 0) |
| 273 | { |
| 274 | for(;size<pvr_dma.size;size+=4) |
| 275 | { |
| 276 | memory_write_dword_64le(space,dst,memory_read_dword(space,src)); |
| 277 | src+=4; |
| 278 | dst+=4; |
| 279 | } |
| 280 | } |
| 281 | else |
| 282 | { |
| 283 | for(;size<pvr_dma.size;size+=4) |
| 284 | { |
| 285 | memory_write_dword_64le(space,src,memory_read_dword(space,dst)); |
| 286 | src+=4; |
| 287 | dst+=4; |
| 288 | } |
| 289 | } |
| 290 | /* Note: do not update the params, since this DMA type doesn't support it. */ |
| 291 | /* TODO: timing of this */ |
| 292 | timer_set(space->machine, ATTOTIME_IN_USEC(250), NULL, 0, pvr_dma_irq); |
| 293 | } |
| 294 | |
| 168 | 295 | // register decode helpers |
| 169 | 296 | |
| 170 | 297 | // this accepts only 32-bit accesses |
| r7924 | r7925 | |
| 247 | 374 | |
| 248 | 375 | void dc_update_interrupt_status(running_machine *machine) |
| 249 | 376 | { |
| 250 | | int level; |
| 377 | int level; |
| 251 | 378 | |
| 252 | 379 | if (dc_sysctrl_regs[SB_ISTERR]) |
| 253 | 380 | { |
| r7924 | r7925 | |
| 269 | 396 | |
| 270 | 397 | level=dc_compute_interrupt_level(machine); |
| 271 | 398 | sh4_set_irln_input(devtag_get_device(machine, "maincpu"), 15-level); |
| 399 | |
| 400 | /* Wave DMA HW trigger */ |
| 401 | if(wave_dma.flag && ((wave_dma.sel & 2) == 2)) |
| 402 | { |
| 403 | if((dc_sysctrl_regs[SB_G2DTNRM] & dc_sysctrl_regs[SB_ISTNRM]) || (dc_sysctrl_regs[SB_G2DTEXT] & dc_sysctrl_regs[SB_ISTEXT])) |
| 404 | { |
| 405 | const address_space *space = cputag_get_address_space(machine, "maincpu", ADDRESS_SPACE_PROGRAM); |
| 406 | |
| 407 | printf("Wave DMA HW trigger\n"); |
| 408 | wave_dma_execute(space); |
| 409 | } |
| 410 | } |
| 411 | |
| 412 | /* PVR-DMA HW trigger */ |
| 413 | if(pvr_dma.flag && ((pvr_dma.sel & 1) == 1)) |
| 414 | { |
| 415 | if((dc_sysctrl_regs[SB_PDTNRM] & dc_sysctrl_regs[SB_ISTNRM]) || (dc_sysctrl_regs[SB_PDTEXT] & dc_sysctrl_regs[SB_ISTEXT])) |
| 416 | { |
| 417 | const address_space *space = cputag_get_address_space(machine, "maincpu", ADDRESS_SPACE_PROGRAM); |
| 418 | |
| 419 | printf("PVR-DMA HW trigger\n"); |
| 420 | pvr_dma_execute(space); |
| 421 | } |
| 422 | } |
| 272 | 423 | } |
| 273 | 424 | |
| 274 | 425 | /****************************************************** |
| r7924 | r7925 | |
| 279 | 430 | [2] Parameter of the device |
| 280 | 431 | [3] End flag (always zero) |
| 281 | 432 | ******************************************************/ |
| 282 | | static int jvs_mux_data; |
| 283 | | |
| 284 | 433 | static int jvsboard_init(int pos) |
| 285 | 434 | { |
| 286 | 435 | // four bytes for every available function |
| r7924 | r7925 | |
| 290 | 439 | { |
| 291 | 440 | maple0x86data2[pos+11]=1; // number of players |
| 292 | 441 | maple0x86data2[pos+12]=22; // switches per player (27 = mahjong) |
| 293 | | jvs_mux_data = 1; |
| 294 | 442 | } |
| 295 | 443 | else //if JVSBD_DEFAULT |
| 296 | 444 | { |
| r7924 | r7925 | |
| 334 | 482 | if(jvsboard_type == JVSBD_MAHJONG) |
| 335 | 483 | { |
| 336 | 484 | maple0x86data2[pos+11]=0; |
| 337 | | switch(jvs_mux_data) |
| 485 | switch(mp_mux_data) |
| 338 | 486 | { |
| 339 | | case 0x01: maple0x86data2[pos+12]=input_port_read(machine, "IN1"); break; |
| 340 | | case 0x02: maple0x86data2[pos+12]=input_port_read(machine, "IN2"); break; |
| 341 | | case 0x04: maple0x86data2[pos+12]=input_port_read(machine, "IN3"); break; |
| 342 | | case 0x08: maple0x86data2[pos+12]=input_port_read(machine, "IN4"); break; |
| 343 | | case 0x10: maple0x86data2[pos+12]=0; break; |
| 487 | case 0x01: maple0x86data2[pos+12]=input_port_read(machine, "KEY1"); break; |
| 488 | case 0x02: maple0x86data2[pos+12]=input_port_read(machine, "KEY2"); break; |
| 489 | case 0x04: maple0x86data2[pos+12]=input_port_read(machine, "KEY3"); break; |
| 490 | case 0x08: maple0x86data2[pos+12]=input_port_read(machine, "KEY4"); break; |
| 491 | case 0x10: maple0x86data2[pos+12]=input_port_read(machine, "KEY5"); break; |
| 344 | 492 | } |
| 345 | 493 | maple0x86data2[pos+13]=0; |
| 346 | 494 | maple0x86data2[pos+14]=0; |
| 347 | 495 | |
| 348 | | jvs_mux_data<<=1; |
| 349 | | if(jvs_mux_data >= 0x20) { jvs_mux_data = 1; } |
| 496 | mp_mux_data<<=1; |
| 497 | if(mp_mux_data >= 0x20) { mp_mux_data = 1; } |
| 350 | 498 | } |
| 351 | 499 | else |
| 352 | 500 | { |
| r7924 | r7925 | |
| 403 | 551 | maple0x86data2[0x1b]=2; //number of players |
| 404 | 552 | if(jvsboard_type == JVSBD_MAHJONG) |
| 405 | 553 | { |
| 406 | | maple0x86data2[0x1c]=input_port_read(machine, "IN1"); |
| 407 | | maple0x86data2[0x1d]=input_port_read(machine, "IN2"); |
| 408 | | maple0x86data2[0x1e]=input_port_read(machine, "IN3"); |
| 409 | | maple0x86data2[0x1f]=input_port_read(machine, "IN4"); |
| 554 | maple0x86data2[0x1c]=0; |
| 555 | switch(mp_mux_data) |
| 556 | { |
| 557 | case 0x01: maple0x86data2[0x1d]=input_port_read(machine, "KEY1"); break; |
| 558 | case 0x02: maple0x86data2[0x1d]=input_port_read(machine, "KEY2"); break; |
| 559 | case 0x04: maple0x86data2[0x1d]=input_port_read(machine, "KEY3"); break; |
| 560 | case 0x08: maple0x86data2[0x1d]=input_port_read(machine, "KEY4"); break; |
| 561 | case 0x10: maple0x86data2[0x1d]=input_port_read(machine, "KEY5"); break; |
| 562 | } |
| 563 | maple0x86data2[0x1e]=0; |
| 564 | maple0x86data2[0x1f]=0; |
| 565 | |
| 566 | mp_mux_data<<=1; |
| 567 | if(mp_mux_data >= 0x20) { mp_mux_data = 1; } |
| 410 | 568 | } |
| 411 | 569 | else |
| 412 | 570 | { |
| r7924 | r7925 | |
| 478 | 636 | address=dc_sysctrl_regs[SB_C2DSTAT]; |
| 479 | 637 | ddtdata.destination=address; |
| 480 | 638 | /* 0 rounding size = 16 Mbytes */ |
| 481 | | if(dc_sysctrl_regs[SB_C2DLEN] == 0) { dc_sysctrl_regs[SB_C2DLEN] = 0x1000000; } |
| 482 | | ddtdata.length=dc_sysctrl_regs[SB_C2DLEN]; |
| 639 | if(dc_sysctrl_regs[SB_C2DLEN] == 0) |
| 640 | ddtdata.length = 0x1000000; |
| 641 | else |
| 642 | ddtdata.length = dc_sysctrl_regs[SB_C2DLEN]; |
| 483 | 643 | ddtdata.size=1; |
| 484 | 644 | ddtdata.direction=0; |
| 485 | 645 | ddtdata.channel=2; |
| r7924 | r7925 | |
| 529 | 689 | dc_sysctrl_regs[SB_ISTERR] = old & ~dat; |
| 530 | 690 | break; |
| 531 | 691 | case SB_SDST: |
| 532 | | #if DEBUG_SYSCTRL |
| 533 | | mame_printf_verbose("SYSCTRL: Sort-DMA not supported yet !!!\n"); |
| 534 | | #endif |
| 692 | //#if DEBUG_SYSCTRL |
| 693 | //mame_printf_verbose("SYSCTRL: Sort-DMA not supported yet !!!\n"); |
| 694 | //#endif |
| 695 | if(dat & 1) |
| 696 | { |
| 697 | // TODO: Sort-DMA routine goes here |
| 698 | printf("Sort-DMA irq\n"); |
| 699 | |
| 700 | dc_sysctrl_regs[SB_ISTNRM] |= IST_DMA_SORT; |
| 701 | dc_sysctrl_regs[SB_SDST] = 0; |
| 702 | } |
| 535 | 703 | break; |
| 536 | 704 | } |
| 537 | 705 | dc_update_interrupt_status(space->machine); |
| r7924 | r7925 | |
| 583 | 751 | maple_regs[reg] = dat; // 5f6c00+reg*4=dat |
| 584 | 752 | switch (reg) |
| 585 | 753 | { |
| 754 | case SB_MDTSEL: |
| 755 | if((dat & 1) == 1) |
| 756 | printf("MAPLE: hardware trigger not supported yet\n"); |
| 757 | break; |
| 586 | 758 | case SB_MDST: |
| 587 | | maple_regs[reg] = old; |
| 759 | maple_regs[SB_MDST] = old; |
| 588 | 760 | if (!(old & 1) && (dat & 1) && maple_regs[SB_MDEN] & 1) // 0 -> 1 |
| 589 | 761 | { |
| 590 | | if (!(maple_regs[SB_MDTSEL] & 1)) |
| 762 | if (!(maple_regs[SB_MDTSEL] & 1)) // SW trigger |
| 591 | 763 | { |
| 592 | | maple_regs[reg] = 1; |
| 764 | maple_regs[SB_MDST] = dat & 1; |
| 593 | 765 | dat=maple_regs[SB_MDSTAR]; |
| 594 | 766 | // printf("Maple DMA: %08x %08x %08x %08x\n",maple_regs[SB_MDSTAR],maple_regs[SB_MDTSEL],maple_regs[SB_MDEN],maple_regs[SB_MDST]); |
| 595 | 767 | // printf(" %08x %08x %08x %08x\n",maple_regs[SB_MSYS],maple_regs[SB_MST],maple_regs[SB_MSHTCL],maple_regs[SB_MMSEL]); |
| r7924 | r7925 | |
| 604 | 776 | ddtdata.mode= -1; // copy from/to buffer |
| 605 | 777 | sh4_dma_ddt(devtag_get_device(space->machine, "maincpu"), &ddtdata); |
| 606 | 778 | |
| 607 | | maple_regs[reg] = 0; |
| 608 | 779 | endflag=buff[0] & 0x80000000; |
| 609 | 780 | port=(buff[0] >> 16) & 3; |
| 610 | 781 | pattern=(buff[0] >> 8) & 7; |
| r7924 | r7925 | |
| 632 | 803 | case 3: |
| 633 | 804 | ddtdata.length=1; |
| 634 | 805 | #if DEBUG_MAPLE |
| 806 | if(port == 0) |
| 635 | 807 | printf("MAPLE: transfer command %x port %x length %x\n", command, port, length); |
| 636 | 808 | #endif |
| 637 | 809 | break; |
| r7924 | r7925 | |
| 764 | 936 | case 0x14: |
| 765 | 937 | { |
| 766 | 938 | tocopy += jvsboard_init(pos); |
| 939 | |
| 940 | //TODO: something sets 0 in the mux data, dunno what yet |
| 941 | if(jvsboard_type == JVSBD_MAHJONG) |
| 942 | mp_mux_data = 1; |
| 767 | 943 | } |
| 768 | 944 | break; |
| 769 | 945 | case 0x21: |
| r7924 | r7925 | |
| 871 | 1047 | |
| 872 | 1048 | if (endflag) |
| 873 | 1049 | { |
| 874 | | #if 1 //ENABLE_MAPLE_IRQ |
| 875 | | /*TODO: this fixes moeru but breaks other games, understand why.*/ |
| 876 | | dc_sysctrl_regs[SB_ISTNRM] |= IST_DMA_MAPLE; |
| 877 | | dc_update_interrupt_status(space->machine); |
| 878 | | #endif |
| 1050 | timer_set(space->machine, ATTOTIME_IN_USEC(200), NULL, 0, maple_dma_irq); |
| 879 | 1051 | break; |
| 880 | 1052 | } |
| 881 | 1053 | // skip fixed packet header |
| r7924 | r7925 | |
| 883 | 1055 | // skip transfer data |
| 884 | 1056 | dat += (length + 1) * 4; |
| 885 | 1057 | } // do transfers |
| 886 | | maple_regs[reg] = 0; |
| 1058 | |
| 887 | 1059 | } |
| 888 | | else |
| 889 | | { |
| 890 | | #if DEBUG_MAPLE |
| 891 | | printf("MAPLE: hardware trigger not supported yet\n"); |
| 892 | | #endif |
| 893 | | } |
| 1060 | |
| 894 | 1061 | } |
| 895 | 1062 | break; |
| 896 | 1063 | } |
| r7924 | r7925 | |
| 930 | 1097 | maple_regs[reg] = dat; // 5f6c00+reg*4=dat |
| 931 | 1098 | switch (reg) |
| 932 | 1099 | { |
| 1100 | case SB_MDTSEL: |
| 1101 | if((dat & 1) == 1) |
| 1102 | printf("MAPLE: hardware trigger not supported yet\n"); |
| 1103 | break; |
| 933 | 1104 | case SB_MDST: |
| 934 | | maple_regs[reg] = old; |
| 1105 | maple_regs[SB_MDST] = old; |
| 935 | 1106 | if (!(old & 1) && (dat & 1) && maple_regs[SB_MDEN] & 1) // 0 -> 1 |
| 936 | 1107 | { |
| 937 | 1108 | if (!(maple_regs[SB_MDTSEL] & 1)) |
| 938 | 1109 | { |
| 939 | | maple_regs[reg] = 1; |
| 1110 | maple_regs[SB_MDST] = dat & 1; |
| 940 | 1111 | dat=maple_regs[SB_MDSTAR]; |
| 941 | 1112 | // printf("Maple DMA: %08x %08x %08x %08x\n",maple_regs[SB_MDSTAR],maple_regs[SB_MDTSEL],maple_regs[SB_MDEN],maple_regs[SB_MDST]); |
| 942 | 1113 | // printf(" %08x %08x %08x %08x\n",maple_regs[SB_MSYS],maple_regs[SB_MST],maple_regs[SB_MSHTCL],maple_regs[SB_MMSEL]); |
| r7924 | r7925 | |
| 951 | 1122 | ddtdata.mode= -1; // copy from/to buffer |
| 952 | 1123 | sh4_dma_ddt(devtag_get_device(space->machine, "maincpu"), &ddtdata); |
| 953 | 1124 | |
| 954 | | maple_regs[reg] = 0; |
| 955 | 1125 | endflag=buff[0] & 0x80000000; |
| 956 | 1126 | port=(buff[0] >> 16) & 3; |
| 957 | 1127 | pattern=(buff[0] >> 8) & 7; |
| r7924 | r7925 | |
| 1026 | 1196 | |
| 1027 | 1197 | if (endflag) |
| 1028 | 1198 | { |
| 1029 | | #if ENABLE_MAPLE_IRQ |
| 1030 | | dc_sysctrl_regs[SB_ISTNRM] |= IST_DMA_MAPLE; |
| 1031 | | dc_update_interrupt_status(space->machine); |
| 1032 | | #endif |
| 1199 | timer_set(space->machine, ATTOTIME_IN_USEC(200), NULL, 0, maple_dma_irq); |
| 1033 | 1200 | break; |
| 1034 | 1201 | } |
| 1035 | 1202 | // skip fixed packet header |
| r7924 | r7925 | |
| 1037 | 1204 | // skip transfer data |
| 1038 | 1205 | dat += (length + 1) * 4; |
| 1039 | 1206 | } // do transfers |
| 1040 | | maple_regs[reg] = 0; |
| 1207 | |
| 1041 | 1208 | } |
| 1042 | | else |
| 1043 | | { |
| 1044 | | #if DEBUG_MAPLE |
| 1045 | | printf("MAPLE: hardware trigger not supported yet\n"); |
| 1046 | | #endif |
| 1047 | | } |
| 1048 | 1209 | } |
| 1049 | 1210 | break; |
| 1050 | 1211 | } |
| r7924 | r7925 | |
| 1126 | 1287 | switch (reg) |
| 1127 | 1288 | { |
| 1128 | 1289 | case SB_GDST: |
| 1129 | | if (dat & 1 && g1bus_regs[SB_GDEN] == 1) // 0 -> 1 |
| 1290 | g1bus_regs[SB_GDST] = old; |
| 1291 | if (((old & 1) == 0) && (dat & 1) && g1bus_regs[SB_GDEN] == 1) // 0 -> 1 |
| 1130 | 1292 | { |
| 1131 | 1293 | if (g1bus_regs[SB_GDDIR] == 0) |
| 1132 | 1294 | { |
| 1133 | | mame_printf_verbose("G1CTRL: unsupported transfer\n"); |
| 1295 | printf("G1CTRL: unsupported transfer\n"); |
| 1134 | 1296 | return; |
| 1135 | 1297 | } |
| 1298 | g1bus_regs[SB_GDST] = dat & 1; |
| 1136 | 1299 | // printf("ROM board DMA to %x len %x (PC %x)\n", g1bus_regs[SB_GDSTAR], g1bus_regs[SB_GDLEN], cpu_get_pc(space->cpu)); |
| 1137 | 1300 | ROM = (UINT8 *)space->machine->device("rom_board")->get_runtime_ptr(DEVINFO_PTR_MEMORY); |
| 1138 | 1301 | dmaoffset = (UINT32)space->machine->device("rom_board")->get_runtime_int(DEVINFO_INT_DMAOFFSET); |
| 1139 | 1302 | ddtdata.destination=g1bus_regs[SB_GDSTAR]; // destination address |
| 1140 | 1303 | ddtdata.length=g1bus_regs[SB_GDLEN] >> 5; // words to transfer |
| 1304 | /* data in the lower 5 bits makes the length size to round by 32 bytes, this'll be needed by Virtua Tennis to boot (according to Deunan) */ |
| 1305 | if(g1bus_regs[SB_GDLEN] & 0x1c) |
| 1306 | ddtdata.length++; |
| 1307 | |
| 1141 | 1308 | ddtdata.size=32; // bytes per word |
| 1142 | 1309 | ddtdata.buffer=ROM+dmaoffset; // buffer address |
| 1143 | 1310 | ddtdata.direction=1; // 0 source to buffer, 1 buffer to destination |
| r7924 | r7925 | |
| 1145 | 1312 | ddtdata.mode= -1; // copy from/to buffer |
| 1146 | 1313 | mame_printf_verbose("G1CTRL: transfer %x from ROM %08x to sdram %08x\n", g1bus_regs[SB_GDLEN], dmaoffset, g1bus_regs[SB_GDSTAR]); |
| 1147 | 1314 | sh4_dma_ddt(devtag_get_device(space->machine, "maincpu"), &ddtdata); |
| 1148 | | g1bus_regs[SB_GDST]=0; |
| 1149 | | dc_sysctrl_regs[SB_ISTNRM] |= IST_DMA_GDROM; |
| 1150 | | dc_update_interrupt_status(space->machine); |
| 1315 | /* Note: KOF Neowave definitely wants this to be delayed (!) */ |
| 1316 | /* FIXME: timing of this */ |
| 1317 | timer_set(space->machine, ATTOTIME_IN_USEC(500), NULL, 0, gdrom_dma_irq); |
| 1151 | 1318 | } |
| 1152 | 1319 | break; |
| 1153 | 1320 | } |
| r7924 | r7925 | |
| 1168 | 1335 | int reg; |
| 1169 | 1336 | UINT64 shift; |
| 1170 | 1337 | UINT32 dat; |
| 1171 | | static struct { |
| 1172 | | UINT32 aica_addr; |
| 1173 | | UINT32 root_addr; |
| 1174 | | UINT32 size; |
| 1175 | | UINT8 dir; |
| 1176 | | UINT8 flag; |
| 1177 | | UINT8 indirect; |
| 1178 | | UINT8 start; |
| 1179 | | UINT8 sel; |
| 1180 | | }wave_dma; |
| 1338 | UINT8 old; |
| 1181 | 1339 | |
| 1182 | 1340 | reg = decode_reg32_64(space->machine, offset, mem_mask, &shift); |
| 1183 | 1341 | dat = (UINT32)(data >> shift); |
| r7924 | r7925 | |
| 1199 | 1357 | case SB_ADDIR: wave_dma.dir = (dat & 1); break; |
| 1200 | 1358 | /*dma flag (active HIGH, bug in docs)*/ |
| 1201 | 1359 | case SB_ADEN: wave_dma.flag = (dat & 1); break; |
| 1360 | /* |
| 1361 | SB_ADTSEL |
| 1362 | bit 1: (0) Wave DMA thru SB_ADST flag (1) Wave DMA thru irq trigger, defined by SB_G2DTNRM / SB_G2DTEXT |
| 1363 | */ |
| 1202 | 1364 | case SB_ADTSEL: wave_dma.sel = dat & 7; break; |
| 1203 | 1365 | /*ready for dma'ing*/ |
| 1204 | 1366 | case SB_ADST: |
| 1367 | old = wave_dma.start & 1; |
| 1205 | 1368 | wave_dma.start = dat & 1; |
| 1206 | 1369 | |
| 1207 | 1370 | #if DEBUG_AICA_DMA |
| r7924 | r7925 | |
| 1211 | 1374 | #endif |
| 1212 | 1375 | |
| 1213 | 1376 | //mame_printf_verbose("SB_ADST data %08x\n",dat); |
| 1214 | | if(wave_dma.flag && wave_dma.start) |
| 1215 | | { |
| 1216 | | UINT32 src,dst,size; |
| 1217 | | dst = wave_dma.aica_addr; |
| 1218 | | src = wave_dma.root_addr; |
| 1219 | | size = 0; |
| 1220 | | /* 0 rounding size = 32 Mbytes */ |
| 1221 | | if(wave_dma.size == 0) { wave_dma.size = 0x200000; } |
| 1222 | | |
| 1223 | | if(wave_dma.dir == 0) |
| 1224 | | { |
| 1225 | | for(;size<wave_dma.size;size+=4) |
| 1226 | | { |
| 1227 | | memory_write_dword_64le(space,dst,memory_read_dword(space,src)); |
| 1228 | | src+=4; |
| 1229 | | dst+=4; |
| 1230 | | } |
| 1231 | | } |
| 1232 | | else |
| 1233 | | { |
| 1234 | | for(;size<wave_dma.size;size+=4) |
| 1235 | | { |
| 1236 | | memory_write_dword_64le(space,src,memory_read_dword(space,dst)); |
| 1237 | | src+=4; |
| 1238 | | dst+=4; |
| 1239 | | } |
| 1240 | | } |
| 1241 | | /* update the params*/ |
| 1242 | | wave_dma.aica_addr = g2bus_regs[SB_ADSTAG] = dst; |
| 1243 | | wave_dma.root_addr = g2bus_regs[SB_ADSTAR] = src; |
| 1244 | | wave_dma.size = g2bus_regs[SB_ADLEN] = 0; |
| 1245 | | wave_dma.flag = (wave_dma.indirect & 1) ? 1 : 0; |
| 1246 | | wave_dma.start = g2bus_regs[SB_ADST] = 0; |
| 1247 | | /*TODO: this makes the sfz3upper to not play any bgm, understand why. */ |
| 1248 | | //dc_sysctrl_regs[SB_ISTNRM] |= IST_DMA_AICA; |
| 1249 | | //dc_update_interrupt_status(space->machine); |
| 1250 | | } |
| 1377 | if(((old & 1) == 0) && wave_dma.flag && wave_dma.start && ((wave_dma.sel & 2) == 0)) // 0 -> 1 |
| 1378 | wave_dma_execute(space); |
| 1251 | 1379 | break; |
| 1252 | 1380 | |
| 1253 | 1381 | case SB_ADSUSP: |
| r7924 | r7925 | |
| 1264 | 1392 | } |
| 1265 | 1393 | } |
| 1266 | 1394 | |
| 1395 | INLINE int decode_reg_64(UINT32 offset, UINT64 mem_mask, UINT64 *shift) |
| 1396 | { |
| 1397 | int reg = offset * 2; |
| 1398 | |
| 1399 | *shift = 0; |
| 1400 | |
| 1401 | // non 32-bit accesses have not yet been seen here, we need to know when they are |
| 1402 | if ((mem_mask != U64(0xffffffff00000000)) && (mem_mask != U64(0x00000000ffffffff))) |
| 1403 | { |
| 1404 | /*assume to return the lower 32-bits ONLY*/ |
| 1405 | return reg & 0xffffffff; |
| 1406 | } |
| 1407 | |
| 1408 | if (mem_mask == U64(0xffffffff00000000)) |
| 1409 | { |
| 1410 | reg++; |
| 1411 | *shift = 32; |
| 1412 | } |
| 1413 | |
| 1414 | return reg; |
| 1415 | } |
| 1416 | |
| 1417 | READ64_HANDLER( pvr_ctrl_r ) |
| 1418 | { |
| 1419 | int reg; |
| 1420 | UINT64 shift; |
| 1421 | |
| 1422 | reg = decode_reg_64(offset, mem_mask, &shift); |
| 1423 | |
| 1424 | #if DEBUG_PVRCTRL |
| 1425 | mame_printf_verbose("PVRCTRL: [%08x] read %x @ %x (reg %x), mask %" I64FMT "x (PC=%x)\n", 0x5f7c00+reg*4, pvrctrl_regs[reg], offset, reg, mem_mask, cpu_get_pc(space->cpu)); |
| 1426 | #endif |
| 1427 | |
| 1428 | return (UINT64)pvrctrl_regs[reg] << shift; |
| 1429 | } |
| 1430 | |
| 1431 | WRITE64_HANDLER( pvr_ctrl_w ) |
| 1432 | { |
| 1433 | int reg; |
| 1434 | UINT64 shift; |
| 1435 | UINT32 dat; |
| 1436 | UINT8 old; |
| 1437 | |
| 1438 | reg = decode_reg_64(offset, mem_mask, &shift); |
| 1439 | dat = (UINT32)(data >> shift); |
| 1440 | |
| 1441 | switch (reg) |
| 1442 | { |
| 1443 | case SB_PDSTAP: pvr_dma.pvr_addr = dat; break; |
| 1444 | case SB_PDSTAR: pvr_dma.sys_addr = dat; break; |
| 1445 | case SB_PDLEN: pvr_dma.size = dat; break; |
| 1446 | case SB_PDDIR: pvr_dma.dir = dat & 1; break; |
| 1447 | case SB_PDTSEL: |
| 1448 | pvr_dma.sel = dat & 1; |
| 1449 | //if(pvr_dma.sel & 1) |
| 1450 | // printf("Warning: Unsupported irq mode trigger PVR-DMA\n"); |
| 1451 | break; |
| 1452 | case SB_PDEN: pvr_dma.flag = dat & 1; break; |
| 1453 | case SB_PDST: |
| 1454 | old = pvr_dma.start & 1; |
| 1455 | pvr_dma.start = dat & 1; |
| 1456 | |
| 1457 | if(((old & 1) == 0) && pvr_dma.flag && pvr_dma.start && ((pvr_dma.sel & 1) == 0)) // 0 -> 1 |
| 1458 | pvr_dma_execute(space); |
| 1459 | break; |
| 1460 | } |
| 1461 | |
| 1462 | #if DEBUG_PVRCTRL |
| 1463 | mame_printf_verbose("PVRCTRL: [%08x=%x] write %" I64FMT "x to %x (reg %x), mask %" I64FMT "x\n", 0x5f7c00+reg*4, dat, data>>shift, offset, reg, mem_mask); |
| 1464 | #endif |
| 1465 | |
| 1466 | // pvrctrl_regs[reg] |= dat; |
| 1467 | pvrctrl_regs[reg] = dat; |
| 1468 | |
| 1469 | } |
| 1470 | |
| 1267 | 1471 | READ64_HANDLER( dc_modem_r ) |
| 1268 | 1472 | { |
| 1269 | 1473 | int reg; |
| r7924 | r7925 | |
| 1359 | 1563 | timer_adjust_periodic(dc_rtc_timer, attotime_zero, 0, ATTOTIME_IN_SEC(1)); |
| 1360 | 1564 | |
| 1361 | 1565 | dc_sysctrl_regs[SB_SBREV] = 0x0b; |
| 1566 | |
| 1567 | mp_mux_data = 0; |
| 1362 | 1568 | } |
| 1363 | 1569 | |
| 1364 | 1570 | READ64_DEVICE_HANDLER( dc_aica_reg_r ) |
src/mame/video/dc.c
| r7924 | r7925 | |
| 13 | 13 | |
| 14 | 14 | static int vblc=0; |
| 15 | 15 | #define DEBUG_FIFO_POLY (0) |
| 16 | | #define DEBUG_PVRCTRL (0) |
| 17 | 16 | #define DEBUG_PVRTA (0) |
| 18 | 17 | #define DEBUG_PVRTA_REGS (0) |
| 19 | 18 | #define DEBUG_PVRDLIST (1) |
| r7924 | r7925 | |
| 112 | 111 | #define vo_vert_start_pos_f2 ((pvrta_regs[VO_STARTY] & 0x03ff0000) >> 16) |
| 113 | 112 | #define vo_vert_start_pos_f1 ((pvrta_regs[VO_STARTY] & 0x000003ff) >> 0) |
| 114 | 113 | |
| 114 | /* |
| 115 | SPG_STATUS |
| 116 | ---- ---- ---- ---- --x- ---- ---- ---- vsync |
| 117 | ---- ---- ---- ---- ---x ---- ---- ---- hsync |
| 118 | ---- ---- ---- ---- ---- x--- ---- ---- blank |
| 119 | ---- ---- ---- ---- ---- -x-- ---- ---- field number |
| 120 | ---- ---- ---- ---- ---- --xx xxxx xxxx scanline |
| 121 | */ |
| 115 | 122 | |
| 116 | | |
| 117 | 123 | UINT32 pvrctrl_regs[0x100/4]; |
| 118 | 124 | static UINT32 pvrta_regs[0x2000/4]; |
| 119 | 125 | static const int pvr_parconfseq[] = {1,2,3,2,3,4,5,6,5,6,7,8,9,10,11,12,13,14,13,14,15,16,17,16,17,0,0,0,0,0,18,19,20,19,20,21,22,23,22,23}; |
| r7924 | r7925 | |
| 975 | 981 | return reg; |
| 976 | 982 | } |
| 977 | 983 | |
| 978 | | READ64_HANDLER( pvr_ctrl_r ) |
| 979 | | { |
| 980 | | int reg; |
| 981 | | UINT64 shift; |
| 982 | | |
| 983 | | reg = decode_reg_64(offset, mem_mask, &shift); |
| 984 | | |
| 985 | | #if DEBUG_PVRCTRL |
| 986 | | mame_printf_verbose("PVRCTRL: [%08x] read %x @ %x (reg %x), mask %" I64FMT "x (PC=%x)\n", 0x5f7c00+reg*4, pvrctrl_regs[reg], offset, reg, mem_mask, cpu_get_pc(space->cpu)); |
| 987 | | #endif |
| 988 | | |
| 989 | | return (UINT64)pvrctrl_regs[reg] << shift; |
| 990 | | } |
| 991 | | |
| 992 | | WRITE64_HANDLER( pvr_ctrl_w ) |
| 993 | | { |
| 994 | | int reg; |
| 995 | | UINT64 shift; |
| 996 | | UINT32 dat; |
| 997 | | static struct { |
| 998 | | UINT32 pvr_addr; |
| 999 | | UINT32 sys_addr; |
| 1000 | | UINT32 size; |
| 1001 | | UINT8 sel; |
| 1002 | | UINT8 dir; |
| 1003 | | UINT8 flag; |
| 1004 | | UINT8 start; |
| 1005 | | }pvr_dma; |
| 1006 | | |
| 1007 | | reg = decode_reg_64(offset, mem_mask, &shift); |
| 1008 | | dat = (UINT32)(data >> shift); |
| 1009 | | |
| 1010 | | switch (reg) |
| 1011 | | { |
| 1012 | | case SB_PDSTAP: pvr_dma.pvr_addr = dat; break; |
| 1013 | | case SB_PDSTAR: pvr_dma.sys_addr = dat; break; |
| 1014 | | case SB_PDLEN: pvr_dma.size = dat; break; |
| 1015 | | case SB_PDDIR: pvr_dma.dir = dat & 1; break; |
| 1016 | | case SB_PDTSEL: |
| 1017 | | pvr_dma.sel = dat & 1; |
| 1018 | | if(pvr_dma.sel & 1) |
| 1019 | | printf("Warning: Unsupported irq mode trigger PVR-DMA\n"); |
| 1020 | | break; |
| 1021 | | case SB_PDEN: pvr_dma.flag = dat & 1; break; |
| 1022 | | case SB_PDST: |
| 1023 | | pvr_dma.start = dat & 1; |
| 1024 | | |
| 1025 | | if(pvr_dma.flag && pvr_dma.start) |
| 1026 | | { |
| 1027 | | UINT32 src,dst,size; |
| 1028 | | dst = pvr_dma.pvr_addr; |
| 1029 | | src = pvr_dma.sys_addr; |
| 1030 | | size = 0; |
| 1031 | | |
| 1032 | | /* used by usagui and sprtjam*/ |
| 1033 | | printf("PVR-DMA start\n"); |
| 1034 | | printf("%08x %08x %08x\n",pvr_dma.pvr_addr,pvr_dma.sys_addr,pvr_dma.size); |
| 1035 | | printf("src %s dst %08x\n",pvr_dma.dir ? "->" : "<-",pvr_dma.sel); |
| 1036 | | |
| 1037 | | /* 0 rounding size = 16 Mbytes */ |
| 1038 | | if(pvr_dma.size == 0) { pvr_dma.size = 0x100000; } |
| 1039 | | |
| 1040 | | if(pvr_dma.dir == 0) |
| 1041 | | { |
| 1042 | | for(;size<pvr_dma.size;size+=4) |
| 1043 | | { |
| 1044 | | memory_write_dword_64le(space,dst,memory_read_dword(space,src)); |
| 1045 | | src+=4; |
| 1046 | | dst+=4; |
| 1047 | | } |
| 1048 | | } |
| 1049 | | else |
| 1050 | | { |
| 1051 | | for(;size<pvr_dma.size;size+=4) |
| 1052 | | { |
| 1053 | | memory_write_dword_64le(space,src,memory_read_dword(space,dst)); |
| 1054 | | src+=4; |
| 1055 | | dst+=4; |
| 1056 | | } |
| 1057 | | } |
| 1058 | | /*Note: do not update the params, since this DMA type doesn't support it. */ |
| 1059 | | |
| 1060 | | dc_sysctrl_regs[SB_ISTNRM] |= IST_DMA_PVR; |
| 1061 | | dc_update_interrupt_status(space->machine); |
| 1062 | | } |
| 1063 | | break; |
| 1064 | | } |
| 1065 | | |
| 1066 | | #if DEBUG_PVRCTRL |
| 1067 | | mame_printf_verbose("PVRCTRL: [%08x=%x] write %" I64FMT "x to %x (reg %x), mask %" I64FMT "x\n", 0x5f7c00+reg*4, dat, data>>shift, offset, reg, mem_mask); |
| 1068 | | #endif |
| 1069 | | |
| 1070 | | // pvrctrl_regs[reg] |= dat; |
| 1071 | | pvrctrl_regs[reg] = dat; |
| 1072 | | |
| 1073 | | } |
| 1074 | | |
| 1075 | 984 | READ64_HANDLER( pvr_ta_r ) |
| 1076 | 985 | { |
| 1077 | 986 | int reg; |
| r7924 | r7925 | |
| 1097 | 1006 | blank = (video_screen_get_vblank(space->machine->primary_screen) | video_screen_get_hblank(space->machine->primary_screen)) ? 0 : 1; |
| 1098 | 1007 | if(spg_blank_pol) { blank^=1; } |
| 1099 | 1008 | |
| 1100 | | pvrta_regs[reg] = (vsync << 13) | (hsync << 12) | (blank << 11) | (fieldnum << 10) | (video_screen_get_vpos(space->machine->primary_screen) & 0x1ff); |
| 1009 | pvrta_regs[reg] = (vsync << 13) | (hsync << 12) | (blank << 11) | (fieldnum << 10) | (video_screen_get_vpos(space->machine->primary_screen) & 0x3ff); |
| 1101 | 1010 | break; |
| 1102 | 1011 | } |
| 1103 | 1012 | case SPG_TRIGGER_POS: |
| 1104 | 1013 | printf("Warning: read at h/v counter ext latches\n"); |
| 1105 | 1014 | break; |
| 1015 | case TA_LIST_INIT: |
| 1016 | return 0; //bit 31 always return 0, a probable left-over in Crazy Taxi reads this and discards the read (?) |
| 1106 | 1017 | } |
| 1107 | 1018 | |
| 1108 | 1019 | #if DEBUG_PVRTA_REGS |
| r7924 | r7925 | |
| 1261 | 1172 | assert_always(0, "TA grabber error A!\n"); |
| 1262 | 1173 | break; |
| 1263 | 1174 | case TA_LIST_INIT: |
| 1264 | | state_ta.tafifo_pos=0; |
| 1265 | | state_ta.tafifo_mask=7; |
| 1266 | | state_ta.tafifo_vertexwords=8; |
| 1267 | | state_ta.tafifo_listtype= -1; |
| 1175 | if(dat & 0x80000000) |
| 1176 | { |
| 1177 | state_ta.tafifo_pos=0; |
| 1178 | state_ta.tafifo_mask=7; |
| 1179 | state_ta.tafifo_vertexwords=8; |
| 1180 | state_ta.tafifo_listtype= -1; |
| 1268 | 1181 | #if DEBUG_PVRTA |
| 1269 | | mame_printf_verbose("TA_OL_BASE %08x TA_OL_LIMIT %08x\n", pvrta_regs[TA_OL_BASE], pvrta_regs[TA_OL_LIMIT]); |
| 1270 | | mame_printf_verbose("TA_ISP_BASE %08x TA_ISP_LIMIT %08x\n", pvrta_regs[TA_ISP_BASE], pvrta_regs[TA_ISP_LIMIT]); |
| 1271 | | mame_printf_verbose("TA_ALLOC_CTRL %08x\n", pvrta_regs[TA_ALLOC_CTRL]); |
| 1272 | | mame_printf_verbose("TA_NEXT_OPB_INIT %08x\n", pvrta_regs[TA_NEXT_OPB_INIT]); |
| 1182 | mame_printf_verbose("TA_OL_BASE %08x TA_OL_LIMIT %08x\n", pvrta_regs[TA_OL_BASE], pvrta_regs[TA_OL_LIMIT]); |
| 1183 | mame_printf_verbose("TA_ISP_BASE %08x TA_ISP_LIMIT %08x\n", pvrta_regs[TA_ISP_BASE], pvrta_regs[TA_ISP_LIMIT]); |
| 1184 | mame_printf_verbose("TA_ALLOC_CTRL %08x\n", pvrta_regs[TA_ALLOC_CTRL]); |
| 1185 | mame_printf_verbose("TA_NEXT_OPB_INIT %08x\n", pvrta_regs[TA_NEXT_OPB_INIT]); |
| 1273 | 1186 | #endif |
| 1274 | | pvrta_regs[TA_NEXT_OPB] = pvrta_regs[TA_NEXT_OPB_INIT]; |
| 1275 | | pvrta_regs[TA_ITP_CURRENT] = pvrta_regs[TA_ISP_BASE]; |
| 1276 | | state_ta.alloc_ctrl_OPB_Mode = pvrta_regs[TA_ALLOC_CTRL] & 0x100000; // 0 up 1 down |
| 1277 | | state_ta.alloc_ctrl_PT_OPB = (4 << ((pvrta_regs[TA_ALLOC_CTRL] >> 16) & 3)) & 0x38; // number of 32 bit words (0,8,16,32) |
| 1278 | | state_ta.alloc_ctrl_TM_OPB = (4 << ((pvrta_regs[TA_ALLOC_CTRL] >> 12) & 3)) & 0x38; |
| 1279 | | state_ta.alloc_ctrl_T_OPB = (4 << ((pvrta_regs[TA_ALLOC_CTRL] >> 8) & 3)) & 0x38; |
| 1280 | | state_ta.alloc_ctrl_OM_OPB = (4 << ((pvrta_regs[TA_ALLOC_CTRL] >> 4) & 3)) & 0x38; |
| 1281 | | state_ta.alloc_ctrl_O_OPB = (4 << ((pvrta_regs[TA_ALLOC_CTRL] >> 0) & 3)) & 0x38; |
| 1282 | | state_ta.listtype_used |= (1+4); |
| 1283 | | // use TA_ISP_BASE and select buffer for grab data |
| 1284 | | state_ta.grabsel = -1; |
| 1285 | | // try to find already used buffer but not busy |
| 1286 | | for (a=0;a < NUM_BUFFERS;a++) |
| 1287 | | { |
| 1288 | | if ((state_ta.grab[a].ispbase == pvrta_regs[TA_ISP_BASE]) && (state_ta.grab[a].busy == 0) && (state_ta.grab[a].valid == 1)) |
| 1289 | | { |
| 1290 | | state_ta.grabsel=a; |
| 1291 | | break; |
| 1292 | | } |
| 1293 | | } |
| 1294 | | // try a buffer not used yet |
| 1295 | | if (state_ta.grabsel < 0) |
| 1296 | | { |
| 1187 | pvrta_regs[TA_NEXT_OPB] = pvrta_regs[TA_NEXT_OPB_INIT]; |
| 1188 | pvrta_regs[TA_ITP_CURRENT] = pvrta_regs[TA_ISP_BASE]; |
| 1189 | state_ta.alloc_ctrl_OPB_Mode = pvrta_regs[TA_ALLOC_CTRL] & 0x100000; // 0 up 1 down |
| 1190 | state_ta.alloc_ctrl_PT_OPB = (4 << ((pvrta_regs[TA_ALLOC_CTRL] >> 16) & 3)) & 0x38; // number of 32 bit words (0,8,16,32) |
| 1191 | state_ta.alloc_ctrl_TM_OPB = (4 << ((pvrta_regs[TA_ALLOC_CTRL] >> 12) & 3)) & 0x38; |
| 1192 | state_ta.alloc_ctrl_T_OPB = (4 << ((pvrta_regs[TA_ALLOC_CTRL] >> 8) & 3)) & 0x38; |
| 1193 | state_ta.alloc_ctrl_OM_OPB = (4 << ((pvrta_regs[TA_ALLOC_CTRL] >> 4) & 3)) & 0x38; |
| 1194 | state_ta.alloc_ctrl_O_OPB = (4 << ((pvrta_regs[TA_ALLOC_CTRL] >> 0) & 3)) & 0x38; |
| 1195 | state_ta.listtype_used |= (1+4); |
| 1196 | // use TA_ISP_BASE and select buffer for grab data |
| 1197 | state_ta.grabsel = -1; |
| 1198 | // try to find already used buffer but not busy |
| 1297 | 1199 | for (a=0;a < NUM_BUFFERS;a++) |
| 1298 | 1200 | { |
| 1299 | | if (state_ta.grab[a].valid == 0) |
| 1201 | if ((state_ta.grab[a].ispbase == pvrta_regs[TA_ISP_BASE]) && (state_ta.grab[a].busy == 0) && (state_ta.grab[a].valid == 1)) |
| 1300 | 1202 | { |
| 1301 | 1203 | state_ta.grabsel=a; |
| 1302 | 1204 | break; |
| 1303 | 1205 | } |
| 1304 | 1206 | } |
| 1305 | | } |
| 1306 | | // find a non busy buffer starting from the last one used |
| 1307 | | if (state_ta.grabsel < 0) |
| 1308 | | { |
| 1309 | | for (a=0;a < 3;a++) |
| 1207 | // try a buffer not used yet |
| 1208 | if (state_ta.grabsel < 0) |
| 1310 | 1209 | { |
| 1311 | | if (state_ta.grab[(state_ta.grabsellast+1+a) & 3].busy == 0) |
| 1210 | for (a=0;a < NUM_BUFFERS;a++) |
| 1312 | 1211 | { |
| 1313 | | state_ta.grabsel=a; |
| 1314 | | break; |
| 1212 | if (state_ta.grab[a].valid == 0) |
| 1213 | { |
| 1214 | state_ta.grabsel=a; |
| 1215 | break; |
| 1216 | } |
| 1315 | 1217 | } |
| 1316 | 1218 | } |
| 1317 | | } |
| 1318 | | if (state_ta.grabsel < 0) |
| 1319 | | assert_always(0, "TA grabber error B!\n"); |
| 1320 | | state_ta.grabsellast=state_ta.grabsel; |
| 1321 | | state_ta.grab[state_ta.grabsel].ispbase=pvrta_regs[TA_ISP_BASE]; |
| 1322 | | state_ta.grab[state_ta.grabsel].busy=0; |
| 1323 | | state_ta.grab[state_ta.grabsel].valid=1; |
| 1324 | | state_ta.grab[state_ta.grabsel].verts_size=0; |
| 1325 | | state_ta.grab[state_ta.grabsel].strips_size=0; |
| 1219 | // find a non busy buffer starting from the last one used |
| 1220 | if (state_ta.grabsel < 0) |
| 1221 | { |
| 1222 | for (a=0;a < 3;a++) |
| 1223 | { |
| 1224 | if (state_ta.grab[(state_ta.grabsellast+1+a) & 3].busy == 0) |
| 1225 | { |
| 1226 | state_ta.grabsel=a; |
| 1227 | break; |
| 1228 | } |
| 1229 | } |
| 1230 | } |
| 1231 | if (state_ta.grabsel < 0) |
| 1232 | assert_always(0, "TA grabber error B!\n"); |
| 1233 | state_ta.grabsellast=state_ta.grabsel; |
| 1234 | state_ta.grab[state_ta.grabsel].ispbase=pvrta_regs[TA_ISP_BASE]; |
| 1235 | state_ta.grab[state_ta.grabsel].busy=0; |
| 1236 | state_ta.grab[state_ta.grabsel].valid=1; |
| 1237 | state_ta.grab[state_ta.grabsel].verts_size=0; |
| 1238 | state_ta.grab[state_ta.grabsel].strips_size=0; |
| 1326 | 1239 | |
| 1327 | | profiler_mark_end(); |
| 1240 | profiler_mark_end(); |
| 1241 | } |
| 1328 | 1242 | break; |
| 1329 | 1243 | //#define TA_YUV_TEX_BASE ((0x005f8148-0x005f8000)/4) |
| 1330 | 1244 | case TA_YUV_TEX_BASE: |
| r7924 | r7925 | |
| 1357 | 1271 | visarea.min_y = 0; |
| 1358 | 1272 | visarea.max_y = ((spg_vbstart - spg_vbend - vo_vert_start_pos_f1) <= 0x100 ? 240 : 480) - 1; |
| 1359 | 1273 | |
| 1274 | |
| 1360 | 1275 | video_screen_configure(space->machine->primary_screen, spg_hbstart, spg_vbstart, &visarea, video_screen_get_frame_period(space->machine->primary_screen).attoseconds ); |
| 1361 | 1276 | } |
| 1362 | 1277 | break; |