/drivers/gpu/pvr/pdump.c

https://bitbucket.org/wisechild/galaxy-nexus · C · 628 lines · 466 code · 137 blank · 25 comment · 67 complexity · b79f5009e67b21a1af5b6b434045750b MD5 · raw file

  1. /**********************************************************************
  2. *
  3. * Copyright (C) Imagination Technologies Ltd. All rights reserved.
  4. *
  5. * This program is free software; you can redistribute it and/or modify it
  6. * under the terms and conditions of the GNU General Public License,
  7. * version 2, as published by the Free Software Foundation.
  8. *
  9. * This program is distributed in the hope it will be useful but, except
  10. * as otherwise stated in writing, without any warranty; without even the
  11. * implied warranty of merchantability or fitness for a particular purpose.
  12. * See the GNU General Public License for more details.
  13. *
  14. * You should have received a copy of the GNU General Public License along with
  15. * this program; if not, write to the Free Software Foundation, Inc.,
  16. * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
  17. *
  18. * The full GNU General Public License is included in this distribution in
  19. * the file called "COPYING".
  20. *
  21. * Contact Information:
  22. * Imagination Technologies Ltd. <gpl-support@imgtec.com>
  23. * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK
  24. *
  25. ******************************************************************************/
  26. #if defined (SUPPORT_SGX) || defined (SUPPORT_VGX)
  27. #if defined (PDUMP)
  28. #include <asm/atomic.h>
  29. #include <stdarg.h>
  30. #if defined (SUPPORT_SGX)
  31. #include "sgxdefs.h"
  32. #endif
  33. #include "services_headers.h"
  34. #include "pvrversion.h"
  35. #include "pvr_debug.h"
  36. #include "dbgdrvif.h"
  37. #if defined (SUPPORT_SGX)
  38. #include "sgxmmu.h"
  39. #endif
  40. #include "mm.h"
  41. #include "pdump_km.h"
  42. #include "pdump_int.h"
  43. #include <linux/kernel.h>
  44. #include <linux/string.h>
  45. static IMG_BOOL PDumpWriteString2 (IMG_CHAR * pszString, IMG_UINT32 ui32Flags);
  46. static IMG_BOOL PDumpWriteILock (PDBG_STREAM psStream, IMG_UINT8 *pui8Data, IMG_UINT32 ui32Count, IMG_UINT32 ui32Flags);
  47. static IMG_VOID DbgSetFrame (PDBG_STREAM psStream, IMG_UINT32 ui32Frame);
  48. static IMG_VOID DbgSetMarker (PDBG_STREAM psStream, IMG_UINT32 ui32Marker);
  49. #define PDUMP_DATAMASTER_PIXEL (1)
  50. #define PDUMP_DATAMASTER_EDM (3)
  51. #define MAX_FILE_SIZE 0x40000000
  52. static atomic_t gsPDumpSuspended = ATOMIC_INIT(0);
  53. static PDBGKM_SERVICE_TABLE gpfnDbgDrv = IMG_NULL;
  54. IMG_CHAR *pszStreamName[PDUMP_NUM_STREAMS] = { "ParamStream2",
  55. "ScriptStream2",
  56. "DriverInfoStream"};
  57. typedef struct PDBG_PDUMP_STATE_TAG
  58. {
  59. PDBG_STREAM psStream[PDUMP_NUM_STREAMS];
  60. IMG_UINT32 ui32ParamFileNum;
  61. IMG_CHAR *pszMsg;
  62. IMG_CHAR *pszScript;
  63. IMG_CHAR *pszFile;
  64. } PDBG_PDUMP_STATE;
  65. static PDBG_PDUMP_STATE gsDBGPdumpState = {{IMG_NULL}, 0, IMG_NULL, IMG_NULL, IMG_NULL};
  66. #define SZ_MSG_SIZE_MAX PVRSRV_PDUMP_MAX_COMMENT_SIZE-1
  67. #define SZ_SCRIPT_SIZE_MAX PVRSRV_PDUMP_MAX_COMMENT_SIZE-1
  68. #define SZ_FILENAME_SIZE_MAX PVRSRV_PDUMP_MAX_COMMENT_SIZE-1
  69. IMG_VOID DBGDrvGetServiceTable(IMG_VOID **fn_table);
  70. static inline IMG_BOOL PDumpSuspended(IMG_VOID)
  71. {
  72. return (atomic_read(&gsPDumpSuspended) != 0) ? IMG_TRUE : IMG_FALSE;
  73. }
  74. PVRSRV_ERROR PDumpOSGetScriptString(IMG_HANDLE *phScript,
  75. IMG_UINT32 *pui32MaxLen)
  76. {
  77. *phScript = (IMG_HANDLE)gsDBGPdumpState.pszScript;
  78. *pui32MaxLen = SZ_SCRIPT_SIZE_MAX;
  79. if ((!*phScript) || PDumpSuspended())
  80. {
  81. return PVRSRV_ERROR_PDUMP_NOT_ACTIVE;
  82. }
  83. return PVRSRV_OK;
  84. }
  85. PVRSRV_ERROR PDumpOSGetMessageString(IMG_CHAR **ppszMsg,
  86. IMG_UINT32 *pui32MaxLen)
  87. {
  88. *ppszMsg = gsDBGPdumpState.pszMsg;
  89. *pui32MaxLen = SZ_MSG_SIZE_MAX;
  90. if ((!*ppszMsg) || PDumpSuspended())
  91. {
  92. return PVRSRV_ERROR_PDUMP_NOT_ACTIVE;
  93. }
  94. return PVRSRV_OK;
  95. }
  96. PVRSRV_ERROR PDumpOSGetFilenameString(IMG_CHAR **ppszFile,
  97. IMG_UINT32 *pui32MaxLen)
  98. {
  99. *ppszFile = gsDBGPdumpState.pszFile;
  100. *pui32MaxLen = SZ_FILENAME_SIZE_MAX;
  101. if ((!*ppszFile) || PDumpSuspended())
  102. {
  103. return PVRSRV_ERROR_PDUMP_NOT_ACTIVE;
  104. }
  105. return PVRSRV_OK;
  106. }
  107. IMG_BOOL PDumpOSWriteString2(IMG_HANDLE hScript, IMG_UINT32 ui32Flags)
  108. {
  109. return PDumpWriteString2(hScript, ui32Flags);
  110. }
  111. PVRSRV_ERROR PDumpOSBufprintf(IMG_HANDLE hBuf, IMG_UINT32 ui32ScriptSizeMax, IMG_CHAR* pszFormat, ...)
  112. {
  113. IMG_CHAR* pszBuf = hBuf;
  114. IMG_INT32 n;
  115. va_list vaArgs;
  116. va_start(vaArgs, pszFormat);
  117. n = vsnprintf(pszBuf, ui32ScriptSizeMax, pszFormat, vaArgs);
  118. va_end(vaArgs);
  119. if (n>=(IMG_INT32)ui32ScriptSizeMax || n==-1)
  120. {
  121. PVR_DPF((PVR_DBG_ERROR, "Buffer overflow detected, pdump output may be incomplete."));
  122. return PVRSRV_ERROR_PDUMP_BUF_OVERFLOW;
  123. }
  124. #if defined(PDUMP_DEBUG_OUTFILES)
  125. g_ui32EveryLineCounter++;
  126. #endif
  127. return PVRSRV_OK;
  128. }
  129. PVRSRV_ERROR PDumpOSVSprintf(IMG_CHAR *pszComment, IMG_UINT32 ui32ScriptSizeMax, IMG_CHAR* pszFormat, PDUMP_va_list vaArgs)
  130. {
  131. IMG_INT32 n;
  132. n = vsnprintf(pszComment, ui32ScriptSizeMax, pszFormat, vaArgs);
  133. if (n>=(IMG_INT32)ui32ScriptSizeMax || n==-1)
  134. {
  135. PVR_DPF((PVR_DBG_ERROR, "Buffer overflow detected, pdump output may be incomplete."));
  136. return PVRSRV_ERROR_PDUMP_BUF_OVERFLOW;
  137. }
  138. return PVRSRV_OK;
  139. }
  140. IMG_VOID PDumpOSDebugPrintf(IMG_CHAR* pszFormat, ...)
  141. {
  142. PVR_UNREFERENCED_PARAMETER(pszFormat);
  143. }
  144. PVRSRV_ERROR PDumpOSSprintf(IMG_CHAR *pszComment, IMG_UINT32 ui32ScriptSizeMax, IMG_CHAR *pszFormat, ...)
  145. {
  146. IMG_INT32 n;
  147. va_list vaArgs;
  148. va_start(vaArgs, pszFormat);
  149. n = vsnprintf(pszComment, ui32ScriptSizeMax, pszFormat, vaArgs);
  150. va_end(vaArgs);
  151. if (n>=(IMG_INT32)ui32ScriptSizeMax || n==-1)
  152. {
  153. PVR_DPF((PVR_DBG_ERROR, "Buffer overflow detected, pdump output may be incomplete."));
  154. return PVRSRV_ERROR_PDUMP_BUF_OVERFLOW;
  155. }
  156. return PVRSRV_OK;
  157. }
  158. IMG_UINT32 PDumpOSBuflen(IMG_HANDLE hBuffer, IMG_UINT32 ui32BufferSizeMax)
  159. {
  160. IMG_CHAR* pszBuf = hBuffer;
  161. IMG_UINT32 ui32Count = 0;
  162. while ((pszBuf[ui32Count]!=0) && (ui32Count<ui32BufferSizeMax) )
  163. {
  164. ui32Count++;
  165. }
  166. return(ui32Count);
  167. }
  168. IMG_VOID PDumpOSVerifyLineEnding(IMG_HANDLE hBuffer, IMG_UINT32 ui32BufferSizeMax)
  169. {
  170. IMG_UINT32 ui32Count;
  171. IMG_CHAR* pszBuf = hBuffer;
  172. ui32Count = PDumpOSBuflen(hBuffer, ui32BufferSizeMax);
  173. if ((ui32Count >= 1) && (pszBuf[ui32Count-1] != '\n') && (ui32Count<ui32BufferSizeMax))
  174. {
  175. pszBuf[ui32Count] = '\n';
  176. ui32Count++;
  177. pszBuf[ui32Count] = '\0';
  178. }
  179. if ((ui32Count >= 2) && (pszBuf[ui32Count-2] != '\r') && (ui32Count<ui32BufferSizeMax))
  180. {
  181. pszBuf[ui32Count-1] = '\r';
  182. pszBuf[ui32Count] = '\n';
  183. ui32Count++;
  184. pszBuf[ui32Count] = '\0';
  185. }
  186. }
  187. IMG_HANDLE PDumpOSGetStream(IMG_UINT32 ePDumpStream)
  188. {
  189. return (IMG_HANDLE)gsDBGPdumpState.psStream[ePDumpStream];
  190. }
  191. IMG_UINT32 PDumpOSGetStreamOffset(IMG_UINT32 ePDumpStream)
  192. {
  193. PDBG_STREAM psStream = gsDBGPdumpState.psStream[ePDumpStream];
  194. return gpfnDbgDrv->pfnGetStreamOffset(psStream);
  195. }
  196. IMG_UINT32 PDumpOSGetParamFileNum(IMG_VOID)
  197. {
  198. return gsDBGPdumpState.ui32ParamFileNum;
  199. }
  200. IMG_BOOL PDumpOSWriteString(IMG_HANDLE hStream,
  201. IMG_UINT8 *psui8Data,
  202. IMG_UINT32 ui32Size,
  203. IMG_UINT32 ui32Flags)
  204. {
  205. PDBG_STREAM psStream = (PDBG_STREAM)hStream;
  206. return PDumpWriteILock(psStream,
  207. psui8Data,
  208. ui32Size,
  209. ui32Flags);
  210. }
  211. IMG_VOID PDumpOSCheckForSplitting(IMG_HANDLE hStream, IMG_UINT32 ui32Size, IMG_UINT32 ui32Flags)
  212. {
  213. PVR_UNREFERENCED_PARAMETER(hStream);
  214. PVR_UNREFERENCED_PARAMETER(ui32Size);
  215. PVR_UNREFERENCED_PARAMETER(ui32Flags);
  216. }
  217. IMG_BOOL PDumpOSJTInitialised(IMG_VOID)
  218. {
  219. if(gpfnDbgDrv)
  220. {
  221. return IMG_TRUE;
  222. }
  223. return IMG_FALSE;
  224. }
  225. inline IMG_BOOL PDumpOSIsSuspended(IMG_VOID)
  226. {
  227. return (atomic_read(&gsPDumpSuspended) != 0) ? IMG_TRUE : IMG_FALSE;
  228. }
  229. IMG_VOID PDumpOSCPUVAddrToDevPAddr(PVRSRV_DEVICE_TYPE eDeviceType,
  230. IMG_HANDLE hOSMemHandle,
  231. IMG_UINT32 ui32Offset,
  232. IMG_UINT8 *pui8LinAddr,
  233. IMG_UINT32 ui32PageSize,
  234. IMG_DEV_PHYADDR *psDevPAddr)
  235. {
  236. IMG_CPU_PHYADDR sCpuPAddr;
  237. PVR_UNREFERENCED_PARAMETER(pui8LinAddr);
  238. PVR_UNREFERENCED_PARAMETER(ui32PageSize);
  239. PVR_ASSERT (hOSMemHandle != IMG_NULL);
  240. sCpuPAddr = OSMemHandleToCpuPAddr(hOSMemHandle, ui32Offset);
  241. PVR_ASSERT((sCpuPAddr.uiAddr & (ui32PageSize - 1)) == 0);
  242. *psDevPAddr = SysCpuPAddrToDevPAddr(eDeviceType, sCpuPAddr);
  243. }
  244. IMG_VOID PDumpOSCPUVAddrToPhysPages(IMG_HANDLE hOSMemHandle,
  245. IMG_UINT32 ui32Offset,
  246. IMG_PUINT8 pui8LinAddr,
  247. IMG_UINT32 ui32DataPageMask,
  248. IMG_UINT32 *pui32PageOffset)
  249. {
  250. if(hOSMemHandle)
  251. {
  252. IMG_CPU_PHYADDR sCpuPAddr;
  253. PVR_UNREFERENCED_PARAMETER(pui8LinAddr);
  254. sCpuPAddr = OSMemHandleToCpuPAddr(hOSMemHandle, ui32Offset);
  255. *pui32PageOffset = sCpuPAddr.uiAddr & ui32DataPageMask;
  256. }
  257. else
  258. {
  259. PVR_UNREFERENCED_PARAMETER(hOSMemHandle);
  260. PVR_UNREFERENCED_PARAMETER(ui32Offset);
  261. *pui32PageOffset = ((IMG_UINT32)pui8LinAddr & ui32DataPageMask);
  262. }
  263. }
  264. IMG_UINT32 PDumpOSDebugDriverWrite( PDBG_STREAM psStream,
  265. PDUMP_DDWMODE eDbgDrvWriteMode,
  266. IMG_UINT8 *pui8Data,
  267. IMG_UINT32 ui32BCount,
  268. IMG_UINT32 ui32Level,
  269. IMG_UINT32 ui32DbgDrvFlags)
  270. {
  271. switch(eDbgDrvWriteMode)
  272. {
  273. case PDUMP_WRITE_MODE_CONTINUOUS:
  274. PVR_UNREFERENCED_PARAMETER(ui32DbgDrvFlags);
  275. return gpfnDbgDrv->pfnDBGDrivWrite2(psStream, pui8Data, ui32BCount, ui32Level);
  276. case PDUMP_WRITE_MODE_LASTFRAME:
  277. return gpfnDbgDrv->pfnWriteLF(psStream, pui8Data, ui32BCount, ui32Level, ui32DbgDrvFlags);
  278. case PDUMP_WRITE_MODE_BINCM:
  279. PVR_UNREFERENCED_PARAMETER(ui32DbgDrvFlags);
  280. return gpfnDbgDrv->pfnWriteBINCM(psStream, pui8Data, ui32BCount, ui32Level);
  281. case PDUMP_WRITE_MODE_PERSISTENT:
  282. PVR_UNREFERENCED_PARAMETER(ui32DbgDrvFlags);
  283. return gpfnDbgDrv->pfnWritePersist(psStream, pui8Data, ui32BCount, ui32Level);
  284. default:
  285. PVR_UNREFERENCED_PARAMETER(ui32DbgDrvFlags);
  286. break;
  287. }
  288. return 0xFFFFFFFFU;
  289. }
  290. IMG_VOID PDumpOSReleaseExecution(IMG_VOID)
  291. {
  292. OSReleaseThreadQuanta();
  293. }
  294. IMG_VOID PDumpInit(IMG_VOID)
  295. {
  296. IMG_UINT32 i;
  297. DBGKM_CONNECT_NOTIFIER sConnectNotifier;
  298. if (!gpfnDbgDrv)
  299. {
  300. DBGDrvGetServiceTable((IMG_VOID **)&gpfnDbgDrv);
  301. if (gpfnDbgDrv == IMG_NULL)
  302. {
  303. return;
  304. }
  305. sConnectNotifier.pfnConnectNotifier = &PDumpConnectionNotify;
  306. gpfnDbgDrv->pfnSetConnectNotifier(sConnectNotifier);
  307. if(!gsDBGPdumpState.pszFile)
  308. {
  309. if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_FILENAME_SIZE_MAX, (IMG_PVOID *)&gsDBGPdumpState.pszFile, 0,
  310. "Filename string") != PVRSRV_OK)
  311. {
  312. goto init_failed;
  313. }
  314. }
  315. if(!gsDBGPdumpState.pszMsg)
  316. {
  317. if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_MSG_SIZE_MAX, (IMG_PVOID *)&gsDBGPdumpState.pszMsg, 0,
  318. "Message string") != PVRSRV_OK)
  319. {
  320. goto init_failed;
  321. }
  322. }
  323. if(!gsDBGPdumpState.pszScript)
  324. {
  325. if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_SCRIPT_SIZE_MAX, (IMG_PVOID *)&gsDBGPdumpState.pszScript, 0,
  326. "Script string") != PVRSRV_OK)
  327. {
  328. goto init_failed;
  329. }
  330. }
  331. for(i=0; i < PDUMP_NUM_STREAMS; i++)
  332. {
  333. gsDBGPdumpState.psStream[i] = gpfnDbgDrv->pfnCreateStream(pszStreamName[i],
  334. DEBUG_CAPMODE_FRAMED,
  335. DEBUG_OUTMODE_STREAMENABLE,
  336. 0,
  337. 10);
  338. gpfnDbgDrv->pfnSetCaptureMode(gsDBGPdumpState.psStream[i],DEBUG_CAPMODE_FRAMED,0xFFFFFFFF, 0xFFFFFFFF, 1);
  339. gpfnDbgDrv->pfnSetFrame(gsDBGPdumpState.psStream[i],0);
  340. }
  341. PDUMPCOMMENT("Driver Product Name: %s", VS_PRODUCT_NAME);
  342. PDUMPCOMMENT("Driver Product Version: %s (%s)", PVRVERSION_STRING, PVRVERSION_FAMILY);
  343. PDUMPCOMMENT("Start of Init Phase");
  344. }
  345. return;
  346. init_failed:
  347. if(gsDBGPdumpState.pszFile)
  348. {
  349. OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_FILENAME_SIZE_MAX, (IMG_PVOID) gsDBGPdumpState.pszFile, 0);
  350. gsDBGPdumpState.pszFile = IMG_NULL;
  351. }
  352. if(gsDBGPdumpState.pszScript)
  353. {
  354. OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_SCRIPT_SIZE_MAX, (IMG_PVOID) gsDBGPdumpState.pszScript, 0);
  355. gsDBGPdumpState.pszScript = IMG_NULL;
  356. }
  357. if(gsDBGPdumpState.pszMsg)
  358. {
  359. OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_MSG_SIZE_MAX, (IMG_PVOID) gsDBGPdumpState.pszMsg, 0);
  360. gsDBGPdumpState.pszMsg = IMG_NULL;
  361. }
  362. sConnectNotifier.pfnConnectNotifier = 0;
  363. gpfnDbgDrv->pfnSetConnectNotifier(sConnectNotifier);
  364. gpfnDbgDrv = IMG_NULL;
  365. }
  366. IMG_VOID PDumpDeInit(IMG_VOID)
  367. {
  368. IMG_UINT32 i;
  369. DBGKM_CONNECT_NOTIFIER sConnectNotifier;
  370. for(i=0; i < PDUMP_NUM_STREAMS; i++)
  371. {
  372. gpfnDbgDrv->pfnDestroyStream(gsDBGPdumpState.psStream[i]);
  373. }
  374. if(gsDBGPdumpState.pszFile)
  375. {
  376. OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_FILENAME_SIZE_MAX, (IMG_PVOID) gsDBGPdumpState.pszFile, 0);
  377. gsDBGPdumpState.pszFile = IMG_NULL;
  378. }
  379. if(gsDBGPdumpState.pszScript)
  380. {
  381. OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_SCRIPT_SIZE_MAX, (IMG_PVOID) gsDBGPdumpState.pszScript, 0);
  382. gsDBGPdumpState.pszScript = IMG_NULL;
  383. }
  384. if(gsDBGPdumpState.pszMsg)
  385. {
  386. OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_MSG_SIZE_MAX, (IMG_PVOID) gsDBGPdumpState.pszMsg, 0);
  387. gsDBGPdumpState.pszMsg = IMG_NULL;
  388. }
  389. sConnectNotifier.pfnConnectNotifier = 0;
  390. gpfnDbgDrv->pfnSetConnectNotifier(sConnectNotifier);
  391. gpfnDbgDrv = IMG_NULL;
  392. }
  393. PVRSRV_ERROR PDumpStartInitPhaseKM(IMG_VOID)
  394. {
  395. IMG_UINT32 i;
  396. if (gpfnDbgDrv)
  397. {
  398. PDUMPCOMMENT("Start Init Phase");
  399. for(i=0; i < PDUMP_NUM_STREAMS; i++)
  400. {
  401. gpfnDbgDrv->pfnStartInitPhase(gsDBGPdumpState.psStream[i]);
  402. }
  403. }
  404. return PVRSRV_OK;
  405. }
  406. PVRSRV_ERROR PDumpStopInitPhaseKM(IMG_VOID)
  407. {
  408. IMG_UINT32 i;
  409. if (gpfnDbgDrv)
  410. {
  411. PDUMPCOMMENT("Stop Init Phase");
  412. for(i=0; i < PDUMP_NUM_STREAMS; i++)
  413. {
  414. gpfnDbgDrv->pfnStopInitPhase(gsDBGPdumpState.psStream[i]);
  415. }
  416. }
  417. return PVRSRV_OK;
  418. }
  419. IMG_BOOL PDumpIsLastCaptureFrameKM(IMG_VOID)
  420. {
  421. return gpfnDbgDrv->pfnIsLastCaptureFrame(gsDBGPdumpState.psStream[PDUMP_STREAM_SCRIPT2]);
  422. }
  423. IMG_BOOL PDumpOSIsCaptureFrameKM(IMG_VOID)
  424. {
  425. if (PDumpSuspended())
  426. {
  427. return IMG_FALSE;
  428. }
  429. return gpfnDbgDrv->pfnIsCaptureFrame(gsDBGPdumpState.psStream[PDUMP_STREAM_SCRIPT2], IMG_FALSE);
  430. }
  431. PVRSRV_ERROR PDumpOSSetFrameKM(IMG_UINT32 ui32Frame)
  432. {
  433. IMG_UINT32 ui32Stream;
  434. for (ui32Stream = 0; ui32Stream < PDUMP_NUM_STREAMS; ui32Stream++)
  435. {
  436. if (gsDBGPdumpState.psStream[ui32Stream])
  437. {
  438. DbgSetFrame(gsDBGPdumpState.psStream[ui32Stream], ui32Frame);
  439. }
  440. }
  441. return PVRSRV_OK;
  442. }
  443. static IMG_BOOL PDumpWriteString2(IMG_CHAR * pszString, IMG_UINT32 ui32Flags)
  444. {
  445. return PDumpWriteILock(gsDBGPdumpState.psStream[PDUMP_STREAM_SCRIPT2], (IMG_UINT8 *) pszString, strlen(pszString), ui32Flags);
  446. }
  447. static IMG_BOOL PDumpWriteILock(PDBG_STREAM psStream, IMG_UINT8 *pui8Data, IMG_UINT32 ui32Count, IMG_UINT32 ui32Flags)
  448. {
  449. IMG_UINT32 ui32Written = 0;
  450. if ((psStream == IMG_NULL) || PDumpSuspended() || ((ui32Flags & PDUMP_FLAGS_NEVER) != 0))
  451. {
  452. PVR_DPF((PVR_DBG_MESSAGE, "PDumpWriteILock: Failed to write 0x%x bytes to stream 0x%x", ui32Count, (IMG_UINT32)psStream));
  453. return IMG_TRUE;
  454. }
  455. if (psStream == gsDBGPdumpState.psStream[PDUMP_STREAM_PARAM2])
  456. {
  457. IMG_UINT32 ui32ParamOutPos = gpfnDbgDrv->pfnGetStreamOffset(gsDBGPdumpState.psStream[PDUMP_STREAM_PARAM2]);
  458. if (ui32ParamOutPos + ui32Count > MAX_FILE_SIZE)
  459. {
  460. if ((gsDBGPdumpState.psStream[PDUMP_STREAM_SCRIPT2] && PDumpWriteString2("\r\n-- Splitting pdump output file\r\n\r\n", ui32Flags)))
  461. {
  462. DbgSetMarker(gsDBGPdumpState.psStream[PDUMP_STREAM_PARAM2], ui32ParamOutPos);
  463. gsDBGPdumpState.ui32ParamFileNum++;
  464. }
  465. }
  466. }
  467. ui32Written = DbgWrite(psStream, pui8Data, ui32Count, ui32Flags);
  468. if (ui32Written == 0xFFFFFFFF)
  469. {
  470. return IMG_FALSE;
  471. }
  472. return IMG_TRUE;
  473. }
  474. static IMG_VOID DbgSetFrame(PDBG_STREAM psStream, IMG_UINT32 ui32Frame)
  475. {
  476. gpfnDbgDrv->pfnSetFrame(psStream, ui32Frame);
  477. }
  478. static IMG_VOID DbgSetMarker(PDBG_STREAM psStream, IMG_UINT32 ui32Marker)
  479. {
  480. gpfnDbgDrv->pfnSetMarker(psStream, ui32Marker);
  481. }
  482. IMG_VOID PDumpSuspendKM(IMG_VOID)
  483. {
  484. atomic_inc(&gsPDumpSuspended);
  485. }
  486. IMG_VOID PDumpResumeKM(IMG_VOID)
  487. {
  488. atomic_dec(&gsPDumpSuspended);
  489. }
  490. #endif
  491. #endif