/drivers/gpu/pvr/pdump.c
C | 628 lines | 466 code | 137 blank | 25 comment | 66 complexity | b79f5009e67b21a1af5b6b434045750b MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.0, AGPL-1.0
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
27#if defined (SUPPORT_SGX) || defined (SUPPORT_VGX)
28#if defined (PDUMP)
29
30#include <asm/atomic.h>
31#include <stdarg.h>
32#if defined (SUPPORT_SGX)
33#include "sgxdefs.h"
34#endif
35#include "services_headers.h"
36
37#include "pvrversion.h"
38#include "pvr_debug.h"
39
40#include "dbgdrvif.h"
41#if defined (SUPPORT_SGX)
42#include "sgxmmu.h"
43#endif
44#include "mm.h"
45#include "pdump_km.h"
46#include "pdump_int.h"
47
48#include <linux/kernel.h>
49#include <linux/string.h>
50
51static IMG_BOOL PDumpWriteString2 (IMG_CHAR * pszString, IMG_UINT32 ui32Flags);
52static IMG_BOOL PDumpWriteILock (PDBG_STREAM psStream, IMG_UINT8 *pui8Data, IMG_UINT32 ui32Count, IMG_UINT32 ui32Flags);
53static IMG_VOID DbgSetFrame (PDBG_STREAM psStream, IMG_UINT32 ui32Frame);
54static IMG_VOID DbgSetMarker (PDBG_STREAM psStream, IMG_UINT32 ui32Marker);
55
56#define PDUMP_DATAMASTER_PIXEL (1)
57#define PDUMP_DATAMASTER_EDM (3)
58
59#define MAX_FILE_SIZE 0x40000000
60
61static atomic_t gsPDumpSuspended = ATOMIC_INIT(0);
62
63static PDBGKM_SERVICE_TABLE gpfnDbgDrv = IMG_NULL;
64
65
66
67IMG_CHAR *pszStreamName[PDUMP_NUM_STREAMS] = { "ParamStream2",
68 "ScriptStream2",
69 "DriverInfoStream"};
70typedef struct PDBG_PDUMP_STATE_TAG
71{
72 PDBG_STREAM psStream[PDUMP_NUM_STREAMS];
73 IMG_UINT32 ui32ParamFileNum;
74
75 IMG_CHAR *pszMsg;
76 IMG_CHAR *pszScript;
77 IMG_CHAR *pszFile;
78
79} PDBG_PDUMP_STATE;
80
81static PDBG_PDUMP_STATE gsDBGPdumpState = {{IMG_NULL}, 0, IMG_NULL, IMG_NULL, IMG_NULL};
82
83#define SZ_MSG_SIZE_MAX PVRSRV_PDUMP_MAX_COMMENT_SIZE-1
84#define SZ_SCRIPT_SIZE_MAX PVRSRV_PDUMP_MAX_COMMENT_SIZE-1
85#define SZ_FILENAME_SIZE_MAX PVRSRV_PDUMP_MAX_COMMENT_SIZE-1
86
87
88
89
90IMG_VOID DBGDrvGetServiceTable(IMG_VOID **fn_table);
91
92static inline IMG_BOOL PDumpSuspended(IMG_VOID)
93{
94 return (atomic_read(&gsPDumpSuspended) != 0) ? IMG_TRUE : IMG_FALSE;
95}
96
97PVRSRV_ERROR PDumpOSGetScriptString(IMG_HANDLE *phScript,
98 IMG_UINT32 *pui32MaxLen)
99{
100 *phScript = (IMG_HANDLE)gsDBGPdumpState.pszScript;
101 *pui32MaxLen = SZ_SCRIPT_SIZE_MAX;
102 if ((!*phScript) || PDumpSuspended())
103 {
104 return PVRSRV_ERROR_PDUMP_NOT_ACTIVE;
105 }
106 return PVRSRV_OK;
107}
108
109PVRSRV_ERROR PDumpOSGetMessageString(IMG_CHAR **ppszMsg,
110 IMG_UINT32 *pui32MaxLen)
111{
112 *ppszMsg = gsDBGPdumpState.pszMsg;
113 *pui32MaxLen = SZ_MSG_SIZE_MAX;
114 if ((!*ppszMsg) || PDumpSuspended())
115 {
116 return PVRSRV_ERROR_PDUMP_NOT_ACTIVE;
117 }
118 return PVRSRV_OK;
119}
120
121PVRSRV_ERROR PDumpOSGetFilenameString(IMG_CHAR **ppszFile,
122 IMG_UINT32 *pui32MaxLen)
123{
124 *ppszFile = gsDBGPdumpState.pszFile;
125 *pui32MaxLen = SZ_FILENAME_SIZE_MAX;
126 if ((!*ppszFile) || PDumpSuspended())
127 {
128 return PVRSRV_ERROR_PDUMP_NOT_ACTIVE;
129 }
130 return PVRSRV_OK;
131}
132
133IMG_BOOL PDumpOSWriteString2(IMG_HANDLE hScript, IMG_UINT32 ui32Flags)
134{
135 return PDumpWriteString2(hScript, ui32Flags);
136}
137
138PVRSRV_ERROR PDumpOSBufprintf(IMG_HANDLE hBuf, IMG_UINT32 ui32ScriptSizeMax, IMG_CHAR* pszFormat, ...)
139{
140 IMG_CHAR* pszBuf = hBuf;
141 IMG_INT32 n;
142 va_list vaArgs;
143
144 va_start(vaArgs, pszFormat);
145
146 n = vsnprintf(pszBuf, ui32ScriptSizeMax, pszFormat, vaArgs);
147
148 va_end(vaArgs);
149
150 if (n>=(IMG_INT32)ui32ScriptSizeMax || n==-1)
151 {
152 PVR_DPF((PVR_DBG_ERROR, "Buffer overflow detected, pdump output may be incomplete."));
153
154 return PVRSRV_ERROR_PDUMP_BUF_OVERFLOW;
155 }
156
157#if defined(PDUMP_DEBUG_OUTFILES)
158 g_ui32EveryLineCounter++;
159#endif
160 return PVRSRV_OK;
161}
162
163PVRSRV_ERROR PDumpOSVSprintf(IMG_CHAR *pszComment, IMG_UINT32 ui32ScriptSizeMax, IMG_CHAR* pszFormat, PDUMP_va_list vaArgs)
164{
165 IMG_INT32 n;
166
167 n = vsnprintf(pszComment, ui32ScriptSizeMax, pszFormat, vaArgs);
168
169 if (n>=(IMG_INT32)ui32ScriptSizeMax || n==-1)
170 {
171 PVR_DPF((PVR_DBG_ERROR, "Buffer overflow detected, pdump output may be incomplete."));
172
173 return PVRSRV_ERROR_PDUMP_BUF_OVERFLOW;
174 }
175
176 return PVRSRV_OK;
177}
178
179IMG_VOID PDumpOSDebugPrintf(IMG_CHAR* pszFormat, ...)
180{
181 PVR_UNREFERENCED_PARAMETER(pszFormat);
182
183
184}
185
186PVRSRV_ERROR PDumpOSSprintf(IMG_CHAR *pszComment, IMG_UINT32 ui32ScriptSizeMax, IMG_CHAR *pszFormat, ...)
187{
188 IMG_INT32 n;
189 va_list vaArgs;
190
191 va_start(vaArgs, pszFormat);
192
193 n = vsnprintf(pszComment, ui32ScriptSizeMax, pszFormat, vaArgs);
194
195 va_end(vaArgs);
196
197 if (n>=(IMG_INT32)ui32ScriptSizeMax || n==-1)
198 {
199 PVR_DPF((PVR_DBG_ERROR, "Buffer overflow detected, pdump output may be incomplete."));
200
201 return PVRSRV_ERROR_PDUMP_BUF_OVERFLOW;
202 }
203
204 return PVRSRV_OK;
205}
206
207IMG_UINT32 PDumpOSBuflen(IMG_HANDLE hBuffer, IMG_UINT32 ui32BufferSizeMax)
208{
209 IMG_CHAR* pszBuf = hBuffer;
210 IMG_UINT32 ui32Count = 0;
211
212 while ((pszBuf[ui32Count]!=0) && (ui32Count<ui32BufferSizeMax) )
213 {
214 ui32Count++;
215 }
216 return(ui32Count);
217}
218
219IMG_VOID PDumpOSVerifyLineEnding(IMG_HANDLE hBuffer, IMG_UINT32 ui32BufferSizeMax)
220{
221 IMG_UINT32 ui32Count;
222 IMG_CHAR* pszBuf = hBuffer;
223
224
225 ui32Count = PDumpOSBuflen(hBuffer, ui32BufferSizeMax);
226
227
228 if ((ui32Count >= 1) && (pszBuf[ui32Count-1] != '\n') && (ui32Count<ui32BufferSizeMax))
229 {
230 pszBuf[ui32Count] = '\n';
231 ui32Count++;
232 pszBuf[ui32Count] = '\0';
233 }
234 if ((ui32Count >= 2) && (pszBuf[ui32Count-2] != '\r') && (ui32Count<ui32BufferSizeMax))
235 {
236 pszBuf[ui32Count-1] = '\r';
237 pszBuf[ui32Count] = '\n';
238 ui32Count++;
239 pszBuf[ui32Count] = '\0';
240 }
241}
242
243IMG_HANDLE PDumpOSGetStream(IMG_UINT32 ePDumpStream)
244{
245 return (IMG_HANDLE)gsDBGPdumpState.psStream[ePDumpStream];
246}
247
248IMG_UINT32 PDumpOSGetStreamOffset(IMG_UINT32 ePDumpStream)
249{
250 PDBG_STREAM psStream = gsDBGPdumpState.psStream[ePDumpStream];
251 return gpfnDbgDrv->pfnGetStreamOffset(psStream);
252}
253
254IMG_UINT32 PDumpOSGetParamFileNum(IMG_VOID)
255{
256 return gsDBGPdumpState.ui32ParamFileNum;
257}
258
259IMG_BOOL PDumpOSWriteString(IMG_HANDLE hStream,
260 IMG_UINT8 *psui8Data,
261 IMG_UINT32 ui32Size,
262 IMG_UINT32 ui32Flags)
263{
264 PDBG_STREAM psStream = (PDBG_STREAM)hStream;
265 return PDumpWriteILock(psStream,
266 psui8Data,
267 ui32Size,
268 ui32Flags);
269}
270
271IMG_VOID PDumpOSCheckForSplitting(IMG_HANDLE hStream, IMG_UINT32 ui32Size, IMG_UINT32 ui32Flags)
272{
273
274 PVR_UNREFERENCED_PARAMETER(hStream);
275 PVR_UNREFERENCED_PARAMETER(ui32Size);
276 PVR_UNREFERENCED_PARAMETER(ui32Flags);
277}
278
279IMG_BOOL PDumpOSJTInitialised(IMG_VOID)
280{
281 if(gpfnDbgDrv)
282 {
283 return IMG_TRUE;
284 }
285 return IMG_FALSE;
286}
287
288inline IMG_BOOL PDumpOSIsSuspended(IMG_VOID)
289{
290 return (atomic_read(&gsPDumpSuspended) != 0) ? IMG_TRUE : IMG_FALSE;
291}
292
293IMG_VOID PDumpOSCPUVAddrToDevPAddr(PVRSRV_DEVICE_TYPE eDeviceType,
294 IMG_HANDLE hOSMemHandle,
295 IMG_UINT32 ui32Offset,
296 IMG_UINT8 *pui8LinAddr,
297 IMG_UINT32 ui32PageSize,
298 IMG_DEV_PHYADDR *psDevPAddr)
299{
300 IMG_CPU_PHYADDR sCpuPAddr;
301
302 PVR_UNREFERENCED_PARAMETER(pui8LinAddr);
303 PVR_UNREFERENCED_PARAMETER(ui32PageSize);
304
305
306
307 PVR_ASSERT (hOSMemHandle != IMG_NULL);
308
309 sCpuPAddr = OSMemHandleToCpuPAddr(hOSMemHandle, ui32Offset);
310 PVR_ASSERT((sCpuPAddr.uiAddr & (ui32PageSize - 1)) == 0);
311
312
313 *psDevPAddr = SysCpuPAddrToDevPAddr(eDeviceType, sCpuPAddr);
314}
315
316IMG_VOID PDumpOSCPUVAddrToPhysPages(IMG_HANDLE hOSMemHandle,
317 IMG_UINT32 ui32Offset,
318 IMG_PUINT8 pui8LinAddr,
319 IMG_UINT32 ui32DataPageMask,
320 IMG_UINT32 *pui32PageOffset)
321{
322 if(hOSMemHandle)
323 {
324
325 IMG_CPU_PHYADDR sCpuPAddr;
326
327 PVR_UNREFERENCED_PARAMETER(pui8LinAddr);
328
329 sCpuPAddr = OSMemHandleToCpuPAddr(hOSMemHandle, ui32Offset);
330 *pui32PageOffset = sCpuPAddr.uiAddr & ui32DataPageMask;
331 }
332 else
333 {
334 PVR_UNREFERENCED_PARAMETER(hOSMemHandle);
335 PVR_UNREFERENCED_PARAMETER(ui32Offset);
336
337 *pui32PageOffset = ((IMG_UINT32)pui8LinAddr & ui32DataPageMask);
338 }
339}
340
341IMG_UINT32 PDumpOSDebugDriverWrite( PDBG_STREAM psStream,
342 PDUMP_DDWMODE eDbgDrvWriteMode,
343 IMG_UINT8 *pui8Data,
344 IMG_UINT32 ui32BCount,
345 IMG_UINT32 ui32Level,
346 IMG_UINT32 ui32DbgDrvFlags)
347{
348 switch(eDbgDrvWriteMode)
349 {
350 case PDUMP_WRITE_MODE_CONTINUOUS:
351 PVR_UNREFERENCED_PARAMETER(ui32DbgDrvFlags);
352 return gpfnDbgDrv->pfnDBGDrivWrite2(psStream, pui8Data, ui32BCount, ui32Level);
353 case PDUMP_WRITE_MODE_LASTFRAME:
354 return gpfnDbgDrv->pfnWriteLF(psStream, pui8Data, ui32BCount, ui32Level, ui32DbgDrvFlags);
355 case PDUMP_WRITE_MODE_BINCM:
356 PVR_UNREFERENCED_PARAMETER(ui32DbgDrvFlags);
357 return gpfnDbgDrv->pfnWriteBINCM(psStream, pui8Data, ui32BCount, ui32Level);
358 case PDUMP_WRITE_MODE_PERSISTENT:
359 PVR_UNREFERENCED_PARAMETER(ui32DbgDrvFlags);
360 return gpfnDbgDrv->pfnWritePersist(psStream, pui8Data, ui32BCount, ui32Level);
361 default:
362 PVR_UNREFERENCED_PARAMETER(ui32DbgDrvFlags);
363 break;
364 }
365 return 0xFFFFFFFFU;
366}
367
368IMG_VOID PDumpOSReleaseExecution(IMG_VOID)
369{
370 OSReleaseThreadQuanta();
371}
372
373IMG_VOID PDumpInit(IMG_VOID)
374{
375 IMG_UINT32 i;
376 DBGKM_CONNECT_NOTIFIER sConnectNotifier;
377
378
379 if (!gpfnDbgDrv)
380 {
381 DBGDrvGetServiceTable((IMG_VOID **)&gpfnDbgDrv);
382
383
384
385 if (gpfnDbgDrv == IMG_NULL)
386 {
387 return;
388 }
389
390
391 sConnectNotifier.pfnConnectNotifier = &PDumpConnectionNotify;
392 gpfnDbgDrv->pfnSetConnectNotifier(sConnectNotifier);
393
394 if(!gsDBGPdumpState.pszFile)
395 {
396 if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_FILENAME_SIZE_MAX, (IMG_PVOID *)&gsDBGPdumpState.pszFile, 0,
397 "Filename string") != PVRSRV_OK)
398 {
399 goto init_failed;
400 }
401 }
402
403 if(!gsDBGPdumpState.pszMsg)
404 {
405 if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_MSG_SIZE_MAX, (IMG_PVOID *)&gsDBGPdumpState.pszMsg, 0,
406 "Message string") != PVRSRV_OK)
407 {
408 goto init_failed;
409 }
410 }
411
412 if(!gsDBGPdumpState.pszScript)
413 {
414 if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_SCRIPT_SIZE_MAX, (IMG_PVOID *)&gsDBGPdumpState.pszScript, 0,
415 "Script string") != PVRSRV_OK)
416 {
417 goto init_failed;
418 }
419 }
420
421 for(i=0; i < PDUMP_NUM_STREAMS; i++)
422 {
423 gsDBGPdumpState.psStream[i] = gpfnDbgDrv->pfnCreateStream(pszStreamName[i],
424 DEBUG_CAPMODE_FRAMED,
425 DEBUG_OUTMODE_STREAMENABLE,
426 0,
427 10);
428
429 gpfnDbgDrv->pfnSetCaptureMode(gsDBGPdumpState.psStream[i],DEBUG_CAPMODE_FRAMED,0xFFFFFFFF, 0xFFFFFFFF, 1);
430 gpfnDbgDrv->pfnSetFrame(gsDBGPdumpState.psStream[i],0);
431 }
432
433 PDUMPCOMMENT("Driver Product Name: %s", VS_PRODUCT_NAME);
434 PDUMPCOMMENT("Driver Product Version: %s (%s)", PVRVERSION_STRING, PVRVERSION_FAMILY);
435 PDUMPCOMMENT("Start of Init Phase");
436 }
437
438 return;
439
440init_failed:
441
442 if(gsDBGPdumpState.pszFile)
443 {
444 OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_FILENAME_SIZE_MAX, (IMG_PVOID) gsDBGPdumpState.pszFile, 0);
445 gsDBGPdumpState.pszFile = IMG_NULL;
446 }
447
448 if(gsDBGPdumpState.pszScript)
449 {
450 OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_SCRIPT_SIZE_MAX, (IMG_PVOID) gsDBGPdumpState.pszScript, 0);
451 gsDBGPdumpState.pszScript = IMG_NULL;
452 }
453
454 if(gsDBGPdumpState.pszMsg)
455 {
456 OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_MSG_SIZE_MAX, (IMG_PVOID) gsDBGPdumpState.pszMsg, 0);
457 gsDBGPdumpState.pszMsg = IMG_NULL;
458 }
459
460
461 sConnectNotifier.pfnConnectNotifier = 0;
462 gpfnDbgDrv->pfnSetConnectNotifier(sConnectNotifier);
463
464 gpfnDbgDrv = IMG_NULL;
465}
466
467
468IMG_VOID PDumpDeInit(IMG_VOID)
469{
470 IMG_UINT32 i;
471 DBGKM_CONNECT_NOTIFIER sConnectNotifier;
472
473 for(i=0; i < PDUMP_NUM_STREAMS; i++)
474 {
475 gpfnDbgDrv->pfnDestroyStream(gsDBGPdumpState.psStream[i]);
476 }
477
478 if(gsDBGPdumpState.pszFile)
479 {
480 OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_FILENAME_SIZE_MAX, (IMG_PVOID) gsDBGPdumpState.pszFile, 0);
481 gsDBGPdumpState.pszFile = IMG_NULL;
482 }
483
484 if(gsDBGPdumpState.pszScript)
485 {
486 OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_SCRIPT_SIZE_MAX, (IMG_PVOID) gsDBGPdumpState.pszScript, 0);
487 gsDBGPdumpState.pszScript = IMG_NULL;
488 }
489
490 if(gsDBGPdumpState.pszMsg)
491 {
492 OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_MSG_SIZE_MAX, (IMG_PVOID) gsDBGPdumpState.pszMsg, 0);
493 gsDBGPdumpState.pszMsg = IMG_NULL;
494 }
495
496
497 sConnectNotifier.pfnConnectNotifier = 0;
498 gpfnDbgDrv->pfnSetConnectNotifier(sConnectNotifier);
499
500 gpfnDbgDrv = IMG_NULL;
501}
502
503PVRSRV_ERROR PDumpStartInitPhaseKM(IMG_VOID)
504{
505 IMG_UINT32 i;
506
507 if (gpfnDbgDrv)
508 {
509 PDUMPCOMMENT("Start Init Phase");
510 for(i=0; i < PDUMP_NUM_STREAMS; i++)
511 {
512 gpfnDbgDrv->pfnStartInitPhase(gsDBGPdumpState.psStream[i]);
513 }
514 }
515 return PVRSRV_OK;
516}
517
518PVRSRV_ERROR PDumpStopInitPhaseKM(IMG_VOID)
519{
520 IMG_UINT32 i;
521
522 if (gpfnDbgDrv)
523 {
524 PDUMPCOMMENT("Stop Init Phase");
525
526 for(i=0; i < PDUMP_NUM_STREAMS; i++)
527 {
528 gpfnDbgDrv->pfnStopInitPhase(gsDBGPdumpState.psStream[i]);
529 }
530 }
531 return PVRSRV_OK;
532}
533
534IMG_BOOL PDumpIsLastCaptureFrameKM(IMG_VOID)
535{
536 return gpfnDbgDrv->pfnIsLastCaptureFrame(gsDBGPdumpState.psStream[PDUMP_STREAM_SCRIPT2]);
537}
538
539
540IMG_BOOL PDumpOSIsCaptureFrameKM(IMG_VOID)
541{
542 if (PDumpSuspended())
543 {
544 return IMG_FALSE;
545 }
546 return gpfnDbgDrv->pfnIsCaptureFrame(gsDBGPdumpState.psStream[PDUMP_STREAM_SCRIPT2], IMG_FALSE);
547}
548
549PVRSRV_ERROR PDumpOSSetFrameKM(IMG_UINT32 ui32Frame)
550{
551 IMG_UINT32 ui32Stream;
552
553 for (ui32Stream = 0; ui32Stream < PDUMP_NUM_STREAMS; ui32Stream++)
554 {
555 if (gsDBGPdumpState.psStream[ui32Stream])
556 {
557 DbgSetFrame(gsDBGPdumpState.psStream[ui32Stream], ui32Frame);
558 }
559 }
560
561 return PVRSRV_OK;
562}
563
564
565static IMG_BOOL PDumpWriteString2(IMG_CHAR * pszString, IMG_UINT32 ui32Flags)
566{
567 return PDumpWriteILock(gsDBGPdumpState.psStream[PDUMP_STREAM_SCRIPT2], (IMG_UINT8 *) pszString, strlen(pszString), ui32Flags);
568}
569
570
571static IMG_BOOL PDumpWriteILock(PDBG_STREAM psStream, IMG_UINT8 *pui8Data, IMG_UINT32 ui32Count, IMG_UINT32 ui32Flags)
572{
573 IMG_UINT32 ui32Written = 0;
574 if ((psStream == IMG_NULL) || PDumpSuspended() || ((ui32Flags & PDUMP_FLAGS_NEVER) != 0))
575 {
576 PVR_DPF((PVR_DBG_MESSAGE, "PDumpWriteILock: Failed to write 0x%x bytes to stream 0x%x", ui32Count, (IMG_UINT32)psStream));
577 return IMG_TRUE;
578 }
579
580
581
582
583 if (psStream == gsDBGPdumpState.psStream[PDUMP_STREAM_PARAM2])
584 {
585 IMG_UINT32 ui32ParamOutPos = gpfnDbgDrv->pfnGetStreamOffset(gsDBGPdumpState.psStream[PDUMP_STREAM_PARAM2]);
586
587 if (ui32ParamOutPos + ui32Count > MAX_FILE_SIZE)
588 {
589 if ((gsDBGPdumpState.psStream[PDUMP_STREAM_SCRIPT2] && PDumpWriteString2("\r\n-- Splitting pdump output file\r\n\r\n", ui32Flags)))
590 {
591 DbgSetMarker(gsDBGPdumpState.psStream[PDUMP_STREAM_PARAM2], ui32ParamOutPos);
592 gsDBGPdumpState.ui32ParamFileNum++;
593 }
594 }
595 }
596
597 ui32Written = DbgWrite(psStream, pui8Data, ui32Count, ui32Flags);
598
599 if (ui32Written == 0xFFFFFFFF)
600 {
601 return IMG_FALSE;
602 }
603
604 return IMG_TRUE;
605}
606
607static IMG_VOID DbgSetFrame(PDBG_STREAM psStream, IMG_UINT32 ui32Frame)
608{
609 gpfnDbgDrv->pfnSetFrame(psStream, ui32Frame);
610}
611
612static IMG_VOID DbgSetMarker(PDBG_STREAM psStream, IMG_UINT32 ui32Marker)
613{
614 gpfnDbgDrv->pfnSetMarker(psStream, ui32Marker);
615}
616
617IMG_VOID PDumpSuspendKM(IMG_VOID)
618{
619 atomic_inc(&gsPDumpSuspended);
620}
621
622IMG_VOID PDumpResumeKM(IMG_VOID)
623{
624 atomic_dec(&gsPDumpSuspended);
625}
626
627#endif
628#endif