trunk/src/mame/machine/megacdcd.c
| r19370 | r19371 | |
| 23 | 23 | for (int i=0;i<10;i++) |
| 24 | 24 | CDD_RX[i] = 0; |
| 25 | 25 | NeoCDCommsWordCount = 0; |
| 26 | | NeoCDAssyStatus = 0; |
| 26 | NeoCD_StatusHack = 0; |
| 27 | 27 | SCD_CURLBA = 0; |
| 28 | 28 | |
| 29 | 29 | CDC_REG0 = 0; |
| r19370 | r19371 | |
| 107 | 107 | CDD_RX[7] + |
| 108 | 108 | CDD_RX[8]; |
| 109 | 109 | |
| 110 | if (is_neoCD) checksum += 0x5; // why?? |
| 110 | 111 | checksum &= 0xf; |
| 111 | 112 | checksum ^= 0xf; |
| 112 | 113 | |
| 113 | 114 | CDD_RX[9] = checksum; |
| 114 | 115 | } |
| 115 | 116 | |
| 117 | bool lc89510_temp_device::CDD_Check_TX_Checksum(void) |
| 118 | { |
| 119 | int checksum = |
| 120 | CDD_TX[0] + |
| 121 | CDD_TX[1] + |
| 122 | CDD_TX[2] + |
| 123 | CDD_TX[3] + |
| 124 | CDD_TX[4] + |
| 125 | CDD_TX[5] + |
| 126 | CDD_TX[6] + |
| 127 | CDD_TX[7] + |
| 128 | CDD_TX[8]; |
| 129 | |
| 130 | if (is_neoCD) checksum += 0x5; // why?? |
| 131 | checksum &= 0xf; |
| 132 | checksum ^= 0xf; |
| 133 | |
| 134 | if (CDD_TX[9] == checksum) |
| 135 | return true; |
| 136 | |
| 137 | return false; |
| 138 | } |
| 139 | |
| 116 | 140 | // converts our 16-bit working regs to 8-bit regs and checksums them |
| 117 | | void lc89510_temp_device::CDD_Export(void) |
| 141 | void lc89510_temp_device::CDD_Export(bool neocd_hack) |
| 118 | 142 | { |
| 119 | | CDD_RX[0] = (CDD_STATUS & 0xff00)>>8; |
| 143 | if (!neocd_hack) |
| 144 | CDD_RX[0] = (CDD_STATUS & 0xff00)>>8; |
| 145 | else |
| 146 | CDD_RX[0] = NeoCD_StatusHack; |
| 147 | |
| 120 | 148 | CDD_RX[1] = (CDD_STATUS & 0x00ff)>>0; |
| 121 | 149 | CDD_RX[2] = (CDD_MIN & 0xff00)>>8; |
| 122 | 150 | CDD_RX[3] = (CDD_MIN & 0x00ff)>>0; |
| r19370 | r19371 | |
| 137 | 165 | |
| 138 | 166 | |
| 139 | 167 | |
| 140 | | void lc89510_temp_device::CheckCommand(running_machine& machine) |
| 141 | | { |
| 142 | | if (CDD_DONE) |
| 143 | | { |
| 144 | | CDD_DONE = 0; |
| 145 | | CDD_Export(); |
| 146 | | CHECK_SCD_LV4_INTERRUPT |
| 147 | | } |
| 148 | 168 | |
| 149 | | if (SCD_READ_ENABLED) |
| 150 | | { |
| 151 | | set_data_audio_mode(); |
| 152 | | Read_LBA_To_Buffer(machine); |
| 153 | | } |
| 154 | | } |
| 155 | | |
| 156 | | |
| 157 | 169 | void lc89510_temp_device::CDD_GetStatus(void) |
| 158 | 170 | { |
| 159 | 171 | UINT16 s = (CDD_STATUS & 0x0f00); |
| r19370 | r19371 | |
| 173 | 185 | cdda_stop_audio( m_cdda ); //stop any pending CD-DA |
| 174 | 186 | |
| 175 | 187 | //neocd |
| 176 | | NeoCDAssyStatus = 0x0E; |
| 188 | NeoCD_StatusHack = 0x0E; |
| 177 | 189 | |
| 178 | 190 | |
| 179 | 191 | } |
| r19370 | r19371 | |
| 340 | 352 | |
| 341 | 353 | // neocd |
| 342 | 354 | CDEmuStatus = seeking; |
| 343 | | NeoCDAssyStatus = 1; |
| 355 | NeoCD_StatusHack = 1; |
| 344 | 356 | |
| 345 | 357 | } |
| 346 | 358 | |
| r19370 | r19371 | |
| 372 | 384 | cdda_pause_audio( m_cdda, 1 ); |
| 373 | 385 | |
| 374 | 386 | |
| 375 | | NeoCDAssyStatus = 4; |
| 387 | NeoCD_StatusHack = 4; |
| 376 | 388 | |
| 377 | 389 | |
| 378 | 390 | } |
| r19370 | r19371 | |
| 390 | 402 | //if(!(CURRENT_TRACK_IS_DATA)) |
| 391 | 403 | cdda_pause_audio( m_cdda, 0 ); |
| 392 | 404 | |
| 393 | | NeoCDAssyStatus = 1; |
| 405 | NeoCD_StatusHack = 1; |
| 394 | 406 | } |
| 395 | 407 | |
| 396 | 408 | |
| r19370 | r19371 | |
| 437 | 449 | CDD_STATUS = SCD_STATUS; |
| 438 | 450 | |
| 439 | 451 | |
| 440 | | NeoCDAssyStatus = 9; |
| 452 | NeoCD_StatusHack = 9; |
| 441 | 453 | } |
| 442 | 454 | |
| 443 | 455 | |
| r19370 | r19371 | |
| 743 | 755 | "<undefined> (f)" // F |
| 744 | 756 | }; |
| 745 | 757 | |
| 746 | | void lc89510_temp_device::CDD_Import(running_machine& machine) |
| 758 | bool lc89510_temp_device::CDD_Import(running_machine& machine) |
| 747 | 759 | { |
| 760 | // don't execute the command if the checksum isn't valid |
| 761 | if (!CDD_Check_TX_Checksum()) |
| 762 | { |
| 763 | printf("invalid checksum\n"); |
| 764 | return false; |
| 765 | } |
| 766 | |
| 748 | 767 | if(CDD_TX[0] != 2 && CDD_TX[0] != 0) |
| 749 | 768 | printf("%s\n",CDD_import_cmdnames[CDD_TX[0]]); |
| 750 | 769 | |
| r19370 | r19371 | |
| 766 | 785 | } |
| 767 | 786 | |
| 768 | 787 | CDD_DONE = 1; |
| 788 | return true; |
| 769 | 789 | } |
| 770 | 790 | |
| 771 | 791 | |
| r19370 | r19371 | |
| 994 | 1014 | { |
| 995 | 1015 | if (!is_neoCD) |
| 996 | 1016 | { |
| 997 | | CheckCommand(machine()); |
| 1017 | if (CDD_DONE) |
| 1018 | { |
| 1019 | CDD_DONE = 0; |
| 1020 | CDD_Export(); |
| 1021 | CHECK_SCD_LV4_INTERRUPT_A |
| 1022 | } |
| 998 | 1023 | } |
| 999 | 1024 | else |
| 1000 | 1025 | { |
| 1001 | | if (nff0002 & 0x0050) { |
| 1026 | if (nff0002 & 0x0050) |
| 1027 | { |
| 1002 | 1028 | nIRQAcknowledge &= ~0x10; |
| 1003 | 1029 | NeoCDIRQUpdate(0); |
| 1004 | | |
| 1005 | | if (nff0002 & 0x0500) { |
| 1006 | | Read_LBA_To_Buffer(machine()); |
| 1007 | | } |
| 1008 | 1030 | } |
| 1009 | 1031 | } |
| 1032 | |
| 1033 | if (SCD_READ_ENABLED) // if (nff0002 & 0x0050) if (nff0002 & 0x0500); |
| 1034 | { |
| 1035 | set_data_audio_mode(); |
| 1036 | Read_LBA_To_Buffer(machine()); |
| 1037 | } |
| 1038 | |
| 1010 | 1039 | } |
| 1011 | 1040 | |
| 1012 | 1041 | |
| r19370 | r19371 | |
| 1038 | 1067 | |
| 1039 | 1068 | void lc89510_temp_device::NeoCDCommsReset() |
| 1040 | 1069 | { |
| 1041 | | bNeoCDCommsSend = false; |
| 1042 | 1070 | bNeoCDCommsClock = true; |
| 1043 | 1071 | |
| 1044 | 1072 | memset(CDD_TX, 0, sizeof(CDD_TX)); |
| r19370 | r19371 | |
| 1046 | 1074 | |
| 1047 | 1075 | NeoCDCommsWordCount = 0; |
| 1048 | 1076 | |
| 1049 | | NeoCDAssyStatus = 9; |
| 1077 | NeoCD_StatusHack = 9; |
| 1050 | 1078 | |
| 1051 | 1079 | |
| 1052 | 1080 | nff0016 = 0; |
| 1053 | 1081 | } |
| 1054 | 1082 | |
| 1055 | 1083 | |
| 1056 | | void lc89510_temp_device::NeoCDProcessCommand() |
| 1057 | | { |
| 1058 | | CDD_Import(machine()); |
| 1059 | | CDD_Export(); |
| 1060 | | } |
| 1061 | 1084 | |
| 1085 | |
| 1062 | 1086 | void lc89510_temp_device::NeoCDCommsControl(UINT8 clock, UINT8 send) |
| 1063 | 1087 | { |
| 1064 | 1088 | if (clock && !bNeoCDCommsClock) { |
| r19370 | r19371 | |
| 1066 | 1090 | if (NeoCDCommsWordCount >= 10) { |
| 1067 | 1091 | NeoCDCommsWordCount = 0; |
| 1068 | 1092 | |
| 1069 | | if (send) { |
| 1093 | if (send) |
| 1094 | { |
| 1095 | if (CDD_TX[0]) |
| 1096 | { |
| 1097 | if (!CDD_Import(machine())) |
| 1098 | return; |
| 1070 | 1099 | |
| 1071 | | // command receive complete |
| 1072 | | |
| 1073 | | if (CDD_TX[0]) { |
| 1074 | | INT32 sum = 0; |
| 1075 | | |
| 1076 | | // printf("has command %02x\n", CDD_TX[0]); |
| 1077 | | |
| 1078 | | // bprintf(PRINT_NORMAL, _T(" - CD mechanism command receive completed : 0x")); |
| 1079 | | for (INT32 i = 0; i < 9; i++) { |
| 1080 | | // bprintf(PRINT_NORMAL, _T("%X"), CDD_TX[i]); |
| 1081 | | sum += CDD_TX[i]; |
| 1082 | | } |
| 1083 | | sum = ~(sum + 5) & 0x0F; |
| 1084 | | // bprintf(PRINT_NORMAL, _T(" (CS 0x%X, %s)\n"), CDD_TX[9], (sum == CDD_TX[9]) ? _T("OK") : _T("NG")); |
| 1085 | | if (sum == CDD_TX[9]) { |
| 1086 | | |
| 1087 | | // printf("request to process command %02x\n", CDD_TX[0]); |
| 1088 | | |
| 1089 | | NeoCDProcessCommand(); |
| 1090 | | |
| 1091 | | if (CDD_TX[0]) { |
| 1092 | | |
| 1093 | | if (NeoCDAssyStatus == 1) { |
| 1094 | | if (CDEmuGetStatus() == idle) { |
| 1095 | | NeoCDAssyStatus = 0x0E; |
| 1096 | | } |
| 1097 | | } |
| 1098 | | |
| 1099 | | CDD_RX[0] = NeoCDAssyStatus; |
| 1100 | | |
| 1101 | | // compute checksum |
| 1102 | | |
| 1103 | | sum = 0; |
| 1104 | | |
| 1105 | | for (INT32 i = 0; i < 9; i++) { |
| 1106 | | sum += CDD_RX[i]; |
| 1107 | | } |
| 1108 | | CDD_RX[9] = ~(sum + 5) & 0x0F; |
| 1100 | if (NeoCD_StatusHack == 1) { |
| 1101 | if (CDEmuGetStatus() == idle) { |
| 1102 | NeoCD_StatusHack = 0x0E; |
| 1109 | 1103 | } |
| 1110 | 1104 | } |
| 1105 | |
| 1106 | CDD_Export(true); // true == neocd hack, |
| 1111 | 1107 | } |
| 1112 | | } else { |
| 1113 | 1108 | |
| 1114 | | // status send complete |
| 1115 | | |
| 1116 | | // if (CDD_RX[0] || CDD_RX[1]) { |
| 1117 | | // INT32 sum = 0; |
| 1118 | | // |
| 1119 | | // bprintf(PRINT_NORMAL, _T(" - CD mechanism status send completed : 0x")); |
| 1120 | | // for (INT32 i = 0; i < 9; i++) { |
| 1121 | | // bprintf(PRINT_NORMAL, _T("%X"), CDD_RX[i]); |
| 1122 | | // sum += CDD_RX[i]; |
| 1123 | | // } |
| 1124 | | // sum = ~(sum + 5) & 0x0F; |
| 1125 | | // bprintf(PRINT_NORMAL, _T(" (CS 0x%X, %s)\n"), CDD_RX[9], (sum == CDD_RX[9]) ? _T("OK") : _T("NG")); |
| 1126 | | // } |
| 1127 | | |
| 1128 | | // if (NeoCDAssyStatus == 0xE) { |
| 1129 | | // NeoCDAssyStatus = 9; |
| 1130 | | // } |
| 1131 | 1109 | } |
| 1132 | 1110 | |
| 1133 | 1111 | } |
| 1134 | | bNeoCDCommsSend = send; |
| 1135 | 1112 | } |
| 1136 | 1113 | bNeoCDCommsClock = clock; |
| 1137 | 1114 | } |
trunk/src/mame/machine/megacdcd.h
| r19370 | r19371 | |
| 113 | 113 | machine.device(":segacd:segacd_68k")->execute().set_input_line(4, HOLD_LINE); \ |
| 114 | 114 | } \ |
| 115 | 115 | |
| 116 | #define CHECK_SCD_LV4_INTERRUPT_A \ |
| 117 | if (segacd_irq_mask & 0x10) \ |
| 118 | { \ |
| 119 | machine().device(":segacd:segacd_68k")->execute().set_input_line(4, HOLD_LINE); \ |
| 120 | } \ |
| 116 | 121 | |
| 117 | 122 | |
| 118 | 123 | |
| 119 | | |
| 120 | 124 | #define CURRENT_TRACK_IS_DATA \ |
| 121 | 125 | (segacd.toc->tracks[SCD_CURTRK - 1].trktype != CD_TRACK_AUDIO) \ |
| 122 | 126 | |
| r19370 | r19371 | |
| 203 | 207 | inline int to_bcd(int val, bool byte); |
| 204 | 208 | void set_data_audio_mode(void); |
| 205 | 209 | void CDD_DoChecksum(void); |
| 206 | | void CDD_Export(void); |
| 210 | bool CDD_Check_TX_Checksum(void); |
| 211 | void CDD_Export(bool neocd_hack = false); |
| 207 | 212 | void scd_ctrl_checks(running_machine& machine); |
| 208 | 213 | void scd_advance_current_readpos(void); |
| 209 | 214 | int Read_LBA_To_Buffer(running_machine& machine); |
| 210 | | void CheckCommand(running_machine& machine); |
| 211 | 215 | void CDD_GetStatus(void); |
| 212 | 216 | void CDD_Stop(running_machine &machine); |
| 213 | 217 | void CDD_GetPos(void); |
| r19370 | r19371 | |
| 238 | 242 | void CDC_Reg_w(UINT8 data); |
| 239 | 243 | void CDD_Process(running_machine& machine, int reason); |
| 240 | 244 | void CDD_Handle_TOC_Commands(void); |
| 241 | | void CDD_Import(running_machine& machine); |
| 245 | bool CDD_Import(running_machine& machine); |
| 242 | 246 | READ16_MEMBER( segacd_irq_mask_r ); |
| 243 | 247 | WRITE16_MEMBER( segacd_irq_mask_w ); |
| 244 | 248 | READ16_MEMBER( segacd_cdd_ctrl_r ); |
| r19370 | r19371 | |
| 274 | 278 | |
| 275 | 279 | |
| 276 | 280 | |
| 277 | | bool bNeoCDCommsClock, bNeoCDCommsSend; |
| 281 | bool bNeoCDCommsClock; |
| 278 | 282 | |
| 279 | 283 | INT32 NeoCDCommsWordCount; |
| 280 | 284 | |
| 281 | | INT32 NeoCDAssyStatus; |
| 285 | INT32 NeoCD_StatusHack; |
| 282 | 286 | |
| 283 | 287 | |
| 284 | 288 | |
| r19370 | r19371 | |
| 290 | 294 | |
| 291 | 295 | void NeoCDIRQUpdate(UINT8 byteValue); |
| 292 | 296 | void NeoCDCommsControl(UINT8 clock, UINT8 send); |
| 293 | | void NeoCDProcessCommand(); |
| 294 | 297 | void LC8951UpdateHeader(); |
| 295 | 298 | char* LC8915InitTransfer(int NeoCDDMACount); |
| 296 | 299 | void LC8915EndTransfer(); |