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