![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mfp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [HATARI the Atari ST Emulator] / hatari / src|
Return to mfp.c CVS log | Up to [HATARI the Atari ST Emulator] / hatari / src |
1.1 ! root 1: /* ! 2: Hatari ! 3: ! 4: MFP - Multi Functional Peripheral. In emulation terms it's the 'chip from hell' - most differences between ! 5: a real machine and an emulator are down to this chip. It seems very simple at first but the implementation ! 6: is very difficult. The following code is the most accurate in an ST emulator to date as it is able to ! 7: perform Spectrum 512 raster effects as well as simulate the quirks found in the chip. ! 8: The easiest way to 'see' the MFP chip is to look at the diagram - this shows the main details of the chip's ! 9: behaviour with regard to interrupts and pending/service bits. ! 10: */ ! 11: ! 12: #include "main.h" ! 13: #include "debug.h" ! 14: #include "decode.h" ! 15: #include "fdc.h" ! 16: #include "ikbd.h" ! 17: #include "int.h" ! 18: #include "m68000.h" ! 19: #include "memAlloc.h" ! 20: #include "memorySnapShot.h" ! 21: #include "mfp.h" ! 22: #include "misc.h" ! 23: #include "psg.h" ! 24: #include "screen.h" ! 25: #include "shortcut.h" ! 26: #include "sound.h" ! 27: #include "stMemory.h" ! 28: #include "ymFormat.h" ! 29: #include "video.h" ! 30: #include "view.h" ! 31: ! 32: /* ! 33: MFP interrupt channel circuit:- ! 34: ! 35: EdgeRegister EnableRegister MaskRegister SBit ! 36: | | | | ! 37: | | | | ------------------------ ! 38: | | ------------------------ ---\ |---\ | | ! 39: | o--\ | | AND---o----------------AND---| S InterruptInService | ! 40: ---\ | AND---| S InterruptPending O |-------/ | |---/ | | ! 41: XOR----------)--/ | R | | | ------------------------ ! 42: Input -----/ | ------------------------ | | ! 43: | | InterruptRequest | ! 44: NOT OR | ! 45: | | | | ! 46: -------------------- --------------------------------------o--- PassVector ! 47: */ ! 48: ! 49: #define IGNORE_FDC_PRIORITY 0xff /* Set 0xff if FDC has higher priority than Keyboard/Midi, or 0x7f if not - Dragon's Breath will now work! */ ! 50: ! 51: // MFP Registers ! 52: unsigned char MFP_GPIP; // General Purpose Pins ! 53: unsigned char MFP_AER,MFP_DDR; // Active Edge Register, Data Direction Register ! 54: unsigned char MFP_IERA,MFP_IERB; // Interrupt Enable Registers A,B 0xfffa07,0xfffa09 ! 55: unsigned char MFP_IPRA,MFP_IPRB; // Interrupt Pending Registers A,B 0xfffa0b,0xfffa0d ! 56: unsigned char MFP_ISRA,MFP_ISRB; // Interrupt In-Service Registers A,B 0xfffa0f,0xfffa11 ! 57: unsigned char MFP_IMRA,MFP_IMRB; // Interrupt Mask Registers A,B 0xfffa13,0xfffa15 ! 58: unsigned char MFP_VR; // Vector Register 0xfffa17 ! 59: unsigned char MFP_TACR,MFP_TBCR,MFP_TCDCR; // Timer A,B,C+D Control Registers ! 60: unsigned char MFP_TADR,MFP_TBDR; // Timer A,B Data Registers ! 61: unsigned char MFP_TCDR,MFP_TDDR; // Timer C,D Data Registers ! 62: unsigned char MFP_TA_MAINCOUNTER; // Timer A Main Counter(internal to MFP) ! 63: unsigned char MFP_TB_MAINCOUNTER; // Timer B Main Counter ! 64: unsigned char MFP_TC_MAINCOUNTER; // Timer C Main Counter(these are temp's, set when read as) ! 65: unsigned char MFP_TD_MAINCOUNTER; // Timer D Main Counter(as done via interrupts) ! 66: ! 67: /* CPU clock cycle counts for each timer */ ! 68: int TimerAClockCycles=0; ! 69: int TimerBClockCycles=0; ! 70: int TimerCClockCycles=0; ! 71: int TimerDClockCycles=0; ! 72: ! 73: /* ! 74: Number of CPU cycles for Timer C+D ! 75: These figures were based on 50Hz=160256cycles, so 200Hz=40064 ! 76: Now, Timer C set on a delay of 192($C0) and a preset DIV of 64 is 200Hz ! 77: This makes the table entry 208.66666*192=40064(200Hz) ! 78: */ ! 79: float MFPTimerToCPUCycleTable[] = { ! 80: 0, // Timer Stop ! 81: 13.04166667f, // Div by 4 ! 82: 32.60416667f, // Div by 10 ! 83: 52.16666667f, // Div by 16 ! 84: 163.02083333f, // Div by 50 ! 85: 208.66666667f, // Div by 64 ! 86: 326.04166667f, // Div by 100 ! 87: 652.08333333f // Div by 200 ! 88: }; ! 89: ! 90: ! 91: //----------------------------------------------------------------------- ! 92: /* ! 93: Reset all MFP variables and start interrupts on their way! ! 94: */ ! 95: void MFP_Reset(void) ! 96: { ! 97: // Reset MFP internal variables ! 98: MFP_GPIP = 0xff; /* Set GPIP register (all 1's = no interrupts) */ ! 99: MFP_AER = MFP_DDR = 0; ! 100: MFP_IERA = MFP_IERB = 0; ! 101: MFP_IPRA = MFP_IPRB = 0; ! 102: MFP_ISRA = MFP_ISRB = 0; ! 103: MFP_IMRA = MFP_IMRB = 0; ! 104: MFP_VR = 0; ! 105: MFP_TACR = MFP_TBCR = MFP_TCDCR = 0; ! 106: MFP_TADR = MFP_TBDR = 0; ! 107: MFP_TCDR = MFP_TDDR = 0; ! 108: MFP_TA_MAINCOUNTER = MFP_TB_MAINCOUNTER = MFP_TC_MAINCOUNTER = MFP_TD_MAINCOUNTER = 0; ! 109: ! 110: // Clear counters ! 111: TimerAClockCycles = TimerBClockCycles = TimerCClockCycles = TimerDClockCycles = 0; ! 112: } ! 113: ! 114: //----------------------------------------------------------------------- ! 115: /* ! 116: Save/Restore snapshot of local variables('MemorySnapShot_Store' handles type) ! 117: */ ! 118: void MFP_MemorySnapShot_Capture(BOOL bSave) ! 119: { ! 120: // Save/Restore details ! 121: MemorySnapShot_Store(&MFP_GPIP,sizeof(MFP_GPIP)); ! 122: MemorySnapShot_Store(&MFP_AER,sizeof(MFP_AER)); ! 123: MemorySnapShot_Store(&MFP_DDR,sizeof(MFP_DDR)); ! 124: MemorySnapShot_Store(&MFP_IERA,sizeof(MFP_IERA)); ! 125: MemorySnapShot_Store(&MFP_IERB,sizeof(MFP_IERB)); ! 126: MemorySnapShot_Store(&MFP_IPRA,sizeof(MFP_IPRA)); ! 127: MemorySnapShot_Store(&MFP_IPRB,sizeof(MFP_IPRB)); ! 128: MemorySnapShot_Store(&MFP_ISRA,sizeof(MFP_ISRA)); ! 129: MemorySnapShot_Store(&MFP_ISRB,sizeof(MFP_ISRB)); ! 130: MemorySnapShot_Store(&MFP_IMRA,sizeof(MFP_IMRA)); ! 131: MemorySnapShot_Store(&MFP_IMRB,sizeof(MFP_IMRB)); ! 132: MemorySnapShot_Store(&MFP_VR,sizeof(MFP_VR)); ! 133: MemorySnapShot_Store(&MFP_TACR,sizeof(MFP_TACR)); ! 134: MemorySnapShot_Store(&MFP_TBCR,sizeof(MFP_TBCR)); ! 135: MemorySnapShot_Store(&MFP_TCDCR,sizeof(MFP_TCDCR)); ! 136: MemorySnapShot_Store(&MFP_TADR,sizeof(MFP_TADR)); ! 137: MemorySnapShot_Store(&MFP_TBDR,sizeof(MFP_TBDR)); ! 138: MemorySnapShot_Store(&MFP_TCDR,sizeof(MFP_TCDR)); ! 139: MemorySnapShot_Store(&MFP_TDDR,sizeof(MFP_TDDR)); ! 140: MemorySnapShot_Store(&MFP_TA_MAINCOUNTER,sizeof(MFP_TA_MAINCOUNTER)); ! 141: MemorySnapShot_Store(&MFP_TB_MAINCOUNTER,sizeof(MFP_TB_MAINCOUNTER)); ! 142: MemorySnapShot_Store(&MFP_TC_MAINCOUNTER,sizeof(MFP_TC_MAINCOUNTER)); ! 143: MemorySnapShot_Store(&MFP_TD_MAINCOUNTER,sizeof(MFP_TD_MAINCOUNTER)); ! 144: MemorySnapShot_Store(&TimerAClockCycles,sizeof(TimerAClockCycles)); ! 145: MemorySnapShot_Store(&TimerBClockCycles,sizeof(TimerBClockCycles)); ! 146: MemorySnapShot_Store(&TimerCClockCycles,sizeof(TimerCClockCycles)); ! 147: MemorySnapShot_Store(&TimerDClockCycles,sizeof(TimerDClockCycles)); ! 148: } ! 149: ! 150: //----------------------------------------------------------------------- ! 151: /* ! 152: Call MFP interrupt - NOTE when the MFP is in Auto interrupt (AEI), the MFP ! 153: puts the interrupt number on the data bus and then the 68000 reads it, multiplies ! 154: it by 4 and adds in a base(usually 0x100) to give the vector. Some programs ! 155: change this offset, eg RoboCod. This offset is stored in the top 4 bits of register ! 156: 0xfffa17(0x40 is the default=0x100) ! 157: Many thanks to Steve Bak for that one! ! 158: */ ! 159: void MFP_Exception(int Interrupt) ! 160: { ! 161: unsigned int Vec; ! 162: ! 163: Vec = (unsigned int)(MFP_VR&0xf0)<<2; ! 164: Vec += Interrupt<<2; ! 165: ExceptionVector = Vec; ! 166: M68000_Exception(); ! 167: } ! 168: ! 169: //----------------------------------------------------------------------- ! 170: /* ! 171: Test interrupt request to see if can cause exception,return TRUE if pass vector ! 172: */ ! 173: BOOL InterruptRequest(int Exception,unsigned char Bit,unsigned long EnableAddr,unsigned char *pPendingReg,unsigned char MaskRegister,unsigned char PriorityMaskLow,unsigned char PriorityMaskHigh,unsigned char *pInServiceReg) ! 174: { ! 175: // Are any higher priority interupts in service? ! 176: if ( ((MFP_ISRA&PriorityMaskLow)==0) && ((MFP_ISRB&PriorityMaskHigh)==0) ) { ! 177: // Is masked? ! 178: if (MaskRegister&Bit) { ! 179: //u if (7>FIND_IPL) { ! 180: //u *pPendingReg &= ~Bit; // Clear pending bit ! 181: //u MFP_UpdateFlags(); ! 182: //u } ! 183: ! 184: // CPU allows interrupt of an MFP level? ! 185: if (6>FIND_IPL) { ! 186: *pPendingReg &= ~Bit; // Clear pending bit ! 187: MFP_UpdateFlags(); ! 188: ! 189: // Are we in 'auto' interrupt or 'manual'? ! 190: if (MFP_VR&0x08) // Software End-of-Interrupt (SEI) ! 191: *pInServiceReg |= Bit; // Set interrupt in service register ! 192: else ! 193: *pInServiceReg &= ~Bit; // Clear interrupt in service register ! 194: ! 195: // Call interrupt, adds in base(default 0x100) ! 196: MFP_Exception(Exception); ! 197: return(TRUE); ! 198: } ! 199: } ! 200: } ! 201: ! 202: return(FALSE); ! 203: } ! 204: ! 205: //----------------------------------------------------------------------- ! 206: /* ! 207: MFP circuit has pending interrupt, request ! 208: */ ! 209: void MFP_RequestInterrupt_TimerA(void) ! 210: { ! 211: InterruptRequest(MFP_EXCEPT_TIMERA,MFP_TIMER_A_BIT,MFP_IERA,&MFP_IPRA,MFP_IMRA,0xe0,0x00&IGNORE_FDC_PRIORITY,&MFP_ISRA); ! 212: } ! 213: void MFP_RequestInterrupt_TimerB(void) ! 214: { ! 215: InterruptRequest(MFP_EXCEPT_TIMERB,MFP_TIMER_B_BIT,MFP_IERA,&MFP_IPRA,MFP_IMRA,0xff,0x00&IGNORE_FDC_PRIORITY,&MFP_ISRA); ! 216: } ! 217: void MFP_RequestInterrupt_TimerC(void) ! 218: { ! 219: InterruptRequest(MFP_EXCEPT_TIMERC,MFP_TIMER_C_BIT,MFP_IERB,&MFP_IPRB,MFP_IMRB,0xff,0xe0&IGNORE_FDC_PRIORITY,&MFP_ISRB); ! 220: } ! 221: void MFP_RequestInterrupt_TimerD(void) ! 222: { ! 223: InterruptRequest(MFP_EXCEPT_TIMERD,MFP_TIMER_D_BIT,MFP_IERB,&MFP_IPRB,MFP_IMRB,0xff,0xf0&IGNORE_FDC_PRIORITY,&MFP_ISRB); ! 224: } ! 225: void MFP_RequestInterrupt_Keyboard(void) ! 226: { ! 227: InterruptRequest(MFP_EXCEPT_KEYBOARD,MFP_KEYBOARD_BIT,MFP_IERB,&MFP_IPRB,MFP_IMRB,0xff,0xc0&IGNORE_FDC_PRIORITY,&MFP_ISRB); ! 228: } ! 229: void MFP_RequestInterrupt_Floppy(void) ! 230: { ! 231: InterruptRequest(MFP_EXCEPT_GPIP5,MFP_FDCHDC_BIT,MFP_IERB,&MFP_IPRB,MFP_IMRB,0xff,0x80&IGNORE_FDC_PRIORITY,&MFP_ISRB); ! 232: } ! 233: ! 234: //----------------------------------------------------------------------- ! 235: /* ! 236: Check 'pending' registers to see if any MFP interrupts need servicing ! 237: */ ! 238: void MFP_CheckPendingInterrupts(void) ! 239: { ! 240: unsigned short i; ! 241: ! 242: i = (MFP_IPRA<<8) | MFP_IPRB; ! 243: ! 244: if( (i&0x21f0)==0 ) ! 245: { /* Should never get here, but if do just clear flag (see 'MFP_UpdateFlags') */ ! 246: PendingInterruptFlag &= CLEAR_PENDING_INTERRUPT_FLAG_MFP; ! 247: return; ! 248: } ! 249: ! 250: if( i&0x2000 ) MFP_RequestInterrupt_TimerA(); /* Check Timer A (bit 5) */ ! 251: if( i&0x0100 ) MFP_RequestInterrupt_TimerB(); /* Check Timer B (bit 0) */ ! 252: if( i&0x0080 ) MFP_RequestInterrupt_Floppy(); /* Check FDC (bit 7) */ ! 253: if( i&0x0040 ) MFP_RequestInterrupt_Keyboard(); /* Check Keyboard (bit 6) */ ! 254: if( i&0x0020 ) MFP_RequestInterrupt_TimerC(); /* Check Timer C (bit 5) */ ! 255: if( i&0x0010 ) MFP_RequestInterrupt_TimerD(); /* Check Timer D (bit 4) */ ! 256: } ! 257: ! 258: //----------------------------------------------------------------------- ! 259: /* ! 260: This is called whenever the MFP_IPRA or MFP_IPRB registers are modified. ! 261: We set the 'PendingInterruptFlag' accordingly (to say if an MFP interrupt ! 262: is to be checked) so we only have one compare during the decode ! 263: instruction loop. ! 264: */ ! 265: void MFP_UpdateFlags(void) ! 266: { ! 267: if( MFP_IPRA|MFP_IPRB ) ! 268: { ! 269: PendingInterruptFlag |= PENDING_INTERRUPT_FLAG_MFP; ! 270: } ! 271: else ! 272: { ! 273: PendingInterruptFlag &= CLEAR_PENDING_INTERRUPT_FLAG_MFP; ! 274: } ! 275: } ! 276: ! 277: //----------------------------------------------------------------------- ! 278: /* ! 279: Interrupt Channel is active, set pending bit so can be serviced ! 280: */ ! 281: void MFP_InputOnChannel(unsigned char Bit,unsigned char EnableBit,unsigned char *pPendingReg) ! 282: { ! 283: // Input has occurred on MFP channel, set interrupt pending to request interrupt when able ! 284: if (EnableBit&Bit) ! 285: *pPendingReg |= Bit; // Set bit ! 286: else ! 287: *pPendingReg &= ~Bit; // Clear bit ! 288: MFP_UpdateFlags(); ! 289: } ! 290: ! 291: //----------------------------------------------------------------------- ! 292: /* ! 293: Generate Timer A Interrupt when in Event Count mode ! 294: */ ! 295: void MFP_TimerA_EventCount_Interrupt(void) ! 296: { ! 297: if (MFP_TA_MAINCOUNTER==1) { // Timer expired? If so, generate interrupt ! 298: MFP_TA_MAINCOUNTER = MFP_TADR; // Reload timer from data register ! 299: ! 300: // Acknowledge in MFP circuit, pass bit,enable,pending ! 301: MFP_InputOnChannel(MFP_TIMER_A_BIT,MFP_IERA,&MFP_IPRA); ! 302: } ! 303: else ! 304: MFP_TA_MAINCOUNTER--; // Subtract timer main counter ! 305: } ! 306: ! 307: //----------------------------------------------------------------------- ! 308: /* ! 309: Generate Timer B Interrupt when in Event Count mode ! 310: */ ! 311: void MFP_TimerB_EventCount_Interrupt(void) ! 312: { ! 313: if (MFP_TB_MAINCOUNTER==1) { // Timer expired? If so, generate interrupt ! 314: MFP_TB_MAINCOUNTER = MFP_TBDR; // Reload timer from data register ! 315: ! 316: // Acknowledge in MFP circuit, pass bit,enable,pending ! 317: MFP_InputOnChannel(MFP_TIMER_B_BIT,MFP_IERA,&MFP_IPRA); ! 318: } ! 319: else ! 320: MFP_TB_MAINCOUNTER--; // Subtract timer main counter ! 321: } ! 322: ! 323: //----------------------------------------------------------------------- ! 324: /* ! 325: Start Timer A or B - EventCount mode is done in HBL handler to time correctly ! 326: */ ! 327: int MFP_StartTimer_AB(unsigned char TimerControl, unsigned int TimerData, int Handler, BOOL bFirstTimer) ! 328: { ! 329: int TimerClockCycles; ! 330: ! 331: /* If we are in event-count mode ignore this(done on HBL) */ ! 332: if (TimerControl!=0x08) { ! 333: /* Find number of CPU cycles for when timer is due(include preset and counter) */ ! 334: /* As timer occurs very often we multiply by counter to speed up emulator */ ! 335: if (TimerData==0) /* Data=0 is actually Data=256 */ ! 336: TimerData = 256; ! 337: TimerClockCycles = ROUND_CYCLES_TO4( TimerData*MFPTimerToCPUCycleTable[TimerControl&0x7] ); ! 338: ! 339: /* And add to our internal interrupt list, if timer cycles is zero then timer is stopped */ ! 340: Int_RemovePendingInterrupt(Handler); ! 341: if (TimerClockCycles) { ! 342: /* Start timer from now? If not continue timer so from original offset */ ! 343: if (bFirstTimer) ! 344: nCyclesOver = 0; ! 345: Int_AddRelativeInterrupt(TimerClockCycles,Handler); ! 346: } ! 347: } ! 348: else { ! 349: /* Make sure no outstanding interrupts in list if channel is disabled */ ! 350: Int_RemovePendingInterrupt(Handler); ! 351: } ! 352: ! 353: return(TimerClockCycles); ! 354: } ! 355: ! 356: //----------------------------------------------------------------------- ! 357: /* ! 358: Start Timer C or D ! 359: */ ! 360: int MFP_StartTimer_CD(unsigned char TimerControl, unsigned int TimerData, int Handler, BOOL bFirstTimer) ! 361: { ! 362: int TimerClockCycles; ! 363: ! 364: /* Is timer on? */ ! 365: if ((TimerControl&0x7)!=0) { ! 366: /* Find number of cycles for when timer is due(include preset and counter) */ ! 367: /* As timer occurs very often we multiply by counter to speed up emulator */ ! 368: if (TimerData==0) /* Data=0 is actually Data=256 */ ! 369: TimerData = 256; ! 370: TimerClockCycles = ROUND_CYCLES_TO4( TimerData*MFPTimerToCPUCycleTable[TimerControl&0x7] ); ! 371: ! 372: /* And add to our internal interrupt list, if timer cycles is zero then timer is stopped */ ! 373: Int_RemovePendingInterrupt(Handler); ! 374: if (TimerClockCycles) { ! 375: /* Start timer from now? If not continue timer so from original offset */ ! 376: if (bFirstTimer) ! 377: nCyclesOver = 0; ! 378: Int_AddRelativeInterrupt(TimerClockCycles,Handler); ! 379: } ! 380: } ! 381: else { ! 382: /* Make sure no outstanding interrupts in list if channel is disabled */ ! 383: Int_RemovePendingInterrupt(Handler); ! 384: } ! 385: ! 386: return(TimerClockCycles); ! 387: } ! 388: ! 389: //----------------------------------------------------------------------- ! 390: /* ! 391: Read Timer A or B - If in EventCount MainCounter already has correct value ! 392: */ ! 393: unsigned char MFP_ReadTimer_AB(unsigned char TimerControl, unsigned char MainCounter, int TimerCycles, int Handler) ! 394: { ! 395: int TimerCyclesPassed; ! 396: ! 397: /* Find TimerAB count, if no interrupt assume in Event Count mode so already up-to-date as kept by HBL */ ! 398: if (Int_InterruptActive(Handler)) { ! 399: /* Find cycles passed since last interrupt */ ! 400: TimerCyclesPassed = TimerCycles-Int_FindCyclesPassed(Handler); ! 401: MainCounter = TimerCyclesPassed/(MFPTimerToCPUCycleTable[TimerControl&0x7]); ! 402: } ! 403: ! 404: return(MainCounter); ! 405: } ! 406: ! 407: //----------------------------------------------------------------------- ! 408: /* ! 409: Read Timer C or D ! 410: */ ! 411: unsigned char MFP_ReadTimerCD(unsigned char TimerControl,unsigned char TimerData, unsigned char MainCounter, int TimerCycles, int Handler) ! 412: { ! 413: int TimerCyclesPassed; ! 414: ! 415: // Find TimerCD count. If not one then timer should be off and can find count from main counter ! 416: if (Int_InterruptActive(Handler)) { ! 417: // Find cycles passed since last interrupt ! 418: TimerCyclesPassed = TimerCycles-Int_FindCyclesPassed(Handler); ! 419: MainCounter = TimerCyclesPassed/(MFPTimerToCPUCycleTable[TimerControl&0x7]); ! 420: } ! 421: else { ! 422: MainCounter = TimerData; ! 423: } ! 424: ! 425: return(MainCounter); ! 426: } ! 427: ! 428: //----------------------------------------------------------------------- ! 429: /* ! 430: Start Timer A ! 431: (This does not start the EventCount mode time as this is taken care of by the HBL) ! 432: */ ! 433: void MFP_StartTimerA(void) ! 434: { ! 435: TimerAClockCycles = MFP_StartTimer_AB(MFP_TACR,MFP_TADR,INTERRUPT_MFP_TIMERA,TRUE); ! 436: } ! 437: ! 438: ! 439: //----------------------------------------------------------------------- ! 440: /* ! 441: Read Timer A ! 442: */ ! 443: void MFP_ReadTimerA(void) ! 444: { ! 445: MFP_TA_MAINCOUNTER = MFP_ReadTimer_AB(MFP_TACR,MFP_TA_MAINCOUNTER,TimerAClockCycles,INTERRUPT_MFP_TIMERA); ! 446: } ! 447: ! 448: ! 449: //----------------------------------------------------------------------- ! 450: /* ! 451: Start Timer B ! 452: (This does not start the EventCount mode time as this is taken care of by the HBL) ! 453: */ ! 454: void MFP_StartTimerB(void) ! 455: { ! 456: TimerBClockCycles = MFP_StartTimer_AB(MFP_TBCR,MFP_TBDR,INTERRUPT_MFP_TIMERB,TRUE); ! 457: } ! 458: ! 459: ! 460: //----------------------------------------------------------------------- ! 461: /* ! 462: Read Timer B ! 463: */ ! 464: void MFP_ReadTimerB(void) ! 465: { ! 466: MFP_TB_MAINCOUNTER = MFP_ReadTimer_AB(MFP_TBCR,MFP_TB_MAINCOUNTER,TimerBClockCycles,INTERRUPT_MFP_TIMERB); ! 467: } ! 468: ! 469: ! 470: //----------------------------------------------------------------------- ! 471: /* ! 472: Start Timer C ! 473: */ ! 474: void MFP_StartTimerC(void) ! 475: { ! 476: TimerCClockCycles = MFP_StartTimer_CD(MFP_TCDCR>>4,MFP_TCDR,INTERRUPT_MFP_TIMERC,TRUE); ! 477: } ! 478: ! 479: ! 480: //----------------------------------------------------------------------- ! 481: /* ! 482: Read Timer C ! 483: */ ! 484: void MFP_ReadTimerC(void) ! 485: { ! 486: MFP_TC_MAINCOUNTER = MFP_ReadTimerCD(MFP_TCDCR>>4,MFP_TCDR,MFP_TC_MAINCOUNTER,TimerCClockCycles,INTERRUPT_MFP_TIMERC); ! 487: } ! 488: ! 489: ! 490: //----------------------------------------------------------------------- ! 491: /* ! 492: Start Timer D ! 493: */ ! 494: void MFP_StartTimerD(void) ! 495: { ! 496: TimerDClockCycles = MFP_StartTimer_CD(MFP_TCDCR,MFP_TDDR,INTERRUPT_MFP_TIMERD,TRUE); ! 497: } ! 498: ! 499: ! 500: //----------------------------------------------------------------------- ! 501: /* ! 502: Read Timer D ! 503: */ ! 504: void MFP_ReadTimerD(void) ! 505: { ! 506: MFP_TD_MAINCOUNTER = MFP_ReadTimerCD(MFP_TCDCR,MFP_TDDR,MFP_TC_MAINCOUNTER,TimerDClockCycles,INTERRUPT_MFP_TIMERD); ! 507: } ! 508: ! 509: ! 510: //----------------------------------------------------------------------- ! 511: /* ! 512: Handle Timer A Interrupt ! 513: */ ! 514: void MFP_InterruptHandler_TimerA(void) ! 515: { ! 516: // Remove this interrupt from list and re-order ! 517: Int_AcknowledgeInterrupt(); ! 518: ! 519: // Acknowledge in MFP circuit, pass bit,enable,pending ! 520: if ((MFP_TACR&0xf)!=0) // Is timer OK? ! 521: MFP_InputOnChannel(MFP_TIMER_A_BIT,MFP_IERA,&MFP_IPRA); ! 522: ! 523: // Start next interrupt, if need one - from current cycle count ! 524: TimerAClockCycles = MFP_StartTimer_AB(MFP_TACR,MFP_TADR,INTERRUPT_MFP_TIMERA,FALSE); ! 525: } ! 526: ! 527: ! 528: //----------------------------------------------------------------------- ! 529: /* ! 530: Handle Timer B Interrupt ! 531: */ ! 532: void MFP_InterruptHandler_TimerB(void) ! 533: { ! 534: // Remove this interrupt from list and re-order ! 535: Int_AcknowledgeInterrupt(); ! 536: ! 537: // Acknowledge in MFP circuit, pass bit,enable,pending ! 538: if ((MFP_TBCR&0xf)!=0) // Is timer OK? ! 539: MFP_InputOnChannel(MFP_TIMER_B_BIT,MFP_IERA,&MFP_IPRA); ! 540: ! 541: // Start next interrupt, if need one - from current cycle count ! 542: TimerBClockCycles = MFP_StartTimer_AB(MFP_TBCR,MFP_TBDR,INTERRUPT_MFP_TIMERB,FALSE); ! 543: } ! 544: ! 545: ! 546: //----------------------------------------------------------------------- ! 547: /* ! 548: Handle Timer C Interrupt ! 549: */ ! 550: void MFP_InterruptHandler_TimerC(void) ! 551: { ! 552: // Remove this interrupt from list and re-order ! 553: Int_AcknowledgeInterrupt(); ! 554: ! 555: // Acknowledge in MFP circuit, pass bit,enable,pending ! 556: if ((MFP_TCDCR&0x70)!=0) // Is timer OK? ! 557: MFP_InputOnChannel(MFP_TIMER_C_BIT,MFP_IERB,&MFP_IPRB); ! 558: ! 559: // Start next interrupt, if need one - from current cycle count ! 560: TimerCClockCycles = MFP_StartTimer_CD(MFP_TCDCR>>4,MFP_TCDR,INTERRUPT_MFP_TIMERC,FALSE); ! 561: } ! 562: ! 563: ! 564: //----------------------------------------------------------------------- ! 565: /* ! 566: Handle Timer D Interrupt ! 567: */ ! 568: void MFP_InterruptHandler_TimerD(void) ! 569: { ! 570: // Remove this interrupt from list and re-order ! 571: Int_AcknowledgeInterrupt(); ! 572: ! 573: // Acknowledge in MFP circuit, pass bit,enable,pending ! 574: if ((MFP_TCDCR&0x07)!=0) // Is timer OK? ! 575: MFP_InputOnChannel(MFP_TIMER_D_BIT,MFP_IERB,&MFP_IPRB); ! 576: ! 577: // Start next interrupt, if need one - from current cycle count ! 578: TimerDClockCycles = MFP_StartTimer_CD(MFP_TCDCR,MFP_TDDR,INTERRUPT_MFP_TIMERD,FALSE); ! 579: } ! 580:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.