3 * Copyright(c) 2008 Imagination Technologies Ltd. All rights reserved.
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.
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.
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.
18 * The full GNU General Public License is included in this distribution in
19 * the file called "COPYING".
21 * Contact Information:
22 * Imagination Technologies Ltd. <gpl-support@imgtec.com>
23 * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK
27 #include <asm/atomic.h>
31 #include "services_headers.h"
32 #include "pvrversion.h"
36 #include "pvr_pdump.h"
37 #include "pvr_pdumpfs.h"
40 * There is no sense in having SGX_MMU_PAGE_SIZE differ from PAGE_SIZE.
41 * Especially the calculations in this file, while obviously an attempt to work
42 * around possibly differing host and gpu page sizes, are impossible when
43 * page size is not the same everywhere.
45 #if PAGE_SIZE != SGX_MMU_PAGE_SIZE
46 #error Host page size differs from GPU page size!
49 static atomic_t gsPDumpSuspended = ATOMIC_INIT(0);
51 #define SZ_COMMENT_SIZE_MAX PVRSRV_PDUMP_MAX_COMMENT_SIZE
52 #define SZ_SCRIPT_SIZE_MAX (SZ_COMMENT_SIZE_MAX + 5)
53 #define SZ_FILENAME_SIZE_MAX SZ_COMMENT_SIZE_MAX
54 static char *gpszComment;
55 static char *gpszScript;
56 static char *gpszFile;
58 void PDumpSuspendKM(void)
60 atomic_inc(&gsPDumpSuspended);
63 void PDumpResumeKM(void)
65 atomic_dec(&gsPDumpSuspended);
68 static inline IMG_BOOL PDumpSuspended(void)
70 return atomic_read(&gsPDumpSuspended) != 0;
74 pdump_print(u32 flags, char *format, ...)
81 if (!pdumpfs_flags_check(flags))
85 vsnprintf(gpszScript, SZ_SCRIPT_SIZE_MAX, format, ap);
88 pdumpfs_write_string(gpszScript);
91 static enum PVRSRV_ERROR
92 pdump_dump(u32 flags, void *buffer, u32 size, bool from_user)
94 enum PVRSRV_ERROR eError;
99 if (!pdumpfs_flags_check(flags))
102 pdump_print(flags, "BIN 0x%08X:", size);
104 eError = pdumpfs_write_data(buffer, size, from_user);
106 pdump_print(flags, "-- BIN END\r\n");
111 void PDumpCommentKM(char *pszComment, u32 ui32Flags)
113 int len = strlen(pszComment);
115 if ((len > 1) && (pszComment[len - 1] == '\n'))
116 pszComment[len - 1] = 0;
118 if ((len > 2) && (pszComment[len - 2] == '\r'))
119 pszComment[len - 2] = 0;
121 pdump_print(ui32Flags, "-- %s\r\n", pszComment);
124 void PDumpComment(char *pszFormat, ...)
128 va_start(ap, pszFormat);
129 vsnprintf(gpszComment, SZ_COMMENT_SIZE_MAX, pszFormat, ap);
132 PDumpCommentKM(gpszComment, PDUMP_FLAGS_CONTINUOUS);
135 void PDumpCommentWithFlags(u32 ui32Flags, char *pszFormat, ...)
139 va_start(ap, pszFormat);
140 vsnprintf(gpszComment, SZ_COMMENT_SIZE_MAX, pszFormat, ap);
143 PDumpCommentKM(gpszComment, ui32Flags);
146 void PDumpSetFrameKM(u32 ui32PID, u32 ui32Frame)
148 if (PDumpSuspended())
151 PDumpComment("Ending current Frame\r\n");
152 pdumpfs_frame_set(ui32PID, ui32Frame);
153 PDumpComment("PID %d: Starting Frame %d\r\n", ui32PID, ui32Frame);
156 IMG_BOOL PDumpIsCaptureFrameKM(void)
158 if (PDumpSuspended())
161 return pdumpfs_capture_enabled();
167 if (OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
168 SZ_FILENAME_SIZE_MAX,
174 if (OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
176 (void **)&gpszComment,
181 if (OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
183 (void **)&gpszScript,
187 if (pdumpfs_init()) {
188 pr_err("%s: pdumpfs_init failed.\n", __func__);
192 PDumpComment("Driver Product Name: %s", VS_PRODUCT_NAME);
193 PDumpComment("Driver Product Version: %s (%s)",
194 PVRVERSION_STRING, PVRVERSION_FILE);
195 PDumpComment("Start of Init Phase");
202 OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_FILENAME_SIZE_MAX,
203 (void *)gpszFile, NULL);
208 OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_SCRIPT_SIZE_MAX,
209 (void *)gpszScript, NULL);
214 OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_COMMENT_SIZE_MAX,
215 (void *)gpszComment, NULL);
220 void PDumpDeInit(void)
225 OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_FILENAME_SIZE_MAX,
226 (void *)gpszFile, NULL);
231 OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_SCRIPT_SIZE_MAX,
232 (void *)gpszScript, NULL);
237 OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_COMMENT_SIZE_MAX,
238 (void *)gpszComment, NULL);
243 void PDumpRegWithFlagsKM(u32 ui32Reg, u32 ui32Data, u32 ui32Flags)
245 pdump_print(ui32Flags,
246 "WRW :SGXREG:0x%8.8X 0x%8.8X\r\n", ui32Reg, ui32Data);
249 void PDumpReg(u32 ui32Reg, u32 ui32Data)
251 PDumpRegWithFlagsKM(ui32Reg, ui32Data, PDUMP_FLAGS_CONTINUOUS);
254 void PDumpRegPolWithFlagsKM(u32 ui32RegAddr, u32 ui32RegValue,
255 u32 ui32Mask, u32 ui32Flags)
257 #define POLL_DELAY 1000
258 #define POLL_COUNT_LONG (2000000000 / POLL_DELAY)
259 #define POLL_COUNT_SHORT (1000000 / POLL_DELAY)
263 if ((ui32RegAddr == EUR_CR_EVENT_STATUS) &&
264 ((ui32RegValue & ui32Mask) &
265 (EUR_CR_EVENT_STATUS_TA_FINISHED_MASK |
266 EUR_CR_EVENT_STATUS_PIXELBE_END_RENDER_MASK |
267 EUR_CR_EVENT_STATUS_DPM_3D_MEM_FREE_MASK)))
268 ui32PollCount = POLL_COUNT_LONG;
270 ui32PollCount = POLL_COUNT_SHORT;
272 pdump_print(ui32Flags,
273 "POL :SGXREG:0x%8.8X 0x%8.8X 0x%8.8X %d %u %d\r\n",
274 ui32RegAddr, ui32RegValue, ui32Mask, 0, ui32PollCount,
278 void PDumpRegPolKM(u32 ui32RegAddr, u32 ui32RegValue, u32 ui32Mask)
280 PDumpRegPolWithFlagsKM(ui32RegAddr, ui32RegValue, ui32Mask,
281 PDUMP_FLAGS_CONTINUOUS);
284 void PDumpMallocPages(u32 ui32DevVAddr, void *hOSMemHandle,
285 u32 ui32NumBytes, void *hUniqueTag)
287 struct IMG_CPU_PHYADDR sCpuPAddr;
288 struct IMG_DEV_PHYADDR sDevPAddr;
291 PVR_ASSERT(((u32) ui32DevVAddr & ~PAGE_MASK) == 0);
292 PVR_ASSERT(hOSMemHandle);
293 PVR_ASSERT(((u32) ui32NumBytes & ~PAGE_MASK) == 0);
295 PDumpComment("MALLOC :SGXMEM:VA_%8.8X 0x%8.8X %u\r\n",
296 ui32DevVAddr, ui32NumBytes, PAGE_SIZE);
298 for (ui32Offset = 0; ui32Offset < ui32NumBytes;
299 ui32Offset += PAGE_SIZE) {
300 sCpuPAddr = OSMemHandleToCpuPAddr(hOSMemHandle, ui32Offset);
301 sDevPAddr = SysCpuPAddrToDevPAddr(0, sCpuPAddr);
303 pdump_print(PDUMP_FLAGS_CONTINUOUS,
304 "MALLOC :SGXMEM:PA_%8.8X%8.8X %u %u 0x%8.8X\r\n",
305 (u32)hUniqueTag, sDevPAddr.uiAddr, PAGE_SIZE,
306 PAGE_SIZE, sDevPAddr.uiAddr);
310 void PDumpMallocPageTable(void *pvLinAddr, void *hUniqueTag)
312 struct IMG_CPU_PHYADDR sCpuPAddr;
313 struct IMG_DEV_PHYADDR sDevPAddr;
315 PVR_ASSERT(((u32) pvLinAddr & ~PAGE_MASK) == 0);
317 PDumpComment("MALLOC :SGXMEM:PAGE_TABLE 0x%8.8X %lu\r\n",
318 PAGE_SIZE, PAGE_SIZE);
320 sCpuPAddr = OSMapLinToCPUPhys(pvLinAddr);
321 sDevPAddr = SysCpuPAddrToDevPAddr(0, sCpuPAddr);
323 pdump_print(PDUMP_FLAGS_CONTINUOUS, "MALLOC :SGXMEM:PA_%8.8X%8.8lX "
324 "0x%lX %lu 0x%8.8lX\r\n", (u32)hUniqueTag,
325 sDevPAddr.uiAddr, PAGE_SIZE,
326 PAGE_SIZE, sDevPAddr.uiAddr);
329 void PDumpFreePages(struct BM_HEAP *psBMHeap, struct IMG_DEV_VIRTADDR sDevVAddr,
330 u32 ui32NumBytes, void *hUniqueTag, IMG_BOOL bInterleaved)
332 struct IMG_DEV_PHYADDR sDevPAddr;
333 struct PVRSRV_DEVICE_NODE *psDeviceNode =
334 psBMHeap->pBMContext->psDeviceNode;
337 PVR_ASSERT(((u32) sDevVAddr.uiAddr & ~PAGE_MASK) == 0);
338 PVR_ASSERT(((u32) ui32NumBytes & ~PAGE_MASK) == 0);
340 PDumpComment("FREE :SGXMEM:VA_%8.8X\r\n", sDevVAddr.uiAddr);
342 for (i = 0; (i * PAGE_SIZE) < ui32NumBytes; i++) {
343 if (!bInterleaved || (i % 2) == 0) {
345 psDeviceNode->pfnMMUGetPhysPageAddr(psBMHeap->
348 pdump_print(PDUMP_FLAGS_CONTINUOUS,
349 "FREE :SGXMEM:PA_%8.8X%8.8X\r\n",
350 (u32)hUniqueTag, sDevPAddr.uiAddr);
353 sDevVAddr.uiAddr += PAGE_SIZE;
357 void PDumpFreePageTable(void *pvLinAddr)
359 struct IMG_CPU_PHYADDR sCpuPAddr;
360 struct IMG_DEV_PHYADDR sDevPAddr;
362 PVR_ASSERT(((u32) pvLinAddr & ~PAGE_MASK) == 0);
364 PDumpComment("FREE :SGXMEM:PAGE_TABLE\r\n");
366 sCpuPAddr = OSMapLinToCPUPhys(pvLinAddr);
367 sDevPAddr = SysCpuPAddrToDevPAddr(0, sCpuPAddr);
369 pdump_print(PDUMP_FLAGS_CONTINUOUS, "FREE :SGXMEM:PA_%8.8X%8.8lX\r\n",
370 PDUMP_PT_UNIQUETAG, sDevPAddr.uiAddr);
373 void PDumpPDRegWithFlags(u32 ui32Reg, u32 ui32Data, u32 ui32Flags)
375 pdump_print(ui32Flags,
376 "WRW :SGXREG:0x%8.8X :SGXMEM:PA_%8.8X%8.8lX:0x%8.8lX\r\n",
377 ui32Reg, PDUMP_PD_UNIQUETAG,
378 ui32Data & PAGE_MASK,
379 ui32Data & ~PAGE_MASK);
382 void PDumpPDReg(u32 ui32Reg, u32 ui32Data)
384 PDumpPDRegWithFlags(ui32Reg, ui32Data, PDUMP_FLAGS_CONTINUOUS);
387 void PDumpMemPolKM(struct PVRSRV_KERNEL_MEM_INFO *psMemInfo,
388 u32 ui32Offset, u32 ui32Value, u32 ui32Mask,
389 enum PDUMP_POLL_OPERATOR eOperator, void *hUniqueTag)
391 #define MEMPOLL_DELAY (1000)
392 #define MEMPOLL_COUNT (2000000000 / MEMPOLL_DELAY)
394 struct IMG_DEV_PHYADDR sDevPAddr;
395 struct IMG_DEV_VIRTADDR sDevVPageAddr;
398 PVR_ASSERT((ui32Offset + sizeof(u32)) <=
399 psMemInfo->ui32AllocSize);
401 sDevVPageAddr.uiAddr = psMemInfo->sDevVAddr.uiAddr + ui32Offset;
402 ui32PageOffset = sDevVPageAddr.uiAddr & ~PAGE_MASK;
403 BM_GetPhysPageAddr(psMemInfo, sDevVPageAddr, &sDevPAddr);
405 pdump_print(0, "POL :SGXMEM:PA_%8.8X%8.8lX:0x%8.8lX 0x%8.8X "
406 "0x%8.8X %d %d %d\r\n", (u32)hUniqueTag,
407 sDevPAddr.uiAddr, ui32PageOffset,
408 ui32Value, ui32Mask, eOperator,
409 MEMPOLL_COUNT, MEMPOLL_DELAY);
413 pdump_mem_print(u32 ui32Flags, struct PVRSRV_KERNEL_MEM_INFO *psMemInfo,
414 u32 ui32Offset, u32 ui32Bytes, void *hUniqueTag)
416 struct IMG_DEV_VIRTADDR sDevVPageAddr;
417 struct IMG_DEV_PHYADDR sDevPAddr;
420 PDumpCommentWithFlags(ui32Flags, "LDB :SGXMEM:VA_%8.8X:0x%8.8X "
422 psMemInfo->sDevVAddr.uiAddr, ui32Offset,
426 (psMemInfo->sDevVAddr.uiAddr + ui32Offset) & ~PAGE_MASK;
430 min(ui32Bytes, (u32)PAGE_SIZE - ui32PageOffset);
432 sDevVPageAddr.uiAddr =
433 psMemInfo->sDevVAddr.uiAddr + ui32Offset;
434 BM_GetPhysPageAddr(psMemInfo, sDevVPageAddr, &sDevPAddr);
436 pdump_print(ui32Flags, "LDB :SGXMEM:PA_%8.8X%8.8lX:0x%8.8lX"
437 " 0x%8.8X\r\n", (u32) hUniqueTag,
438 sDevPAddr.uiAddr, ui32PageOffset,
442 ui32Bytes -= ui32BlockBytes;
443 ui32Offset += ui32BlockBytes;
448 PDumpMemKM(void *pvAltLinAddr, struct PVRSRV_KERNEL_MEM_INFO *psMemInfo,
449 u32 ui32Offset, u32 ui32Bytes, u32 ui32Flags, void *hUniqueTag)
451 enum PVRSRV_ERROR eError;
453 PVR_ASSERT((ui32Offset + ui32Bytes) <= psMemInfo->ui32AllocSize);
456 return PVRSRV_ERROR_GENERIC;
459 eError = pdump_dump(ui32Flags, pvAltLinAddr, ui32Bytes, false);
460 else if (psMemInfo->pvLinAddrKM)
461 eError = pdump_dump(ui32Flags,
462 psMemInfo->pvLinAddrKM + ui32Offset,
465 return PVRSRV_ERROR_GENERIC;
467 if (eError != PVRSRV_OK)
470 pdump_mem_print(ui32Flags, psMemInfo, ui32Offset, ui32Bytes,
477 PDumpMemUM(void *pvAltLinAddrUM, void *pvLinAddrUM,
478 struct PVRSRV_KERNEL_MEM_INFO *psMemInfo,
479 u32 ui32Offset, u32 ui32Bytes, u32 ui32Flags, void *hUniqueTag)
481 enum PVRSRV_ERROR eError;
483 PVR_ASSERT((ui32Offset + ui32Bytes) <= psMemInfo->ui32AllocSize);
486 return PVRSRV_ERROR_GENERIC;
489 eError = pdump_dump(ui32Flags, pvAltLinAddrUM, ui32Bytes, true);
490 else if (psMemInfo->pvLinAddrKM)
491 eError = pdump_dump(ui32Flags,
492 psMemInfo->pvLinAddrKM + ui32Offset,
494 else if (pvLinAddrUM)
495 eError = pdump_dump(ui32Flags, pvLinAddrUM + ui32Offset,
498 return PVRSRV_ERROR_GENERIC;
500 if (eError != PVRSRV_OK)
503 pdump_mem_print(ui32Flags, psMemInfo, ui32Offset, ui32Bytes,
510 PDumpPageTableKM(void *pvLinAddr, u32 ui32Bytes, IMG_BOOL bInitialisePages,
511 void *hUniqueTag1, void *hUniqueTag2)
513 struct IMG_DEV_PHYADDR sDevPAddr;
514 struct IMG_CPU_PHYADDR sCpuPAddr;
515 enum PVRSRV_ERROR eError;
518 return PVRSRV_ERROR_GENERIC;
520 if (bInitialisePages) {
521 eError = pdump_dump(PDUMP_FLAGS_CONTINUOUS, pvLinAddr,
523 if (eError != PVRSRV_OK)
530 (u32)(PAGE_SIZE - ((u32)pvLinAddr & ~PAGE_MASK)));
532 sCpuPAddr = OSMapLinToCPUPhys(pvLinAddr);
533 sDevPAddr = SysCpuPAddrToDevPAddr(0, sCpuPAddr);
535 if (bInitialisePages) {
536 pdump_print(PDUMP_FLAGS_CONTINUOUS, "LDB :SGXMEM:"
537 "PA_%8.8X%8.8lX:0x%8.8lX 0x%8.8X\r\n",
539 sDevPAddr.uiAddr & PAGE_MASK,
540 sDevPAddr.uiAddr & ~PAGE_MASK,
545 for (ui32Offset = 0; ui32Offset < ui32BlockBytes;
546 ui32Offset += sizeof(u32)) {
548 *((u32 *)(pvLinAddr + ui32Offset));
550 if ((ui32PTE & ~PAGE_MASK) != 0) {
551 pdump_print(PDUMP_FLAGS_CONTINUOUS,
552 "WRW :SGXMEM:PA_%8.8X%8.8lX:0x%8.8lX :SGXMEM:PA_%8.8X%8.8lX:0x%8.8lX\r\n",
554 sDevPAddr.uiAddr & PAGE_MASK,
555 sDevPAddr.uiAddr & ~PAGE_MASK,
558 ui32PTE & ~PAGE_MASK);
563 pdump_print(PDUMP_FLAGS_CONTINUOUS,
564 "WRW :SGXMEM:PA_%8.8X%8.8lX:0x%8.8lX 0x%8.8X%8.8X\r\n",
566 sDevPAddr.uiAddr & PAGE_MASK,
567 sDevPAddr.uiAddr & ~PAGE_MASK,
568 ui32PTE, (u32)hUniqueTag2);
571 sDevPAddr.uiAddr += sizeof(u32);
575 ui32Bytes -= ui32BlockBytes;
576 pvLinAddr += ui32BlockBytes;
583 PDumpPDDevPAddrKM(struct PVRSRV_KERNEL_MEM_INFO *psMemInfo,
584 u32 ui32Offset, struct IMG_DEV_PHYADDR sPDDevPAddr,
585 void *hUniqueTag1, void *hUniqueTag2)
587 struct IMG_DEV_VIRTADDR sDevVPageAddr;
588 struct IMG_DEV_PHYADDR sDevPAddr;
591 sDevVPageAddr.uiAddr = psMemInfo->sDevVAddr.uiAddr + ui32Offset;
592 ui32PageOffset = sDevVPageAddr.uiAddr & ~PAGE_MASK;
593 BM_GetPhysPageAddr(psMemInfo, sDevVPageAddr, &sDevPAddr);
595 if ((sPDDevPAddr.uiAddr & PAGE_MASK) != 0) {
596 pdump_print(PDUMP_FLAGS_CONTINUOUS,
597 "WRW :SGXMEM:PA_%8.8X%8.8lX:0x%8.8lX :SGXMEM:PA_%8.8X%8.8lX:0x%8.8lX\r\n",
599 sDevPAddr.uiAddr, ui32PageOffset,
601 sPDDevPAddr.uiAddr & PAGE_MASK,
602 sPDDevPAddr.uiAddr & ~PAGE_MASK);
604 PVR_ASSERT(!(sDevPAddr.uiAddr & SGX_MMU_PTE_VALID));
605 pdump_print(PDUMP_FLAGS_CONTINUOUS,
606 "WRW :SGXMEM:PA_%8.8X%8.8lX:0x%8.8lX 0x%8.8X\r\n",
608 sDevPAddr.uiAddr, ui32PageOffset,
613 void PDumpBitmapKM(char *pszFileName, u32 ui32FileOffset,
614 u32 ui32Width, u32 ui32Height, u32 ui32StrideInBytes,
615 struct IMG_DEV_VIRTADDR sDevBaseAddr,
616 u32 ui32Size, enum PDUMP_PIXEL_FORMAT ePixelFormat,
617 enum PDUMP_MEM_FORMAT eMemFormat, u32 ui32PDumpFlags)
619 PDumpCommentWithFlags(ui32PDumpFlags, "Dump bitmap of render\r\n");
621 pdump_print(ui32PDumpFlags,
622 "SII %s %s.bin :SGXMEM:v:0x%08X 0x%08X "
623 "0x%08X 0x%08X 0x%08X 0x%08X 0x%08X 0x%08X\r\n",
624 pszFileName, pszFileName, sDevBaseAddr.uiAddr, ui32Size,
625 ui32FileOffset, ePixelFormat, ui32Width, ui32Height,
626 ui32StrideInBytes, eMemFormat);
629 static void PDumpReadRegKM(char *pszFileName, u32 ui32FileOffset,
632 pdump_print(0, "SAB :SGXREG:0x%08X 0x%08X %s\r\n",
633 ui32Address, ui32FileOffset, pszFileName);
636 void PDump3DSignatureRegisters(u32 ui32DumpFrameNum,
637 u32 *pui32Registers, u32 ui32NumRegisters)
641 PDumpCommentWithFlags(0, "Dump 3D signature registers\r\n");
642 snprintf(gpszFile, SZ_FILENAME_SIZE_MAX, "out%u_3d.sig",
645 for (i = 0; i < ui32NumRegisters; i++)
646 PDumpReadRegKM(gpszFile, i * sizeof(u32), pui32Registers[i]);
649 void PDumpCounterRegisters(u32 ui32DumpFrameNum,
650 u32 *pui32Registers, u32 ui32NumRegisters)
654 PDumpCommentWithFlags(0, "Dump counter registers\r\n");
655 snprintf(gpszFile, SZ_FILENAME_SIZE_MAX, "out%u.perf",
658 for (i = 0; i < ui32NumRegisters; i++)
659 PDumpReadRegKM(gpszFile, i * sizeof(u32), pui32Registers[i]);
662 void PDumpTASignatureRegisters(u32 ui32DumpFrameNum, u32 ui32TAKickCount,
663 u32 *pui32Registers, u32 ui32NumRegisters)
665 u32 i, ui32FileOffset;
667 PDumpCommentWithFlags(0, "Dump TA signature registers\r\n");
668 snprintf(gpszFile, SZ_FILENAME_SIZE_MAX, "out%u_ta.sig",
671 ui32FileOffset = ui32TAKickCount * ui32NumRegisters * sizeof(u32);
673 for (i = 0; i < ui32NumRegisters; i++)
674 PDumpReadRegKM(gpszFile, ui32FileOffset + i * sizeof(u32),
678 void PDumpRegRead(const u32 ui32RegOffset, u32 ui32Flags)
680 pdump_print(ui32Flags, "RDW :SGXREG:0x%X\r\n", ui32RegOffset);
683 void PDumpCycleCountRegRead(const u32 ui32RegOffset)
685 PDumpRegRead(ui32RegOffset, 0);
688 void PDumpHWPerfCBKM(char *pszFileName, u32 ui32FileOffset,
689 struct IMG_DEV_VIRTADDR sDevBaseAddr, u32 ui32Size,
692 PDumpCommentWithFlags(ui32PDumpFlags,
693 "Dump Hardware Performance Circular Buffer\r\n");
694 pdump_print(ui32PDumpFlags,
695 "SAB :SGXMEM:v:0x%08X 0x%08X 0x%08X %s.bin\r\n",
696 sDevBaseAddr.uiAddr, ui32Size, ui32FileOffset, pszFileName);
699 void PDumpCBP(struct PVRSRV_KERNEL_MEM_INFO *psROffMemInfo,
700 u32 ui32ROffOffset, u32 ui32WPosVal, u32 ui32PacketSize,
701 u32 ui32BufferSize, void *hUniqueTag)
703 struct IMG_DEV_PHYADDR sDevPAddr;
704 struct IMG_DEV_VIRTADDR sDevVPageAddr;
707 PVR_ASSERT((ui32ROffOffset + sizeof(u32)) <=
708 psROffMemInfo->ui32AllocSize);
710 sDevVPageAddr.uiAddr =
711 psROffMemInfo->sDevVAddr.uiAddr + ui32ROffOffset;
712 ui32PageOffset = sDevVPageAddr.uiAddr & ~PAGE_MASK;
713 BM_GetPhysPageAddr(psROffMemInfo, sDevVPageAddr, &sDevPAddr);
715 pdump_print(0, "CBP :SGXMEM:PA_%8.8X%8.8lX:0x%8.8lX 0x%8.8X"
716 " 0x%8.8X 0x%8.8X\r\n", (u32) hUniqueTag,
717 sDevPAddr.uiAddr, ui32PageOffset,
718 ui32WPosVal, ui32PacketSize, ui32BufferSize);
721 void PDumpIDLWithFlags(u32 ui32Clocks, u32 ui32Flags)
723 pdump_print(ui32Flags, "IDL %u\r\n", ui32Clocks);