d31795711ac4f99e2d62116cdc47546c3a8fcbb5
[profile/ivi/intel-emgd-kmod.git] / pvr / tools / intern / debug / dbgdriv / common / dbgdriv.c
1 /**********************************************************************
2  Copyright (c) Imagination Technologies Ltd.
3
4  Permission is hereby granted, free of charge, to any person obtaining a copy
5  of this software and associated documentation files (the "Software"), to deal
6  in the Software without restriction, including without limitation the rights
7  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8  copies of the Software, and to permit persons to whom the Software is
9  furnished to do so, subject to the following conditions:
10
11  The above copyright notice and this permission notice shall be included in
12  all copies or substantial portions of the Software.
13
14  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
20  THE SOFTWARE.
21  ******************************************************************************/
22
23
24 #ifdef LINUX
25 #include <linux/string.h>
26 #endif
27
28 #include "img_types.h"
29 #include "pvr_debug.h"
30 #include "dbgdrvif.h"
31 #include "dbgdriv.h"
32 #include "hotkey.h"
33 #include "hostfunc.h"
34
35
36
37
38 #define LAST_FRAME_BUF_SIZE     1024
39
40 typedef struct _DBG_LASTFRAME_BUFFER_
41 {
42         PDBG_STREAM     psStream;
43         IMG_UINT8 ui8Buffer[LAST_FRAME_BUF_SIZE];
44         IMG_UINT32              ui32BufLen;
45         struct _DBG_LASTFRAME_BUFFER_   *psNext;
46 } *PDBG_LASTFRAME_BUFFER;
47
48
49 static PDBG_STREAM      g_psStreamList = 0;
50 static PDBG_LASTFRAME_BUFFER    g_psLFBufferList;
51
52 static IMG_UINT32               g_ui32LOff = 0;
53 static IMG_UINT32               g_ui32Line = 0;
54 static IMG_UINT32               g_ui32MonoLines = 25;
55
56 static IMG_BOOL                 g_bHotkeyMiddump = IMG_FALSE;
57 static IMG_UINT32               g_ui32HotkeyMiddumpStart = 0xffffffff;
58 static IMG_UINT32               g_ui32HotkeyMiddumpEnd = 0xffffffff;
59
60 IMG_VOID *                              g_pvAPIMutex=IMG_NULL;
61
62 extern IMG_UINT32               g_ui32HotKeyFrame;
63 extern IMG_BOOL                 g_bHotKeyPressed;
64 extern IMG_BOOL                 g_bHotKeyRegistered;
65
66 IMG_BOOL                                gbDumpThisFrame = IMG_FALSE;
67
68
69 IMG_UINT32 SpaceInStream(PDBG_STREAM psStream);
70 IMG_BOOL ExpandStreamBuffer(PDBG_STREAM psStream, IMG_UINT32 ui32NewSize);
71 PDBG_LASTFRAME_BUFFER FindLFBuf(PDBG_STREAM psStream);
72
73 DBGKM_SERVICE_TABLE g_sDBGKMServices =
74 {
75         sizeof (DBGKM_SERVICE_TABLE),
76         ExtDBGDrivCreateStream,
77         ExtDBGDrivDestroyStream,
78         ExtDBGDrivFindStream,
79         ExtDBGDrivWriteString,
80         ExtDBGDrivReadString,
81         ExtDBGDrivWrite,
82         ExtDBGDrivRead,
83         ExtDBGDrivSetCaptureMode,
84         ExtDBGDrivSetOutputMode,
85         ExtDBGDrivSetDebugLevel,
86         ExtDBGDrivSetFrame,
87         ExtDBGDrivGetFrame,
88         ExtDBGDrivOverrideMode,
89         ExtDBGDrivDefaultMode,
90         ExtDBGDrivWrite2,
91         ExtDBGDrivWriteStringCM,
92         ExtDBGDrivWriteCM,
93         ExtDBGDrivSetMarker,
94         ExtDBGDrivGetMarker,
95         ExtDBGDrivStartInitPhase,
96         ExtDBGDrivStopInitPhase,
97         ExtDBGDrivIsCaptureFrame,
98         ExtDBGDrivWriteLF,
99         ExtDBGDrivReadLF,
100         ExtDBGDrivGetStreamOffset,
101         ExtDBGDrivSetStreamOffset,
102         ExtDBGDrivIsLastCaptureFrame,
103         ExtDBGDrivWaitForEvent
104 };
105
106
107
108
109
110 IMG_VOID * IMG_CALLCONV ExtDBGDrivCreateStream(IMG_CHAR *       pszName, IMG_UINT32 ui32CapMode, IMG_UINT32     ui32OutMode, IMG_UINT32 ui32Flags, IMG_UINT32 ui32Size)
111 {
112         IMG_VOID *      pvRet;
113
114
115         HostAquireMutex(g_pvAPIMutex);
116
117         pvRet=DBGDrivCreateStream(pszName, ui32CapMode, ui32OutMode, ui32Flags, ui32Size);
118
119
120         HostReleaseMutex(g_pvAPIMutex);
121
122         return pvRet;
123 }
124
125 void IMG_CALLCONV ExtDBGDrivDestroyStream(PDBG_STREAM psStream)
126 {
127
128         HostAquireMutex(g_pvAPIMutex);
129
130         DBGDrivDestroyStream(psStream);
131
132
133         HostReleaseMutex(g_pvAPIMutex);
134
135         return;
136 }
137
138 IMG_VOID * IMG_CALLCONV ExtDBGDrivFindStream(IMG_CHAR * pszName, IMG_BOOL bResetStream)
139 {
140         IMG_VOID *      pvRet;
141
142
143         HostAquireMutex(g_pvAPIMutex);
144
145         pvRet=DBGDrivFindStream(pszName, bResetStream);
146
147
148         HostReleaseMutex(g_pvAPIMutex);
149
150         return pvRet;
151 }
152
153 IMG_UINT32 IMG_CALLCONV ExtDBGDrivWriteString(PDBG_STREAM psStream,IMG_CHAR * pszString,IMG_UINT32 ui32Level)
154 {
155         IMG_UINT32      ui32Ret;
156
157
158         HostAquireMutex(g_pvAPIMutex);
159
160         ui32Ret=DBGDrivWriteString(psStream, pszString, ui32Level);
161
162
163         HostReleaseMutex(g_pvAPIMutex);
164
165         return ui32Ret;
166 }
167
168 IMG_UINT32 IMG_CALLCONV ExtDBGDrivReadString(PDBG_STREAM psStream,IMG_CHAR * pszString,IMG_UINT32 ui32Limit)
169 {
170         IMG_UINT32 ui32Ret;
171
172
173         HostAquireMutex(g_pvAPIMutex);
174
175         ui32Ret=DBGDrivReadString(psStream, pszString, ui32Limit);
176
177
178         HostReleaseMutex(g_pvAPIMutex);
179
180         return ui32Ret;
181 }
182
183 IMG_UINT32 IMG_CALLCONV ExtDBGDrivWrite(PDBG_STREAM psStream,IMG_UINT8 * pui8InBuf,IMG_UINT32 ui32InBuffSize,IMG_UINT32 ui32Level)
184 {
185         IMG_UINT32      ui32Ret;
186
187
188         HostAquireMutex(g_pvAPIMutex);
189
190         ui32Ret=DBGDrivWrite(psStream, pui8InBuf, ui32InBuffSize, ui32Level);
191
192
193         HostReleaseMutex(g_pvAPIMutex);
194
195         return ui32Ret;
196 }
197
198 IMG_UINT32 IMG_CALLCONV ExtDBGDrivRead(PDBG_STREAM psStream, IMG_BOOL bReadInitBuffer, IMG_UINT32 ui32OutBuffSize,IMG_UINT8 * pui8OutBuf)
199 {
200         IMG_UINT32 ui32Ret;
201
202
203         HostAquireMutex(g_pvAPIMutex);
204
205         ui32Ret=DBGDrivRead(psStream, bReadInitBuffer, ui32OutBuffSize, pui8OutBuf);
206
207
208         HostReleaseMutex(g_pvAPIMutex);
209
210         return ui32Ret;
211 }
212
213 void IMG_CALLCONV ExtDBGDrivSetCaptureMode(PDBG_STREAM psStream,IMG_UINT32 ui32Mode,IMG_UINT32 ui32Start,IMG_UINT32 ui32End,IMG_UINT32 ui32SampleRate)
214 {
215
216         HostAquireMutex(g_pvAPIMutex);
217
218         DBGDrivSetCaptureMode(psStream, ui32Mode, ui32Start, ui32End, ui32SampleRate);
219
220
221         HostReleaseMutex(g_pvAPIMutex);
222
223         return;
224 }
225
226 void IMG_CALLCONV ExtDBGDrivSetOutputMode(PDBG_STREAM psStream,IMG_UINT32 ui32OutMode)
227 {
228
229         HostAquireMutex(g_pvAPIMutex);
230
231         DBGDrivSetOutputMode(psStream, ui32OutMode);
232
233
234         HostReleaseMutex(g_pvAPIMutex);
235
236         return;
237 }
238
239 void IMG_CALLCONV ExtDBGDrivSetDebugLevel(PDBG_STREAM psStream,IMG_UINT32 ui32DebugLevel)
240 {
241
242         HostAquireMutex(g_pvAPIMutex);
243
244         DBGDrivSetDebugLevel(psStream, ui32DebugLevel);
245
246
247         HostReleaseMutex(g_pvAPIMutex);
248
249         return;
250 }
251
252 void IMG_CALLCONV ExtDBGDrivSetFrame(PDBG_STREAM psStream,IMG_UINT32 ui32Frame)
253 {
254
255         HostAquireMutex(g_pvAPIMutex);
256
257         DBGDrivSetFrame(psStream, ui32Frame);
258
259
260         HostReleaseMutex(g_pvAPIMutex);
261
262         return;
263 }
264
265 IMG_UINT32 IMG_CALLCONV ExtDBGDrivGetFrame(PDBG_STREAM psStream)
266 {
267         IMG_UINT32      ui32Ret;
268
269
270         HostAquireMutex(g_pvAPIMutex);
271
272         ui32Ret=DBGDrivGetFrame(psStream);
273
274
275         HostReleaseMutex(g_pvAPIMutex);
276
277         return ui32Ret;
278 }
279
280 IMG_BOOL IMG_CALLCONV ExtDBGDrivIsLastCaptureFrame(PDBG_STREAM psStream)
281 {
282         IMG_BOOL        bRet;
283
284
285         HostAquireMutex(g_pvAPIMutex);
286
287         bRet = DBGDrivIsLastCaptureFrame(psStream);
288
289
290         HostReleaseMutex(g_pvAPIMutex);
291
292         return bRet;
293 }
294
295 IMG_BOOL IMG_CALLCONV ExtDBGDrivIsCaptureFrame(PDBG_STREAM psStream, IMG_BOOL bCheckPreviousFrame)
296 {
297         IMG_BOOL        bRet;
298
299
300         HostAquireMutex(g_pvAPIMutex);
301
302         bRet = DBGDrivIsCaptureFrame(psStream, bCheckPreviousFrame);
303
304
305         HostReleaseMutex(g_pvAPIMutex);
306
307         return bRet;
308 }
309
310 void IMG_CALLCONV ExtDBGDrivOverrideMode(PDBG_STREAM psStream,IMG_UINT32 ui32Mode)
311 {
312
313         HostAquireMutex(g_pvAPIMutex);
314
315         DBGDrivOverrideMode(psStream, ui32Mode);
316
317
318         HostReleaseMutex(g_pvAPIMutex);
319
320         return;
321 }
322
323 void IMG_CALLCONV ExtDBGDrivDefaultMode(PDBG_STREAM psStream)
324 {
325
326         HostAquireMutex(g_pvAPIMutex);
327
328         DBGDrivDefaultMode(psStream);
329
330
331         HostReleaseMutex(g_pvAPIMutex);
332
333         return;
334 }
335
336 IMG_UINT32 IMG_CALLCONV ExtDBGDrivWrite2(PDBG_STREAM psStream,IMG_UINT8 * pui8InBuf,IMG_UINT32 ui32InBuffSize,IMG_UINT32 ui32Level)
337 {
338         IMG_UINT32      ui32Ret;
339
340
341         HostAquireMutex(g_pvAPIMutex);
342
343         ui32Ret=DBGDrivWrite2(psStream, pui8InBuf, ui32InBuffSize, ui32Level);
344
345
346         HostReleaseMutex(g_pvAPIMutex);
347
348         return ui32Ret;
349 }
350
351 IMG_UINT32 IMG_CALLCONV ExtDBGDrivWriteStringCM(PDBG_STREAM psStream,IMG_CHAR * pszString,IMG_UINT32 ui32Level)
352 {
353         IMG_UINT32      ui32Ret;
354
355
356         HostAquireMutex(g_pvAPIMutex);
357
358         ui32Ret=DBGDrivWriteStringCM(psStream, pszString, ui32Level);
359
360
361         HostReleaseMutex(g_pvAPIMutex);
362
363         return ui32Ret;
364 }
365
366 IMG_UINT32 IMG_CALLCONV ExtDBGDrivWriteCM(PDBG_STREAM psStream,IMG_UINT8 * pui8InBuf,IMG_UINT32 ui32InBuffSize,IMG_UINT32 ui32Level)
367 {
368         IMG_UINT32      ui32Ret;
369
370
371         HostAquireMutex(g_pvAPIMutex);
372
373         ui32Ret=DBGDrivWriteCM(psStream, pui8InBuf, ui32InBuffSize, ui32Level);
374
375
376         HostReleaseMutex(g_pvAPIMutex);
377
378         return ui32Ret;
379 }
380
381 void IMG_CALLCONV ExtDBGDrivSetMarker(PDBG_STREAM psStream, IMG_UINT32 ui32Marker)
382 {
383
384         HostAquireMutex(g_pvAPIMutex);
385
386         DBGDrivSetMarker(psStream, ui32Marker);
387
388
389         HostReleaseMutex(g_pvAPIMutex);
390
391         return;
392 }
393
394 IMG_UINT32 IMG_CALLCONV ExtDBGDrivGetMarker(PDBG_STREAM psStream)
395 {
396         IMG_UINT32      ui32Marker;
397
398
399         HostAquireMutex(g_pvAPIMutex);
400
401         ui32Marker = DBGDrivGetMarker(psStream);
402
403
404         HostReleaseMutex(g_pvAPIMutex);
405
406         return ui32Marker;
407 }
408
409 IMG_UINT32 IMG_CALLCONV ExtDBGDrivWriteLF(PDBG_STREAM psStream, IMG_UINT8 * pui8InBuf, IMG_UINT32 ui32InBuffSize, IMG_UINT32 ui32Level, IMG_UINT32 ui32Flags)
410 {
411         IMG_UINT32      ui32Ret;
412
413
414         HostAquireMutex(g_pvAPIMutex);
415
416         ui32Ret = DBGDrivWriteLF(psStream, pui8InBuf, ui32InBuffSize, ui32Level, ui32Flags);
417
418
419         HostReleaseMutex(g_pvAPIMutex);
420
421         return ui32Ret;
422 }
423
424 IMG_UINT32 IMG_CALLCONV ExtDBGDrivReadLF(PDBG_STREAM psStream, IMG_UINT32 ui32OutBuffSize, IMG_UINT8 * pui8OutBuf)
425 {
426         IMG_UINT32 ui32Ret;
427
428
429         HostAquireMutex(g_pvAPIMutex);
430
431         ui32Ret = DBGDrivReadLF(psStream, ui32OutBuffSize, pui8OutBuf);
432
433
434         HostReleaseMutex(g_pvAPIMutex);
435
436         return ui32Ret;
437 }
438
439
440 IMG_VOID IMG_CALLCONV ExtDBGDrivStartInitPhase(PDBG_STREAM psStream)
441 {
442
443         HostAquireMutex(g_pvAPIMutex);
444
445         DBGDrivStartInitPhase(psStream);
446
447
448         HostReleaseMutex(g_pvAPIMutex);
449
450         return;
451 }
452
453 IMG_VOID IMG_CALLCONV ExtDBGDrivStopInitPhase(PDBG_STREAM psStream)
454 {
455
456         HostAquireMutex(g_pvAPIMutex);
457
458         DBGDrivStopInitPhase(psStream);
459
460
461         HostReleaseMutex(g_pvAPIMutex);
462
463         return;
464 }
465
466 IMG_UINT32 IMG_CALLCONV ExtDBGDrivGetStreamOffset(PDBG_STREAM psStream)
467 {
468         IMG_UINT32 ui32Ret;
469
470
471         HostAquireMutex(g_pvAPIMutex);
472
473         ui32Ret = DBGDrivGetStreamOffset(psStream);
474
475
476         HostReleaseMutex(g_pvAPIMutex);
477
478         return ui32Ret;
479 }
480
481 IMG_VOID IMG_CALLCONV ExtDBGDrivSetStreamOffset(PDBG_STREAM psStream, IMG_UINT32 ui32StreamOffset)
482 {
483
484         HostAquireMutex(g_pvAPIMutex);
485
486         DBGDrivSetStreamOffset(psStream, ui32StreamOffset);
487
488
489         HostReleaseMutex(g_pvAPIMutex);
490 }
491
492 IMG_VOID IMG_CALLCONV ExtDBGDrivWaitForEvent(DBG_EVENT eEvent)
493 {
494 #if defined(SUPPORT_DBGDRV_EVENT_OBJECTS)
495         DBGDrivWaitForEvent(eEvent);
496 #else
497         PVR_UNREFERENCED_PARAMETER(eEvent);
498 #endif
499 }
500
501 IMG_UINT32 AtoI(IMG_CHAR *szIn)
502 {
503         IMG_INT         iLen = 0;
504         IMG_UINT32      ui32Value = 0;
505         IMG_UINT32      ui32Digit=1;
506         IMG_UINT32      ui32Base=10;
507         IMG_INT         iPos;
508         IMG_CHAR        bc;
509
510
511         while (szIn[iLen] > 0)
512         {
513                 iLen ++;
514         }
515
516
517         if (iLen == 0)
518         {
519                 return (0);
520         }
521
522
523         iPos=0;
524         while (szIn[iPos] == '0')
525         {
526                 iPos++;
527         }
528         if (szIn[iPos] == '\0')
529         {
530                 return 0;
531         }
532         if (szIn[iPos] == 'x' || szIn[iPos] == 'X')
533         {
534                 ui32Base=16;
535                 szIn[iPos]='0';
536         }
537
538
539         for (iPos = iLen - 1; iPos >= 0; iPos --)
540         {
541                 bc = szIn[iPos];
542
543                 if ( (bc >= 'a') && (bc <= 'f') && ui32Base == 16)
544                 {
545                         bc -= 'a' - 0xa;
546                 }
547                 else
548                 if ( (bc >= 'A') && (bc <= 'F') && ui32Base == 16)
549                 {
550                         bc -= 'A' - 0xa;
551                 }
552                 else
553                 if ((bc >= '0') && (bc <= '9'))
554                 {
555                         bc -= '0';
556                 }
557                 else
558                         return (0);
559
560                 ui32Value += (IMG_UINT32)bc  * ui32Digit;
561
562                 ui32Digit = ui32Digit * ui32Base;
563         }
564         return (ui32Value);
565 }
566
567
568 IMG_BOOL StreamValid(PDBG_STREAM psStream)
569 {
570         PDBG_STREAM     psThis;
571
572         psThis = g_psStreamList;
573
574         while (psThis)
575         {
576                 if (psStream && (psThis == psStream))
577                 {
578                         return(IMG_TRUE);
579                 }
580                 else
581                 {
582                         psThis = psThis->psNext;
583                 }
584         }
585
586         return(IMG_FALSE);
587 }
588
589
590 void Write(PDBG_STREAM psStream,IMG_UINT8 * pui8Data,IMG_UINT32 ui32InBuffSize)
591 {
592
593
594         if ((psStream->ui32WPtr + ui32InBuffSize) > psStream->ui32Size)
595         {
596                 IMG_UINT32 ui32B1 = psStream->ui32Size - psStream->ui32WPtr;
597                 IMG_UINT32 ui32B2 = ui32InBuffSize - ui32B1;
598
599
600                 HostMemCopy((IMG_VOID *)(psStream->ui32Base + psStream->ui32WPtr),
601                                 (IMG_VOID *) pui8Data,
602                                 ui32B1);
603
604
605                 HostMemCopy((IMG_VOID *)psStream->ui32Base,
606                                 (IMG_VOID *)((IMG_UINT32) pui8Data + ui32B1),
607                                 ui32B2);
608
609
610                 psStream->ui32WPtr = ui32B2;
611         }
612         else
613         {
614                 HostMemCopy((IMG_VOID *)(psStream->ui32Base + psStream->ui32WPtr),
615                                 (IMG_VOID *) pui8Data,
616                                 ui32InBuffSize);
617
618                 psStream->ui32WPtr += ui32InBuffSize;
619
620                 if (psStream->ui32WPtr == psStream->ui32Size)
621                 {
622                         psStream->ui32WPtr = 0;
623                 }
624         }
625         psStream->ui32DataWritten += ui32InBuffSize;
626 }
627
628
629 void MonoOut(IMG_CHAR * pszString,IMG_BOOL bNewLine)
630 {
631         IMG_UINT32      i;
632         IMG_CHAR *      pScreen;
633
634         pScreen = (IMG_CHAR *) DBGDRIV_MONOBASE;
635
636         pScreen += g_ui32Line * 160;
637
638
639
640         i=0;
641         do
642         {
643                 pScreen[g_ui32LOff + (i*2)] = pszString[i];
644                 pScreen[g_ui32LOff + (i*2)+1] = 127;
645                 i++;
646         }
647         while ((pszString[i] != 0) && (i < 4096));
648
649         g_ui32LOff += i * 2;
650
651         if (bNewLine)
652         {
653                 g_ui32LOff = 0;
654                 g_ui32Line++;
655         }
656
657
658
659         if (g_ui32Line == g_ui32MonoLines)
660         {
661                 g_ui32Line = g_ui32MonoLines - 1;
662
663                 HostMemCopy((IMG_VOID *)DBGDRIV_MONOBASE,(IMG_VOID *)(DBGDRIV_MONOBASE + 160),160 * (g_ui32MonoLines - 1));
664
665                 HostMemSet((IMG_VOID *)(DBGDRIV_MONOBASE + (160 * (g_ui32MonoLines - 1))),0,160);
666         }
667 }
668
669
670
671 void AppendName(IMG_CHAR * pszOut,IMG_CHAR * pszBase,IMG_CHAR * pszName)
672 {
673         IMG_UINT32 i;
674         IMG_UINT32 ui32Off;
675
676         i = 0;
677
678         while (pszBase[i] != 0)
679         {
680                 pszOut[i] = pszBase[i];
681                 i++;
682         }
683
684         ui32Off = i;
685         i = 0;
686
687         while (pszName[i] != 0)
688         {
689                 pszOut[ui32Off+i] = pszName[i];
690                 i++;
691         }
692
693         pszOut[ui32Off+i] = pszName[i];
694 }
695
696
697 IMG_VOID * IMG_CALLCONV DBGDrivCreateStream(IMG_CHAR *          pszName,
698                                                                    IMG_UINT32   ui32CapMode,
699                                                                    IMG_UINT32   ui32OutMode,
700                                                                    IMG_UINT32   ui32Flags,
701                                                                    IMG_UINT32   ui32Size)
702 {
703         PDBG_STREAM     psStream;
704         PDBG_STREAM     psInitStream;
705         PDBG_LASTFRAME_BUFFER   psLFBuffer;
706         IMG_UINT32              ui32Off;
707         IMG_VOID *              pvBase;
708
709
710
711
712         psStream = (PDBG_STREAM) DBGDrivFindStream(pszName, IMG_FALSE);
713
714         if (psStream)
715         {
716                 return ((IMG_VOID *) psStream);
717         }
718
719
720
721         psStream = HostNonPageablePageAlloc(1);
722         psInitStream = HostNonPageablePageAlloc(1);
723         psLFBuffer = HostNonPageablePageAlloc(1);
724         if      (
725                         (!psStream) ||
726                         (!psInitStream) ||
727                         (!psLFBuffer)
728                 )
729         {
730                 PVR_DPF((PVR_DBG_ERROR,"DBGDriv: Couldn't alloc control structs\n\r"));
731                 return((IMG_VOID *) 0);
732         }
733
734
735         if ((ui32Flags & DEBUG_FLAGS_USE_NONPAGED_MEM) != 0)
736         {
737                 pvBase = HostNonPageablePageAlloc(ui32Size);
738         }
739         else
740         {
741                 pvBase = HostPageablePageAlloc(ui32Size);
742         }
743
744         if (!pvBase)
745         {
746                 PVR_DPF((PVR_DBG_ERROR,"DBGDriv: Couldn't alloc Stream buffer\n\r"));
747                 HostNonPageablePageFree(psStream);
748                 return((IMG_VOID *) 0);
749         }
750
751
752
753         psStream->psNext = 0;
754         psStream->ui32Flags = ui32Flags;
755         psStream->ui32Base = (IMG_UINT32)pvBase;
756         psStream->ui32Size = ui32Size * 4096UL;
757         psStream->ui32RPtr = 0;
758         psStream->ui32WPtr = 0;
759         psStream->ui32DataWritten = 0;
760         psStream->ui32CapMode = ui32CapMode;
761         psStream->ui32OutMode = ui32OutMode;
762         psStream->ui32DebugLevel = DEBUG_LEVEL_0;
763         psStream->ui32DefaultMode = ui32CapMode;
764         psStream->ui32Start = 0;
765         psStream->ui32End = 0;
766         psStream->ui32Current = 0;
767         psStream->ui32SampleRate = 1;
768         psStream->ui32Access = 0;
769         psStream->ui32Timeout = 0;
770         psStream->ui32Marker = 0;
771         psStream->bInitPhaseComplete = IMG_FALSE;
772
773
774         if ((ui32Flags & DEBUG_FLAGS_USE_NONPAGED_MEM) != 0)
775         {
776                 pvBase = HostNonPageablePageAlloc(ui32Size);
777         }
778         else
779         {
780                 pvBase = HostPageablePageAlloc(ui32Size);
781         }
782
783         if (!pvBase)
784         {
785                 PVR_DPF((PVR_DBG_ERROR,"DBGDriv: Couldn't alloc InitStream buffer\n\r"));
786
787                 if ((psStream->ui32Flags & DEBUG_FLAGS_USE_NONPAGED_MEM) != 0)
788                 {
789                         HostNonPageablePageFree((IMG_VOID *)psStream->ui32Base);
790                 }
791                 else
792                 {
793                         HostPageablePageFree((IMG_VOID *)psStream->ui32Base);
794                 }
795                 HostNonPageablePageFree(psStream);
796                 return((IMG_VOID *) 0);
797         }
798
799         psInitStream->psNext = 0;
800         psInitStream->ui32Flags = ui32Flags;
801         psInitStream->ui32Base = (IMG_UINT32)pvBase;
802         psInitStream->ui32Size = ui32Size * 4096UL;
803         psInitStream->ui32RPtr = 0;
804         psInitStream->ui32WPtr = 0;
805         psInitStream->ui32DataWritten = 0;
806         psInitStream->ui32CapMode = ui32CapMode;
807         psInitStream->ui32OutMode = ui32OutMode;
808         psInitStream->ui32DebugLevel = DEBUG_LEVEL_0;
809         psInitStream->ui32DefaultMode = ui32CapMode;
810         psInitStream->ui32Start = 0;
811         psInitStream->ui32End = 0;
812         psInitStream->ui32Current = 0;
813         psInitStream->ui32SampleRate = 1;
814         psInitStream->ui32Access = 0;
815         psInitStream->ui32Timeout = 0;
816         psInitStream->ui32Marker = 0;
817         psInitStream->bInitPhaseComplete = IMG_FALSE;
818
819         psStream->psInitStream = psInitStream;
820
821
822         psLFBuffer->psStream = psStream;
823         psLFBuffer->ui32BufLen = 0UL;
824
825         g_bHotkeyMiddump = IMG_FALSE;
826         g_ui32HotkeyMiddumpStart = 0xffffffffUL;
827         g_ui32HotkeyMiddumpEnd = 0xffffffffUL;
828
829
830
831         ui32Off = 0;
832
833         do
834         {
835                 psStream->szName[ui32Off] = pszName[ui32Off];
836
837                 ui32Off++;
838         }
839         while ((pszName[ui32Off] != 0) && (ui32Off < (4096UL - sizeof(DBG_STREAM))));
840
841         psStream->szName[ui32Off] = pszName[ui32Off];
842
843
844
845         psStream->psNext = g_psStreamList;
846         g_psStreamList = psStream;
847
848         psLFBuffer->psNext = g_psLFBufferList;
849         g_psLFBufferList = psLFBuffer;
850
851
852         return((IMG_VOID *) psStream);
853 }
854
855 void IMG_CALLCONV DBGDrivDestroyStream(PDBG_STREAM psStream)
856 {
857         PDBG_STREAM     psStreamThis;
858         PDBG_STREAM     psStreamPrev;
859         PDBG_LASTFRAME_BUFFER   psLFBuffer;
860         PDBG_LASTFRAME_BUFFER   psLFThis;
861         PDBG_LASTFRAME_BUFFER   psLFPrev;
862
863         PVR_DPF((PVR_DBG_MESSAGE, "DBGDriv: Destroying stream %s\r\n", psStream->szName ));
864
865
866
867         if (!StreamValid(psStream))
868         {
869                 return;
870         }
871
872         psLFBuffer = FindLFBuf(psStream);
873
874
875
876         psStreamThis = g_psStreamList;
877         psStreamPrev = 0;
878
879         while (psStreamThis)
880         {
881                 if (psStreamThis == psStream)
882                 {
883                         if (psStreamPrev)
884                         {
885                                 psStreamPrev->psNext = psStreamThis->psNext;
886                         }
887                         else
888                         {
889                                 g_psStreamList = psStreamThis->psNext;
890                         }
891
892                         psStreamThis = 0;
893                 }
894                 else
895                 {
896                         psStreamPrev = psStreamThis;
897                         psStreamThis = psStreamThis->psNext;
898                 }
899         }
900
901         psLFThis = g_psLFBufferList;
902         psLFPrev = 0;
903
904         while (psLFThis)
905         {
906                 if (psLFThis == psLFBuffer)
907                 {
908                         if (psLFPrev)
909                         {
910                                 psLFPrev->psNext = psLFThis->psNext;
911                         }
912                         else
913                         {
914                                 g_psLFBufferList = psLFThis->psNext;
915                         }
916
917                         psLFThis = 0;
918                 }
919                 else
920                 {
921                         psLFPrev = psLFThis;
922                         psLFThis = psLFThis->psNext;
923                 }
924         }
925
926
927         if (psStream->ui32CapMode & DEBUG_CAPMODE_HOTKEY)
928         {
929                 DeactivateHotKeys();
930         }
931
932
933
934         if ((psStream->ui32Flags & DEBUG_FLAGS_USE_NONPAGED_MEM) != 0)
935         {
936                 HostNonPageablePageFree((IMG_VOID *)psStream->ui32Base);
937                 HostNonPageablePageFree((IMG_VOID *)psStream->psInitStream->ui32Base);
938         }
939         else
940         {
941                 HostPageablePageFree((IMG_VOID *)psStream->ui32Base);
942                 HostPageablePageFree((IMG_VOID *)psStream->psInitStream->ui32Base);
943         }
944
945         HostNonPageablePageFree(psStream->psInitStream);
946         HostNonPageablePageFree(psStream);
947         HostNonPageablePageFree(psLFBuffer);
948
949         if (g_psStreamList == 0)
950         {
951                 PVR_DPF((PVR_DBG_MESSAGE,"DBGDriv: Stream list now empty" ));
952         }
953
954         return;
955 }
956
957 IMG_VOID * IMG_CALLCONV DBGDrivFindStream(IMG_CHAR * pszName, IMG_BOOL bResetStream)
958 {
959         PDBG_STREAM     psStream;
960         PDBG_STREAM     psThis;
961         IMG_UINT32      ui32Off;
962         IMG_BOOL        bAreSame;
963
964         psStream = 0;
965
966
967
968         for (psThis = g_psStreamList; psThis != IMG_NULL; psThis = psThis->psNext)
969         {
970                 bAreSame = IMG_TRUE;
971                 ui32Off = 0;
972
973                 if (strlen(psThis->szName) == strlen(pszName))
974                 {
975                         while ((psThis->szName[ui32Off] != 0) && (pszName[ui32Off] != 0) && (ui32Off < 128) && bAreSame)
976                         {
977                                 if (psThis->szName[ui32Off] != pszName[ui32Off])
978                                 {
979                                         bAreSame = IMG_FALSE;
980                                 }
981
982                                 ui32Off++;
983                         }
984                 }
985                 else
986                 {
987                         bAreSame = IMG_FALSE;
988                 }
989
990                 if (bAreSame)
991                 {
992                         psStream = psThis;
993                         break;
994                 }
995         }
996
997         if(bResetStream && psStream)
998         {
999                 static IMG_CHAR szComment[] = "-- Init phase terminated\r\n";
1000                 psStream->psInitStream->ui32RPtr = 0;
1001                 psStream->ui32RPtr = 0;
1002                 psStream->ui32WPtr = 0;
1003                 psStream->ui32DataWritten = psStream->psInitStream->ui32DataWritten;
1004                 if (psStream->bInitPhaseComplete == IMG_FALSE)
1005                 {
1006                         if (psStream->ui32Flags & DEBUG_FLAGS_TEXTSTREAM)
1007                         {
1008                                 DBGDrivWrite2(psStream, (IMG_UINT8 *)szComment, sizeof(szComment) - 1, 0x01);
1009                         }
1010                         psStream->bInitPhaseComplete = IMG_TRUE;
1011                 }
1012         }
1013
1014         return((IMG_VOID *) psStream);
1015 }
1016
1017 IMG_UINT32 IMG_CALLCONV DBGDrivWriteStringCM(PDBG_STREAM psStream,IMG_CHAR * pszString,IMG_UINT32 ui32Level)
1018 {
1019
1020
1021         if (!StreamValid(psStream))
1022         {
1023                 return(0xFFFFFFFFUL);
1024         }
1025
1026
1027
1028         if (psStream->ui32CapMode & DEBUG_CAPMODE_FRAMED)
1029         {
1030                 if      ((psStream->ui32Flags & DEBUG_FLAGS_ENABLESAMPLE) == 0)
1031                 {
1032                         return(0);
1033                 }
1034         }
1035         else
1036         {
1037                 if (psStream->ui32CapMode == DEBUG_CAPMODE_HOTKEY)
1038                 {
1039                         if ((psStream->ui32Current != g_ui32HotKeyFrame) || (g_bHotKeyPressed == IMG_FALSE))
1040                         {
1041                                 return(0);
1042                         }
1043                 }
1044         }
1045
1046         return(DBGDrivWriteString(psStream,pszString,ui32Level));
1047
1048 }
1049
1050 IMG_UINT32 IMG_CALLCONV DBGDrivWriteString(PDBG_STREAM psStream,IMG_CHAR * pszString,IMG_UINT32 ui32Level)
1051 {
1052         IMG_UINT32      ui32Len;
1053         IMG_UINT32      ui32Space;
1054         IMG_UINT32      ui32WPtr;
1055         IMG_UINT8 *     pui8Buffer;
1056
1057
1058
1059         if (!StreamValid(psStream))
1060         {
1061                 return(0xFFFFFFFFUL);
1062         }
1063
1064
1065
1066         if ((psStream->ui32DebugLevel & ui32Level) == 0)
1067         {
1068                 return(0xFFFFFFFFUL);
1069         }
1070
1071
1072
1073
1074         if ((psStream->ui32OutMode & DEBUG_OUTMODE_ASYNC) == 0)
1075         {
1076                 if (psStream->ui32OutMode & DEBUG_OUTMODE_STANDARDDBG)
1077                 {
1078                         PVR_DPF((PVR_DBG_MESSAGE,"%s: %s\r\n",psStream->szName, pszString));
1079                 }
1080
1081
1082
1083                 if (psStream->ui32OutMode & DEBUG_OUTMODE_MONO)
1084                 {
1085                         MonoOut(psStream->szName,IMG_FALSE);
1086                         MonoOut(": ",IMG_FALSE);
1087                         MonoOut(pszString,IMG_TRUE);
1088                 }
1089         }
1090
1091
1092
1093         if      (
1094                         !(
1095                                 ((psStream->ui32OutMode & DEBUG_OUTMODE_STREAMENABLE) != 0) ||
1096                                 ((psStream->ui32OutMode & DEBUG_OUTMODE_ASYNC) != 0)
1097                         )
1098                 )
1099         {
1100                 return(0xFFFFFFFFUL);
1101         }
1102
1103
1104
1105         ui32Space=SpaceInStream(psStream);
1106
1107         if(ui32Space > 0)
1108         {
1109                 ui32Space--;
1110         }
1111
1112         ui32Len         = 0;
1113         ui32WPtr        = psStream->ui32WPtr;
1114         pui8Buffer      = (IMG_UINT8 *) psStream->ui32Base;
1115
1116         while((pszString[ui32Len] != 0) && (ui32Len < ui32Space))
1117         {
1118                 pui8Buffer[ui32WPtr] = (IMG_UINT8)pszString[ui32Len];
1119                 ui32Len++;
1120                 ui32WPtr++;
1121                 if (ui32WPtr == psStream->ui32Size)
1122                 {
1123                         ui32WPtr = 0;
1124                 }
1125         }
1126
1127         if (ui32Len < ui32Space)
1128         {
1129
1130                 pui8Buffer[ui32WPtr] = (IMG_UINT8)pszString[ui32Len];
1131                 ui32Len++;
1132                 ui32WPtr++;
1133                 if (ui32WPtr == psStream->ui32Size)
1134                 {
1135                         ui32WPtr = 0;
1136                 }
1137
1138
1139                 psStream->ui32WPtr = ui32WPtr;
1140                 psStream->ui32DataWritten+= ui32Len;
1141         } else
1142         {
1143                 ui32Len = 0;
1144         }
1145
1146 #if defined(SUPPORT_DBGDRV_EVENT_OBJECTS)
1147         if (ui32Len)
1148         {
1149                 HostSignalEvent(DBG_EVENT_STREAM_DATA);
1150         }
1151 #endif
1152
1153         return(ui32Len);
1154 }
1155
1156 IMG_UINT32 IMG_CALLCONV DBGDrivReadString(PDBG_STREAM psStream,IMG_CHAR * pszString,IMG_UINT32 ui32Limit)
1157 {
1158         IMG_UINT32                              ui32OutLen;
1159         IMG_UINT32                              ui32Len;
1160         IMG_UINT32                              ui32Offset;
1161         IMG_UINT8                               *pui8Buff;
1162
1163
1164
1165         if (!StreamValid(psStream))
1166         {
1167                 return(0);
1168         }
1169
1170
1171
1172         pui8Buff = (IMG_UINT8 *) psStream->ui32Base;
1173         ui32Offset = psStream->ui32RPtr;
1174
1175         if (psStream->ui32RPtr == psStream->ui32WPtr)
1176         {
1177                 return(0);
1178         }
1179
1180
1181
1182         ui32Len = 0;
1183         while((pui8Buff[ui32Offset] != 0) && (ui32Offset != psStream->ui32WPtr))
1184         {
1185                 ui32Offset++;
1186                 ui32Len++;
1187
1188
1189
1190                 if (ui32Offset == psStream->ui32Size)
1191                 {
1192                         ui32Offset = 0;
1193                 }
1194         }
1195
1196         ui32OutLen = ui32Len + 1;
1197
1198
1199
1200         if (ui32Len > ui32Limit)
1201         {
1202                 return(0);
1203         }
1204
1205
1206
1207         ui32Offset = psStream->ui32RPtr;
1208         ui32Len = 0;
1209
1210         while ((pui8Buff[ui32Offset] != 0) && (ui32Len < ui32Limit))
1211         {
1212                 pszString[ui32Len] = (IMG_CHAR)pui8Buff[ui32Offset];
1213                 ui32Offset++;
1214                 ui32Len++;
1215
1216
1217
1218                 if (ui32Offset == psStream->ui32Size)
1219                 {
1220                         ui32Offset = 0;
1221                 }
1222         }
1223
1224         pszString[ui32Len] = (IMG_CHAR)pui8Buff[ui32Offset];
1225
1226         psStream->ui32RPtr = ui32Offset + 1;
1227
1228         if (psStream->ui32RPtr == psStream->ui32Size)
1229         {
1230                 psStream->ui32RPtr = 0;
1231         }
1232
1233         return(ui32OutLen);
1234 }
1235
1236 IMG_UINT32 IMG_CALLCONV DBGDrivWrite(PDBG_STREAM psMainStream,IMG_UINT8 * pui8InBuf,IMG_UINT32 ui32InBuffSize,IMG_UINT32 ui32Level)
1237 {
1238         IMG_UINT32                              ui32Space;
1239         DBG_STREAM *psStream;
1240
1241
1242
1243         if (!StreamValid(psMainStream))
1244         {
1245                 return(0xFFFFFFFFUL);
1246         }
1247
1248
1249
1250         if ((psMainStream->ui32DebugLevel & ui32Level) == 0)
1251         {
1252                 return(0xFFFFFFFFUL);
1253         }
1254
1255
1256
1257         if (psMainStream->ui32CapMode & DEBUG_CAPMODE_FRAMED)
1258         {
1259                 if      ((psMainStream->ui32Flags & DEBUG_FLAGS_ENABLESAMPLE) == 0)
1260                 {
1261                         return(0xFFFFFFFFUL);
1262                 }
1263         }
1264         else if (psMainStream->ui32CapMode == DEBUG_CAPMODE_HOTKEY)
1265         {
1266                 if ((psMainStream->ui32Current != g_ui32HotKeyFrame) || (g_bHotKeyPressed == IMG_FALSE))
1267                         return(0xFFFFFFFFUL);
1268         }
1269
1270         if(psMainStream->bInitPhaseComplete)
1271         {
1272                 psStream = psMainStream;
1273         }
1274         else
1275         {
1276                 psStream = psMainStream->psInitStream;
1277         }
1278
1279
1280
1281         ui32Space=SpaceInStream(psStream);
1282
1283
1284
1285         if ((psStream->ui32OutMode & DEBUG_OUTMODE_STREAMENABLE) == 0)
1286         {
1287                 return(0);
1288         }
1289
1290         if (ui32Space < 8)
1291         {
1292                 return(0);
1293         }
1294
1295
1296
1297         if (ui32Space <= (ui32InBuffSize + 4))
1298         {
1299                 ui32InBuffSize = ui32Space - 8;
1300         }
1301
1302
1303
1304         Write(psStream,(IMG_UINT8 *) &ui32InBuffSize,4);
1305         Write(psStream,pui8InBuf,ui32InBuffSize);
1306
1307 #if defined(SUPPORT_DBGDRV_EVENT_OBJECTS)
1308         if (ui32InBuffSize)
1309         {
1310                 HostSignalEvent(DBG_EVENT_STREAM_DATA);
1311         }
1312 #endif
1313         return(ui32InBuffSize);
1314 }
1315
1316 IMG_UINT32 IMG_CALLCONV DBGDrivWriteCM(PDBG_STREAM psStream,IMG_UINT8 * pui8InBuf,IMG_UINT32 ui32InBuffSize,IMG_UINT32 ui32Level)
1317 {
1318
1319
1320         if (!StreamValid(psStream))
1321         {
1322                 return(0xFFFFFFFFUL);
1323         }
1324
1325
1326
1327         if (psStream->ui32CapMode & DEBUG_CAPMODE_FRAMED)
1328         {
1329                 if      ((psStream->ui32Flags & DEBUG_FLAGS_ENABLESAMPLE) == 0)
1330                 {
1331                         return(0xFFFFFFFFUL);
1332                 }
1333         }
1334         else
1335         {
1336                 if (psStream->ui32CapMode == DEBUG_CAPMODE_HOTKEY)
1337                 {
1338                         if ((psStream->ui32Current != g_ui32HotKeyFrame) || (g_bHotKeyPressed == IMG_FALSE))
1339                         {
1340                                 return(0xFFFFFFFFUL);
1341                         }
1342                 }
1343         }
1344
1345         return(DBGDrivWrite2(psStream,pui8InBuf,ui32InBuffSize,ui32Level));
1346 }
1347
1348 IMG_UINT32 IMG_CALLCONV DBGDrivWrite2(PDBG_STREAM psMainStream,IMG_UINT8 * pui8InBuf,IMG_UINT32 ui32InBuffSize,IMG_UINT32 ui32Level)
1349 {
1350         IMG_UINT32      ui32Space;
1351         DBG_STREAM      *psStream;
1352
1353
1354
1355         if (!StreamValid(psMainStream))
1356         {
1357                 return(0xFFFFFFFFUL);
1358         }
1359
1360
1361
1362         if ((psMainStream->ui32DebugLevel & ui32Level) == 0)
1363         {
1364                 return(0xFFFFFFFFUL);
1365         }
1366
1367         if(psMainStream->bInitPhaseComplete)
1368         {
1369                 psStream = psMainStream;
1370         }
1371         else
1372         {
1373                 psStream = psMainStream->psInitStream;
1374         }
1375
1376
1377
1378         ui32Space=SpaceInStream(psStream);
1379
1380
1381
1382         if ((psStream->ui32OutMode & DEBUG_OUTMODE_STREAMENABLE) == 0)
1383         {
1384                 return(0);
1385         }
1386
1387
1388
1389         if (psStream->ui32Flags & DEBUG_FLAGS_NO_BUF_EXPANDSION)
1390         {
1391
1392
1393
1394                 if (ui32Space < 32)
1395                 {
1396                         return(0);
1397                 }
1398         }
1399         else
1400         {
1401                 if ((ui32Space < 32) || (ui32Space <= (ui32InBuffSize + 4)))
1402                 {
1403                         IMG_UINT32      ui32NewBufSize;
1404
1405
1406
1407                         ui32NewBufSize = 2 * psStream->ui32Size;
1408
1409                         if (ui32InBuffSize > psStream->ui32Size)
1410                         {
1411                                 ui32NewBufSize += ui32InBuffSize;
1412                         }
1413
1414
1415
1416                         if (!ExpandStreamBuffer(psStream,ui32NewBufSize))
1417                         {
1418                                 if (ui32Space < 32)
1419                                 {
1420                                         return(0);
1421                                 }
1422                         }
1423
1424
1425
1426                         ui32Space = SpaceInStream(psStream);
1427                 }
1428         }
1429
1430
1431
1432         if (ui32Space <= (ui32InBuffSize + 4))
1433         {
1434                 ui32InBuffSize = ui32Space - 4;
1435         }
1436
1437
1438
1439         Write(psStream,pui8InBuf,ui32InBuffSize);
1440
1441 #if defined(SUPPORT_DBGDRV_EVENT_OBJECTS)
1442         if (ui32InBuffSize)
1443         {
1444                 HostSignalEvent(DBG_EVENT_STREAM_DATA);
1445         }
1446 #endif
1447         return(ui32InBuffSize);
1448 }
1449
1450 IMG_UINT32 IMG_CALLCONV DBGDrivRead(PDBG_STREAM psMainStream, IMG_BOOL bReadInitBuffer, IMG_UINT32 ui32OutBuffSize,IMG_UINT8 * pui8OutBuf)
1451 {
1452         IMG_UINT32 ui32Data;
1453         DBG_STREAM *psStream;
1454
1455
1456
1457         if (!StreamValid(psMainStream))
1458         {
1459                 return(0);
1460         }
1461
1462         if(bReadInitBuffer)
1463         {
1464                 psStream = psMainStream->psInitStream;
1465         }
1466         else
1467         {
1468                 psStream = psMainStream;
1469         }
1470
1471         if (psStream->ui32RPtr == psStream->ui32WPtr)
1472         {
1473                 return(0);
1474         }
1475
1476
1477
1478         if (psStream->ui32RPtr <= psStream->ui32WPtr)
1479         {
1480                 ui32Data = psStream->ui32WPtr - psStream->ui32RPtr;
1481         }
1482         else
1483         {
1484                 ui32Data = psStream->ui32WPtr + (psStream->ui32Size - psStream->ui32RPtr);
1485         }
1486
1487
1488
1489         if (ui32Data > ui32OutBuffSize)
1490         {
1491                 ui32Data = ui32OutBuffSize;
1492         }
1493
1494
1495
1496         if ((psStream->ui32RPtr + ui32Data) > psStream->ui32Size)
1497         {
1498                 IMG_UINT32 ui32B1 = psStream->ui32Size - psStream->ui32RPtr;
1499                 IMG_UINT32 ui32B2 = ui32Data - ui32B1;
1500
1501
1502                 HostMemCopy((IMG_VOID *) pui8OutBuf,
1503                                 (IMG_VOID *)(psStream->ui32Base + psStream->ui32RPtr),
1504                                 ui32B1);
1505
1506
1507                 HostMemCopy((IMG_VOID *)((IMG_UINT32) pui8OutBuf + ui32B1),
1508                                 (IMG_VOID *)psStream->ui32Base,
1509                                 ui32B2);
1510
1511
1512                 psStream->ui32RPtr = ui32B2;
1513         }
1514         else
1515         {
1516                 HostMemCopy((IMG_VOID *) pui8OutBuf,
1517                                 (IMG_VOID *)(psStream->ui32Base + psStream->ui32RPtr),
1518                                 ui32Data);
1519
1520
1521                 psStream->ui32RPtr += ui32Data;
1522
1523
1524                 if (psStream->ui32RPtr == psStream->ui32Size)
1525                 {
1526                         psStream->ui32RPtr = 0;
1527                 }
1528         }
1529
1530         return(ui32Data);
1531 }
1532
1533 void IMG_CALLCONV DBGDrivSetCaptureMode(PDBG_STREAM psStream,IMG_UINT32 ui32Mode,IMG_UINT32 ui32Start,IMG_UINT32 ui32End,IMG_UINT32 ui32SampleRate)
1534 {
1535
1536
1537         if (!StreamValid(psStream))
1538         {
1539                 return;
1540         }
1541
1542         psStream->ui32CapMode = ui32Mode;
1543         psStream->ui32DefaultMode = ui32Mode;
1544         psStream->ui32Start = ui32Start;
1545         psStream->ui32End = ui32End;
1546         psStream->ui32SampleRate = ui32SampleRate;
1547
1548
1549
1550         if (psStream->ui32CapMode & DEBUG_CAPMODE_HOTKEY)
1551         {
1552                 ActivateHotKeys(psStream);
1553         }
1554 }
1555
1556 void IMG_CALLCONV DBGDrivSetOutputMode(PDBG_STREAM psStream,IMG_UINT32 ui32OutMode)
1557 {
1558
1559
1560         if (!StreamValid(psStream))
1561         {
1562                 return;
1563         }
1564
1565         psStream->ui32OutMode = ui32OutMode;
1566 }
1567
1568 void IMG_CALLCONV DBGDrivSetDebugLevel(PDBG_STREAM psStream,IMG_UINT32 ui32DebugLevel)
1569 {
1570
1571
1572         if (!StreamValid(psStream))
1573         {
1574                 return;
1575         }
1576
1577         psStream->ui32DebugLevel = ui32DebugLevel;
1578 }
1579
1580 void IMG_CALLCONV DBGDrivSetFrame(PDBG_STREAM psStream,IMG_UINT32 ui32Frame)
1581 {
1582
1583
1584         if (!StreamValid(psStream))
1585         {
1586                 return;
1587         }
1588
1589         psStream->ui32Current = ui32Frame;
1590
1591         if ((ui32Frame >= psStream->ui32Start) &&
1592                 (ui32Frame <= psStream->ui32End) &&
1593                 (((ui32Frame - psStream->ui32Start) % psStream->ui32SampleRate) == 0))
1594         {
1595                 psStream->ui32Flags |= DEBUG_FLAGS_ENABLESAMPLE;
1596         }
1597         else
1598         {
1599                 psStream->ui32Flags &= ~DEBUG_FLAGS_ENABLESAMPLE;
1600         }
1601
1602         if (g_bHotkeyMiddump)
1603         {
1604                 if ((ui32Frame >= g_ui32HotkeyMiddumpStart) &&
1605                         (ui32Frame <= g_ui32HotkeyMiddumpEnd) &&
1606                         (((ui32Frame - g_ui32HotkeyMiddumpStart) % psStream->ui32SampleRate) == 0))
1607                 {
1608                         psStream->ui32Flags |= DEBUG_FLAGS_ENABLESAMPLE;
1609                 }
1610                 else
1611                 {
1612                         psStream->ui32Flags &= ~DEBUG_FLAGS_ENABLESAMPLE;
1613                         if (psStream->ui32Current > g_ui32HotkeyMiddumpEnd)
1614                         {
1615                                 g_bHotkeyMiddump = IMG_FALSE;
1616                         }
1617                 }
1618         }
1619
1620
1621         if (g_bHotKeyRegistered)
1622         {
1623                 g_bHotKeyRegistered = IMG_FALSE;
1624
1625                 PVR_DPF((PVR_DBG_MESSAGE,"Hotkey pressed (%08x)!\n",psStream));
1626
1627                 if (!g_bHotKeyPressed)
1628                 {
1629
1630
1631                         g_ui32HotKeyFrame = psStream->ui32Current + 2;
1632
1633
1634
1635                         g_bHotKeyPressed = IMG_TRUE;
1636                 }
1637
1638
1639
1640                 if (((psStream->ui32CapMode & DEBUG_CAPMODE_FRAMED) != 0) &&
1641                         ((psStream->ui32CapMode & DEBUG_CAPMODE_HOTKEY) != 0))
1642                 {
1643                         if (!g_bHotkeyMiddump)
1644                         {
1645
1646                                 g_ui32HotkeyMiddumpStart = g_ui32HotKeyFrame + 1;
1647                                 g_ui32HotkeyMiddumpEnd = 0xffffffff;
1648                                 g_bHotkeyMiddump = IMG_TRUE;
1649                                 PVR_DPF((PVR_DBG_MESSAGE,"Sampling every %d frame(s)\n", psStream->ui32SampleRate));
1650                         }
1651                         else
1652                         {
1653
1654                                 g_ui32HotkeyMiddumpEnd = g_ui32HotKeyFrame;
1655                                 PVR_DPF((PVR_DBG_MESSAGE,"Turning off sampling\n"));
1656                         }
1657                 }
1658
1659         }
1660
1661
1662
1663         if (psStream->ui32Current > g_ui32HotKeyFrame)
1664         {
1665                 g_bHotKeyPressed = IMG_FALSE;
1666         }
1667 }
1668
1669 IMG_UINT32 IMG_CALLCONV DBGDrivGetFrame(PDBG_STREAM psStream)
1670 {
1671
1672
1673         if (!StreamValid(psStream))
1674         {
1675                 return(0);
1676         }
1677
1678         return(psStream->ui32Current);
1679 }
1680
1681 IMG_BOOL IMG_CALLCONV DBGDrivIsLastCaptureFrame(PDBG_STREAM psStream)
1682 {
1683         IMG_UINT32      ui32NextFrame;
1684
1685
1686
1687         if (!StreamValid(psStream))
1688         {
1689                 return IMG_FALSE;
1690         }
1691
1692         if (psStream->ui32CapMode & DEBUG_CAPMODE_FRAMED)
1693         {
1694                 ui32NextFrame = psStream->ui32Current + psStream->ui32SampleRate;
1695                 if (ui32NextFrame > psStream->ui32End)
1696                 {
1697                         return IMG_TRUE;
1698                 }
1699         }
1700         return IMG_FALSE;
1701 }
1702
1703 IMG_BOOL IMG_CALLCONV DBGDrivIsCaptureFrame(PDBG_STREAM psStream, IMG_BOOL bCheckPreviousFrame)
1704 {
1705         IMG_UINT32 ui32FrameShift = bCheckPreviousFrame ? 1UL : 0UL;
1706
1707
1708
1709         if (!StreamValid(psStream))
1710         {
1711                 return IMG_FALSE;
1712         }
1713
1714         if (psStream->ui32CapMode & DEBUG_CAPMODE_FRAMED)
1715         {
1716
1717                 if (g_bHotkeyMiddump)
1718                 {
1719                         if ((psStream->ui32Current >= (g_ui32HotkeyMiddumpStart - ui32FrameShift)) &&
1720                                 (psStream->ui32Current <= (g_ui32HotkeyMiddumpEnd - ui32FrameShift)) &&
1721                                 ((((psStream->ui32Current + ui32FrameShift) - g_ui32HotkeyMiddumpStart) % psStream->ui32SampleRate) == 0))
1722                         {
1723                                 return IMG_TRUE;
1724                         }
1725                 }
1726                 else
1727                 {
1728                         if ((psStream->ui32Current >= (psStream->ui32Start - ui32FrameShift)) &&
1729                                 (psStream->ui32Current <= (psStream->ui32End - ui32FrameShift)) &&
1730                                 ((((psStream->ui32Current + ui32FrameShift) - psStream->ui32Start) % psStream->ui32SampleRate) == 0))
1731                         {
1732                                 return IMG_TRUE;
1733                         }
1734                 }
1735         }
1736         else if (psStream->ui32CapMode == DEBUG_CAPMODE_HOTKEY)
1737         {
1738                 if ((psStream->ui32Current == (g_ui32HotKeyFrame-ui32FrameShift)) && (g_bHotKeyPressed))
1739                 {
1740                         return IMG_TRUE;
1741                 }
1742         }
1743         return IMG_FALSE;
1744 }
1745
1746 void IMG_CALLCONV DBGDrivOverrideMode(PDBG_STREAM psStream,IMG_UINT32 ui32Mode)
1747 {
1748
1749
1750         if (!StreamValid(psStream))
1751         {
1752                 return;
1753         }
1754
1755         psStream->ui32CapMode = ui32Mode;
1756 }
1757
1758 void IMG_CALLCONV DBGDrivDefaultMode(PDBG_STREAM psStream)
1759 {
1760
1761
1762         if (!StreamValid(psStream))
1763         {
1764                 return;
1765         }
1766
1767         psStream->ui32CapMode = psStream->ui32DefaultMode;
1768 }
1769
1770 void IMG_CALLCONV DBGDrivSetMarker(PDBG_STREAM psStream, IMG_UINT32 ui32Marker)
1771 {
1772
1773
1774         if (!StreamValid(psStream))
1775         {
1776                 return;
1777         }
1778
1779         psStream->ui32Marker = ui32Marker;
1780 }
1781
1782 IMG_UINT32 IMG_CALLCONV DBGDrivGetMarker(PDBG_STREAM psStream)
1783 {
1784
1785
1786         if (!StreamValid(psStream))
1787         {
1788                 return 0;
1789         }
1790
1791         return psStream->ui32Marker;
1792 }
1793
1794
1795 IMG_UINT32 IMG_CALLCONV DBGDrivGetStreamOffset(PDBG_STREAM psMainStream)
1796 {
1797         PDBG_STREAM psStream;
1798
1799
1800
1801         if (!StreamValid(psMainStream))
1802         {
1803                 return 0;
1804         }
1805
1806         if(psMainStream->bInitPhaseComplete)
1807         {
1808                 psStream = psMainStream;
1809         }
1810         else
1811         {
1812                 psStream = psMainStream->psInitStream;
1813         }
1814
1815         return psStream->ui32DataWritten;
1816 }
1817
1818 IMG_VOID IMG_CALLCONV DBGDrivSetStreamOffset(PDBG_STREAM psMainStream, IMG_UINT32 ui32StreamOffset)
1819 {
1820         PDBG_STREAM psStream;
1821
1822
1823
1824         if (!StreamValid(psMainStream))
1825         {
1826                 return;
1827         }
1828
1829         if(psMainStream->bInitPhaseComplete)
1830         {
1831                 psStream = psMainStream;
1832         }
1833         else
1834         {
1835                 psStream = psMainStream->psInitStream;
1836         }
1837
1838         psStream->ui32DataWritten = ui32StreamOffset;
1839 }
1840
1841 IMG_UINT32 IMG_CALLCONV DBGDrivGetServiceTable(void)
1842 {
1843         return((IMG_UINT32) &g_sDBGKMServices);
1844 }
1845
1846 IMG_UINT32 IMG_CALLCONV DBGDrivWriteLF(PDBG_STREAM psStream, IMG_UINT8 * pui8InBuf, IMG_UINT32 ui32InBuffSize, IMG_UINT32 ui32Level, IMG_UINT32 ui32Flags)
1847 {
1848         PDBG_LASTFRAME_BUFFER   psLFBuffer;
1849
1850
1851
1852         if (!StreamValid(psStream))
1853         {
1854                 return(0xFFFFFFFFUL);
1855         }
1856
1857
1858
1859         if ((psStream->ui32DebugLevel & ui32Level) == 0)
1860         {
1861                 return(0xFFFFFFFFUL);
1862         }
1863
1864
1865
1866         if ((psStream->ui32CapMode & DEBUG_CAPMODE_FRAMED) != 0)
1867         {
1868                 if      ((psStream->ui32Flags & DEBUG_FLAGS_ENABLESAMPLE) == 0)
1869                 {
1870                         return(0xFFFFFFFFUL);
1871                 }
1872         }
1873         else if (psStream->ui32CapMode == DEBUG_CAPMODE_HOTKEY)
1874         {
1875                 if ((psStream->ui32Current != g_ui32HotKeyFrame) || (g_bHotKeyPressed == IMG_FALSE))
1876                         return(0xFFFFFFFFUL);
1877         }
1878
1879         psLFBuffer = FindLFBuf(psStream);
1880
1881         if (ui32Flags & WRITELF_FLAGS_RESETBUF)
1882         {
1883
1884
1885                 ui32InBuffSize = (ui32InBuffSize > LAST_FRAME_BUF_SIZE) ? LAST_FRAME_BUF_SIZE : ui32InBuffSize;
1886                 HostMemCopy((IMG_VOID *)psLFBuffer->ui8Buffer, (IMG_VOID *)pui8InBuf, ui32InBuffSize);
1887                 psLFBuffer->ui32BufLen = ui32InBuffSize;
1888         }
1889         else
1890         {
1891
1892
1893                 ui32InBuffSize = ((psLFBuffer->ui32BufLen + ui32InBuffSize) > LAST_FRAME_BUF_SIZE) ? (LAST_FRAME_BUF_SIZE - psLFBuffer->ui32BufLen) : ui32InBuffSize;
1894                 HostMemCopy((IMG_VOID *)(&psLFBuffer->ui8Buffer[psLFBuffer->ui32BufLen]), (IMG_VOID *)pui8InBuf, ui32InBuffSize);
1895                 psLFBuffer->ui32BufLen += ui32InBuffSize;
1896         }
1897
1898         return(ui32InBuffSize);
1899 }
1900
1901 IMG_UINT32 IMG_CALLCONV DBGDrivReadLF(PDBG_STREAM psStream, IMG_UINT32 ui32OutBuffSize, IMG_UINT8 * pui8OutBuf)
1902 {
1903         PDBG_LASTFRAME_BUFFER   psLFBuffer;
1904         IMG_UINT32      ui32Data;
1905
1906
1907
1908         if (!StreamValid(psStream))
1909         {
1910                 return(0);
1911         }
1912
1913         psLFBuffer = FindLFBuf(psStream);
1914
1915
1916
1917         ui32Data = (ui32OutBuffSize < psLFBuffer->ui32BufLen) ? ui32OutBuffSize : psLFBuffer->ui32BufLen;
1918
1919
1920
1921         HostMemCopy((IMG_VOID *)pui8OutBuf, (IMG_VOID *)psLFBuffer->ui8Buffer, ui32Data);
1922
1923         return ui32Data;
1924 }
1925
1926 IMG_VOID IMG_CALLCONV DBGDrivStartInitPhase(PDBG_STREAM psStream)
1927 {
1928         psStream->bInitPhaseComplete = IMG_FALSE;
1929 }
1930
1931 IMG_VOID IMG_CALLCONV DBGDrivStopInitPhase(PDBG_STREAM psStream)
1932 {
1933         psStream->bInitPhaseComplete = IMG_TRUE;
1934 }
1935
1936 #if defined(SUPPORT_DBGDRV_EVENT_OBJECTS)
1937 IMG_VOID IMG_CALLCONV DBGDrivWaitForEvent(DBG_EVENT eEvent)
1938 {
1939         HostWaitForEvent(eEvent);
1940 }
1941 #endif
1942
1943 IMG_BOOL ExpandStreamBuffer(PDBG_STREAM psStream, IMG_UINT32 ui32NewSize)
1944 {
1945         IMG_VOID *      pvNewBuf;
1946         IMG_UINT32      ui32NewSizeInPages;
1947         IMG_UINT32      ui32NewWOffset;
1948         IMG_UINT32      ui32SpaceInOldBuf;
1949
1950
1951
1952         if (psStream->ui32Size >= ui32NewSize)
1953         {
1954                 return IMG_FALSE;
1955         }
1956
1957
1958
1959         ui32SpaceInOldBuf = SpaceInStream(psStream);
1960
1961
1962
1963         ui32NewSizeInPages = ((ui32NewSize + 0xfffUL) & ~0xfffUL) / 4096UL;
1964
1965         if ((psStream->ui32Flags & DEBUG_FLAGS_USE_NONPAGED_MEM) != 0)
1966         {
1967                 pvNewBuf = HostNonPageablePageAlloc(ui32NewSizeInPages);
1968         }
1969         else
1970         {
1971                 pvNewBuf = HostPageablePageAlloc(ui32NewSizeInPages);
1972         }
1973
1974         if (pvNewBuf == IMG_NULL)
1975         {
1976                 return IMG_FALSE;
1977         }
1978
1979
1980
1981
1982         if (psStream->ui32RPtr <= psStream->ui32WPtr)
1983         {
1984
1985
1986                 HostMemCopy((IMG_VOID *)pvNewBuf, (IMG_VOID *)(psStream->ui32Base + psStream->ui32RPtr), psStream->ui32WPtr - psStream->ui32RPtr);
1987         }
1988         else
1989         {
1990                 IMG_UINT32      ui32FirstCopySize;
1991
1992
1993
1994                 ui32FirstCopySize = psStream->ui32Size - psStream->ui32RPtr;
1995
1996                 HostMemCopy((IMG_VOID *)pvNewBuf, (IMG_VOID *)(psStream->ui32Base + psStream->ui32RPtr), ui32FirstCopySize);
1997
1998
1999
2000                 HostMemCopy((IMG_VOID *)((IMG_UINT32)pvNewBuf + ui32FirstCopySize), (IMG_VOID *)psStream->ui32Base, psStream->ui32WPtr);
2001         }
2002
2003
2004
2005         ui32NewWOffset = psStream->ui32Size - ui32SpaceInOldBuf;
2006
2007
2008
2009         if ((psStream->ui32Flags & DEBUG_FLAGS_USE_NONPAGED_MEM) != 0)
2010         {
2011                 HostNonPageablePageFree((IMG_VOID *)psStream->ui32Base);
2012         }
2013         else
2014         {
2015                 HostPageablePageFree((IMG_VOID *)psStream->ui32Base);
2016         }
2017
2018
2019
2020         psStream->ui32Base = (IMG_UINT32)pvNewBuf;
2021         psStream->ui32RPtr = 0;
2022         psStream->ui32WPtr = ui32NewWOffset;
2023         psStream->ui32Size = ui32NewSizeInPages * 4096;
2024
2025         return IMG_TRUE;
2026 }
2027
2028 IMG_UINT32 SpaceInStream(PDBG_STREAM psStream)
2029 {
2030         IMG_UINT32      ui32Space;
2031
2032         if (psStream->ui32RPtr > psStream->ui32WPtr)
2033         {
2034                 ui32Space = psStream->ui32RPtr - psStream->ui32WPtr;
2035         }
2036         else
2037         {
2038                 ui32Space = psStream->ui32RPtr + (psStream->ui32Size - psStream->ui32WPtr);
2039         }
2040
2041         return ui32Space;
2042 }
2043
2044
2045 void DestroyAllStreams(void)
2046 {
2047         while (g_psStreamList != IMG_NULL)
2048         {
2049                 DBGDrivDestroyStream(g_psStreamList);
2050         }
2051         return;
2052 }
2053
2054 PDBG_LASTFRAME_BUFFER FindLFBuf(PDBG_STREAM psStream)
2055 {
2056         PDBG_LASTFRAME_BUFFER   psLFBuffer;
2057
2058         psLFBuffer = g_psLFBufferList;
2059
2060         while (psLFBuffer)
2061         {
2062                 if (psLFBuffer->psStream == psStream)
2063                 {
2064                         break;
2065                 }
2066
2067                 psLFBuffer = psLFBuffer->psNext;
2068         }
2069
2070         return psLFBuffer;
2071 }
2072