fix build
[pcsx_rearmed.git] / libpcsxcore / psxcounters.c
1 /***************************************************************************
2  *   Copyright (C) 2010 by Blade_Arma                                      *
3  *                                                                         *
4  *   This program is free software; you can redistribute it and/or modify  *
5  *   it under the terms of the GNU General Public License as published by  *
6  *   the Free Software Foundation; either version 2 of the License, or     *
7  *   (at your option) any later version.                                   *
8  *                                                                         *
9  *   This program is distributed in the hope that it will be useful,       *
10  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
11  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
12  *   GNU General Public License for more details.                          *
13  *                                                                         *
14  *   You should have received a copy of the GNU General Public License     *
15  *   along with this program; if not, write to the                         *
16  *   Free Software Foundation, Inc.,                                       *
17  *   51 Franklin Street, Fifth Floor, Boston, MA 02111-1307 USA.           *
18  ***************************************************************************/
19
20 /*
21  * Internal PSX counters.
22  */
23
24 #include "psxcounters.h"
25 #include "psxevents.h"
26 #include "gpu.h"
27 //#include "debug.h"
28 #define DebugVSync()
29
30 /******************************************************************************/
31
32 enum
33 {
34     RcSyncModeEnable  = 0x0001, // 0
35     Rc01BlankPause    = 0 << 1, // 1,2
36     Rc01UnblankReset  = 1 << 1, // 1,2
37     Rc01UnblankReset2 = 2 << 1, // 1,2
38     Rc2Stop           = 0 << 1, // 1,2
39     Rc2Stop2          = 3 << 1, // 1,2
40     RcCountToTarget   = 0x0008, // 3
41     RcIrqOnTarget     = 0x0010, // 4
42     RcIrqOnOverflow   = 0x0020, // 5
43     RcIrqRegenerate   = 0x0040, // 6
44     RcUnknown7        = 0x0080, // 7    ?
45     Rc0PixelClock     = 0x0100, // 8    fake implementation
46     Rc1HSyncClock     = 0x0100, // 8
47     Rc2Unknown8       = 0x0100, // 8    ?
48     Rc0Unknown9       = 0x0200, // 9    ?
49     Rc1Unknown9       = 0x0200, // 9    ?
50     Rc2OneEighthClock = 0x0200, // 9
51     RcUnknown10       = 0x0400, // 10   ?
52     RcCountEqTarget   = 0x0800, // 11
53     RcOverflow        = 0x1000, // 12
54     RcUnknown13       = 0x2000, // 13   ? (always zero)
55     RcUnknown14       = 0x4000, // 14   ? (always zero)
56     RcUnknown15       = 0x8000, // 15   ? (always zero)
57 };
58
59 #define CounterQuantity           ( 4 )
60 //static const u32 CounterQuantity  = 4;
61
62 static const u32 CountToOverflow  = 0;
63 static const u32 CountToTarget    = 1;
64
65 static const u32 HSyncTotal[]     = { 263, 314 };
66 #define VBlankStart 240 // todo: depend on the actual GPU setting
67
68 #define VERBOSE_LEVEL 0
69
70 /******************************************************************************/
71 #ifdef DRC_DISABLE
72 Rcnt rcnts[ CounterQuantity ];
73 #endif
74 u32 hSyncCount = 0;
75 u32 frame_counter = 0;
76 static u32 hsync_steps = 0;
77
78 u32 psxNextCounter = 0, psxNextsCounter = 0;
79
80 /******************************************************************************/
81
82 static inline
83 u32 lineCycles(void)
84 {
85     if (Config.PsxType)
86         return PSXCLK / 50 / HSyncTotal[1];
87     else
88         return PSXCLK / 60 / HSyncTotal[0];
89 }
90
91 static inline
92 void setIrq( u32 irq )
93 {
94     psxHu32ref(0x1070) |= SWAPu32(irq);
95 }
96
97 static
98 void verboseLog( u32 level, const char *str, ... )
99 {
100 #if VERBOSE_LEVEL > 0
101     if( level <= VERBOSE_LEVEL )
102     {
103         va_list va;
104         char buf[ 4096 ];
105
106         va_start( va, str );
107         vsprintf( buf, str, va );
108         va_end( va );
109
110         printf( "%s", buf );
111         fflush( stdout );
112     }
113 #endif
114 }
115
116 /******************************************************************************/
117
118 static inline
119 void _psxRcntWcount( u32 index, u32 value )
120 {
121     if( value > 0xffff )
122     {
123         verboseLog( 1, "[RCNT %i] wcount > 0xffff: %x\n", index, value );
124         value &= 0xffff;
125     }
126
127     rcnts[index].cycleStart  = psxRegs.cycle;
128     rcnts[index].cycleStart -= value * rcnts[index].rate;
129
130     // TODO: <=.
131     if( value < rcnts[index].target )
132     {
133         rcnts[index].cycle = rcnts[index].target * rcnts[index].rate;
134         rcnts[index].counterState = CountToTarget;
135     }
136     else
137     {
138         rcnts[index].cycle = 0x10000 * rcnts[index].rate;
139         rcnts[index].counterState = CountToOverflow;
140     }
141 }
142
143 static inline
144 u32 _psxRcntRcount( u32 index )
145 {
146     u32 count;
147
148     count  = psxRegs.cycle;
149     count -= rcnts[index].cycleStart;
150     if (rcnts[index].rate > 1)
151         count /= rcnts[index].rate;
152
153     if( count > 0x10000 )
154     {
155         verboseLog( 1, "[RCNT %i] rcount > 0x10000: %x\n", index, count );
156     }
157     count &= 0xffff;
158
159     return count;
160 }
161
162 static
163 void _psxRcntWmode( u32 index, u32 value )
164 {
165     rcnts[index].mode = value;
166
167     switch( index )
168     {
169         case 0:
170             if( value & Rc0PixelClock )
171             {
172                 rcnts[index].rate = 5;
173             }
174             else
175             {
176                 rcnts[index].rate = 1;
177             }
178         break;
179         case 1:
180             if( value & Rc1HSyncClock )
181             {
182                 rcnts[index].rate = lineCycles();
183             }
184             else
185             {
186                 rcnts[index].rate = 1;
187             }
188         break;
189         case 2:
190             if( value & Rc2OneEighthClock )
191             {
192                 rcnts[index].rate = 8;
193             }
194             else
195             {
196                 rcnts[index].rate = 1;
197             }
198
199             // TODO: wcount must work.
200             if( (value & 7) == (RcSyncModeEnable | Rc2Stop) ||
201                 (value & 7) == (RcSyncModeEnable | Rc2Stop2) )
202             {
203                 rcnts[index].rate = 0xffffffff;
204             }
205         break;
206     }
207 }
208
209 /******************************************************************************/
210
211 static
212 void psxRcntSet()
213 {
214     s32 countToUpdate;
215     u32 i;
216
217     psxNextsCounter = psxRegs.cycle;
218     psxNextCounter  = 0x7fffffff;
219
220     for( i = 0; i < CounterQuantity; ++i )
221     {
222         countToUpdate = rcnts[i].cycle - (psxNextsCounter - rcnts[i].cycleStart);
223
224         if( countToUpdate < 0 )
225         {
226             psxNextCounter = 0;
227             break;
228         }
229
230         if( countToUpdate < (s32)psxNextCounter )
231         {
232             psxNextCounter = countToUpdate;
233         }
234     }
235
236     set_event(PSXINT_RCNT, psxNextCounter);
237 }
238
239 /******************************************************************************/
240
241 static
242 void psxRcntReset( u32 index )
243 {
244     u32 rcycles;
245
246     rcnts[index].mode |= RcUnknown10;
247
248     if( rcnts[index].counterState == CountToTarget )
249     {
250         rcycles = psxRegs.cycle - rcnts[index].cycleStart;
251         if( rcnts[index].mode & RcCountToTarget )
252         {
253             rcycles -= rcnts[index].target * rcnts[index].rate;
254             rcnts[index].cycleStart = psxRegs.cycle - rcycles;
255         }
256         else
257         {
258             rcnts[index].cycle = 0x10000 * rcnts[index].rate;
259             rcnts[index].counterState = CountToOverflow;
260         }
261
262         if( rcnts[index].mode & RcIrqOnTarget )
263         {
264             if( (rcnts[index].mode & RcIrqRegenerate) || (!rcnts[index].irqState) )
265             {
266                 verboseLog( 3, "[RCNT %i] irq\n", index );
267                 setIrq( rcnts[index].irq );
268                 rcnts[index].irqState = 1;
269             }
270         }
271
272         rcnts[index].mode |= RcCountEqTarget;
273
274         if( rcycles < 0x10000 * rcnts[index].rate )
275             return;
276     }
277
278     if( rcnts[index].counterState == CountToOverflow )
279     {
280         rcycles = psxRegs.cycle - rcnts[index].cycleStart;
281         rcycles -= 0x10000 * rcnts[index].rate;
282
283         rcnts[index].cycleStart = psxRegs.cycle - rcycles;
284
285         if( rcycles < rcnts[index].target * rcnts[index].rate )
286         {
287             rcnts[index].cycle = rcnts[index].target * rcnts[index].rate;
288             rcnts[index].counterState = CountToTarget;
289         }
290
291         if( rcnts[index].mode & RcIrqOnOverflow )
292         {
293             if( (rcnts[index].mode & RcIrqRegenerate) || (!rcnts[index].irqState) )
294             {
295                 verboseLog( 3, "[RCNT %i] irq\n", index );
296                 setIrq( rcnts[index].irq );
297                 rcnts[index].irqState = 1;
298             }
299         }
300
301         rcnts[index].mode |= RcOverflow;
302     }
303 }
304
305 static void scheduleRcntBase(void)
306 {
307     // Schedule next call, in hsyncs
308     if (hSyncCount < VBlankStart)
309         hsync_steps = VBlankStart - hSyncCount;
310     else
311         hsync_steps = HSyncTotal[Config.PsxType] - hSyncCount;
312
313     if (hSyncCount + hsync_steps == HSyncTotal[Config.PsxType])
314     {
315         rcnts[3].cycle = Config.PsxType ? PSXCLK / 50 : PSXCLK / 60;
316     }
317     else
318     {
319         // clk / 50 / 314 ~= 2157.25
320         // clk / 60 / 263 ~= 2146.31
321         u32 mult = Config.PsxType ? 8836089 : 8791293;
322         rcnts[3].cycle = hsync_steps * mult >> 12;
323     }
324 }
325
326 void psxRcntUpdate()
327 {
328     u32 cycle, cycles_passed;
329
330     cycle = psxRegs.cycle;
331
332     // rcnt 0.
333     cycles_passed = cycle - rcnts[0].cycleStart;
334     while( cycles_passed >= rcnts[0].cycle )
335     {
336         if (((rcnts[0].mode & 7) == (RcSyncModeEnable | Rc01UnblankReset) ||
337              (rcnts[0].mode & 7) == (RcSyncModeEnable | Rc01UnblankReset2))
338             && cycles_passed > lineCycles())
339         {
340             u32 q = cycles_passed / (lineCycles() + 1u);
341             rcnts[0].cycleStart += q * lineCycles();
342             break;
343         }
344         else
345             psxRcntReset( 0 );
346
347         cycles_passed = cycle - rcnts[0].cycleStart;
348     }
349
350     // rcnt 1.
351     while( cycle - rcnts[1].cycleStart >= rcnts[1].cycle )
352     {
353         psxRcntReset( 1 );
354     }
355
356     // rcnt 2.
357     while( cycle - rcnts[2].cycleStart >= rcnts[2].cycle )
358     {
359         psxRcntReset( 2 );
360     }
361
362     // rcnt base.
363     if( cycle - rcnts[3].cycleStart >= rcnts[3].cycle )
364     {
365         hSyncCount += hsync_steps;
366
367         // VSync irq.
368         if( hSyncCount == VBlankStart )
369         {
370             HW_GPU_STATUS &= SWAP32(~PSXGPU_LCF);
371             GPU_vBlank( 1, 0 );
372             setIrq( 0x01 );
373
374             EmuUpdate();
375             GPU_updateLace();
376
377             if( SPU_async )
378             {
379                 SPU_async( cycle, 1 );
380             }
381         }
382         
383         // Update lace.
384         if( hSyncCount >= HSyncTotal[Config.PsxType] )
385         {
386             u32 status, field = 0;
387             rcnts[3].cycleStart += Config.PsxType ? PSXCLK / 50 : PSXCLK / 60;
388             hSyncCount = 0;
389             frame_counter++;
390
391             gpuSyncPluginSR();
392             status = SWAP32(HW_GPU_STATUS) | PSXGPU_FIELD;
393             if ((status & PSXGPU_ILACE_BITS) == PSXGPU_ILACE_BITS) {
394                 field = frame_counter & 1;
395                 status |= field << 31;
396                 status ^= field << 13;
397             }
398             HW_GPU_STATUS = SWAP32(status);
399             GPU_vBlank(0, field);
400             if ((s32)(psxRegs.gpuIdleAfter - psxRegs.cycle) < 0)
401                 psxRegs.gpuIdleAfter = psxRegs.cycle - 1; // prevent overflow
402
403             if ((rcnts[0].mode & 7) == (RcSyncModeEnable | Rc01UnblankReset) ||
404                 (rcnts[0].mode & 7) == (RcSyncModeEnable | Rc01UnblankReset2))
405             {
406                 rcnts[0].cycleStart = rcnts[3].cycleStart;
407             }
408
409             if ((rcnts[1].mode & 7) == (RcSyncModeEnable | Rc01UnblankReset) ||
410                 (rcnts[1].mode & 7) == (RcSyncModeEnable | Rc01UnblankReset2))
411             {
412                 rcnts[1].cycleStart = rcnts[3].cycleStart;
413             }
414             else if (rcnts[1].mode & Rc1HSyncClock)
415             {
416                 // adjust to remove the rounding error
417                 _psxRcntWcount(1, (psxRegs.cycle - rcnts[1].cycleStart) / rcnts[1].rate);
418             }
419         }
420
421         scheduleRcntBase();
422     }
423
424     psxRcntSet();
425
426 #if 0 //ndef NDEBUG
427     DebugVSync();
428 #endif
429 }
430
431 /******************************************************************************/
432
433 void psxRcntWcount( u32 index, u32 value )
434 {
435     verboseLog( 2, "[RCNT %i] wcount: %x\n", index, value );
436
437     _psxRcntWcount( index, value );
438     psxRcntSet();
439 }
440
441 void psxRcntWmode( u32 index, u32 value )
442 {
443     verboseLog( 1, "[RCNT %i] wmode: %x\n", index, value );
444
445     _psxRcntWmode( index, value );
446     _psxRcntWcount( index, 0 );
447
448     rcnts[index].irqState = 0;
449     psxRcntSet();
450 }
451
452 void psxRcntWtarget( u32 index, u32 value )
453 {
454     verboseLog( 1, "[RCNT %i] wtarget: %x\n", index, value );
455
456     rcnts[index].target = value;
457
458     _psxRcntWcount( index, _psxRcntRcount( index ) );
459     psxRcntSet();
460 }
461
462 /******************************************************************************/
463
464 u32 psxRcntRcount0()
465 {
466     u32 index = 0;
467     u32 count;
468
469     if ((rcnts[0].mode & 7) == (RcSyncModeEnable | Rc01UnblankReset) ||
470         (rcnts[0].mode & 7) == (RcSyncModeEnable | Rc01UnblankReset2))
471     {
472         count = psxRegs.cycle - rcnts[index].cycleStart;
473         //count = ((16u * count) % (16u * PSXCLK / 60 / 263)) / 16u;
474         count = count % lineCycles();
475         rcnts[index].cycleStart = psxRegs.cycle - count;
476     }
477     else
478         count = _psxRcntRcount( index );
479
480     verboseLog( 2, "[RCNT 0] rcount: %04x m: %04x\n", count, rcnts[index].mode);
481
482     return count;
483 }
484
485 u32 psxRcntRcount1()
486 {
487     u32 index = 1;
488     u32 count;
489
490     count = _psxRcntRcount( index );
491
492     verboseLog( 2, "[RCNT 1] rcount: %04x m: %04x\n", count, rcnts[index].mode);
493
494     return count;
495 }
496
497 u32 psxRcntRcount2()
498 {
499     u32 index = 2;
500     u32 count;
501
502     count = _psxRcntRcount( index );
503
504     verboseLog( 2, "[RCNT 2] rcount: %04x m: %04x\n", count, rcnts[index].mode);
505
506     return count;
507 }
508
509 u32 psxRcntRmode( u32 index )
510 {
511     u16 mode;
512
513     mode = rcnts[index].mode;
514     rcnts[index].mode &= 0xe7ff;
515
516     verboseLog( 2, "[RCNT %i] rmode: %x\n", index, mode );
517
518     return mode;
519 }
520
521 u32 psxRcntRtarget( u32 index )
522 {
523     verboseLog( 2, "[RCNT %i] rtarget: %x\n", index, rcnts[index].target );
524
525     return rcnts[index].target;
526 }
527
528 /******************************************************************************/
529
530 void psxRcntInit()
531 {
532     s32 i;
533
534     // rcnt 0.
535     rcnts[0].rate   = 1;
536     rcnts[0].irq    = 0x10;
537
538     // rcnt 1.
539     rcnts[1].rate   = 1;
540     rcnts[1].irq    = 0x20;
541
542     // rcnt 2.
543     rcnts[2].rate   = 1;
544     rcnts[2].irq    = 0x40;
545
546     // rcnt base.
547     rcnts[3].rate   = 1;
548
549     for( i = 0; i < CounterQuantity; ++i )
550     {
551         _psxRcntWcount( i, 0 );
552     }
553
554     hSyncCount = 0;
555     hsync_steps = 1;
556
557     scheduleRcntBase();
558     psxRcntSet();
559 }
560
561 /******************************************************************************/
562
563 s32 psxRcntFreeze( void *f, s32 Mode )
564 {
565     u32 spuSyncCount = 0;
566     u32 count;
567     s32 i;
568
569     gzfreeze( &rcnts, sizeof(Rcnt) * CounterQuantity );
570     gzfreeze( &hSyncCount, sizeof(hSyncCount) );
571     gzfreeze( &spuSyncCount, sizeof(spuSyncCount) );
572     gzfreeze( &psxNextCounter, sizeof(psxNextCounter) );
573     gzfreeze( &psxNextsCounter, sizeof(psxNextsCounter) );
574
575     if (Mode == 0)
576     {
577         rcnts[3].rate = 1;
578         for( i = 0; i < CounterQuantity - 1; ++i )
579         {
580             _psxRcntWmode( i, rcnts[i].mode );
581             count = (psxRegs.cycle - rcnts[i].cycleStart) / rcnts[i].rate;
582             if (count > 0x1000)
583                 _psxRcntWcount( i, count & 0xffff );
584         }
585         scheduleRcntBase();
586         psxRcntSet();
587     }
588
589     return 0;
590 }
591
592 /******************************************************************************/
593 // vim:ts=4:shiftwidth=4:expandtab