← Back to branch summary

~gma500/+junk/emgd152-natty

« back to all changes in this revision

Viewing changes to emgd-dkms-1.5.15.3082/pvr/services4/srvkm/include/pdump_km.h

  • Committer: Luca Forina
  • Date: 2011-02-06 15:11:54 UTC
  • Revision ID: luca.forina@gmail.com-20110206151154-9dzn5ugxjub9qenb
Upload Emgd 1.5.2 for Natty (override Maverick)

Show diffs side-by-side

added added

removed removed

Lines of Context:
emgd-dkms-1.5.15.3082/pvr/services4/srvkm/include/pdump_km.h
 
1
/**********************************************************************
 
2
 *
 
3
 * Copyright(c) 2008 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
#ifndef _PDUMP_KM_H_
 
28
#define _PDUMP_KM_H_
 
29
 
 
30
#if defined(LINUX)
 
31
#define COMMON_PDUMP_OS_SUPPORT
 
32
#endif 
 
33
 
 
34
#if defined(COMMON_PDUMP_OS_SUPPORT)
 
35
#if defined(SUPPORT_SGX) || defined(SUPPORT_MSVDX)
 
36
#define SGX_SUPPORT_COMMON_PDUMP
 
37
#if defined(SGX_SUPPORT_COMMON_PDUMP)
 
38
#include <pdump_osfunc.h>
 
39
#endif 
 
40
 
 
41
#endif 
 
42
#endif 
 
43
 
 
44
#if defined(__cplusplus)
 
45
extern "C" {
 
46
#endif
 
47
 
 
48
#define PDUMP_FLAGS_NEVER                       0x08000000UL
 
49
#define PDUMP_FLAGS_TOOUT2MEM           0x10000000UL
 
50
#define PDUMP_FLAGS_LASTFRAME           0x20000000UL
 
51
#define PDUMP_FLAGS_RESETLFBUFFER       0x40000000UL
 
52
#define PDUMP_FLAGS_CONTINUOUS          0x80000000UL
 
53
 
 
54
#define PDUMP_PD_UNIQUETAG                      (IMG_HANDLE)0
 
55
#define PDUMP_PT_UNIQUETAG                      (IMG_HANDLE)0
 
56
 
 
57
#define PDUMP_STREAM_PARAM2                     0
 
58
#define PDUMP_STREAM_SCRIPT2            1
 
59
#define PDUMP_STREAM_DRIVERINFO         2
 
60
#define PDUMP_NUM_STREAMS                       3
 
61
 
 
62
 
 
63
#ifndef PDUMP
 
64
#define MAKEUNIQUETAG(hMemInfo) (0)
 
65
#endif
 
66
 
 
67
#ifdef PDUMP
 
68
 
 
69
#define MAKEUNIQUETAG(hMemInfo) (((BM_BUF *)(((PVRSRV_KERNEL_MEM_INFO *)hMemInfo)->sMemBlk.hBuffer))->pMapping)
 
70
 
 
71
        IMG_IMPORT PVRSRV_ERROR PDumpMemPolKM(PVRSRV_KERNEL_MEM_INFO *psMemInfo,
 
72
                                                                                  IMG_UINT32                    ui32Offset,
 
73
                                                                                  IMG_UINT32                    ui32Value,
 
74
                                                                                  IMG_UINT32                    ui32Mask,
 
75
                                                                                  PDUMP_POLL_OPERATOR   eOperator,
 
76
                                                                                  IMG_UINT32                    ui32Flags,
 
77
                                                                                  IMG_HANDLE                    hUniqueTag);
 
78
 
 
79
        IMG_IMPORT PVRSRV_ERROR PDumpMemUM(PVRSRV_PER_PROCESS_DATA *psProcData,
 
80
                                                                           IMG_PVOID                    pvAltLinAddr,
 
81
                                                                           IMG_PVOID                    pvLinAddr,
 
82
                                                                           PVRSRV_KERNEL_MEM_INFO       *psMemInfo,
 
83
                                                                           IMG_UINT32                   ui32Offset,
 
84
                                                                           IMG_UINT32                   ui32Bytes,
 
85
                                                                           IMG_UINT32                   ui32Flags,
 
86
                                                                           IMG_HANDLE                   hUniqueTag);
 
87
 
 
88
        IMG_IMPORT PVRSRV_ERROR PDumpMemKM(IMG_PVOID                    pvAltLinAddr,
 
89
                                                                           PVRSRV_KERNEL_MEM_INFO       *psMemInfo,
 
90
                                                                           IMG_UINT32                   ui32Offset,
 
91
                                                                           IMG_UINT32                   ui32Bytes,
 
92
                                                                           IMG_UINT32                   ui32Flags,
 
93
                                                                           IMG_HANDLE                   hUniqueTag);
 
94
        PVRSRV_ERROR PDumpMemPagesKM(PVRSRV_DEVICE_TYPE eDeviceType,
 
95
                                                                 IMG_DEV_PHYADDR                *pPages,
 
96
                                                                 IMG_UINT32                     ui32NumPages,
 
97
                                                                 IMG_DEV_VIRTADDR       sDevAddr,
 
98
                                                                 IMG_UINT32                     ui32Start,
 
99
                                                                 IMG_UINT32                     ui32Length,
 
100
                                                                 IMG_UINT32                     ui32Flags,
 
101
                                                                 IMG_HANDLE                     hUniqueTag);
 
102
 
 
103
        PVRSRV_ERROR PDumpMem2KM(PVRSRV_DEVICE_TYPE     eDeviceType,
 
104
                                                         IMG_CPU_VIRTADDR       pvLinAddr,
 
105
                                                         IMG_UINT32                     ui32Bytes,
 
106
                                                         IMG_UINT32                     ui32Flags,
 
107
                                                         IMG_BOOL                       bInitialisePages,
 
108
                                                         IMG_HANDLE                     hUniqueTag1,
 
109
                                                         IMG_HANDLE                     hUniqueTag2);
 
110
        IMG_VOID PDumpInitCommon(IMG_VOID);
 
111
        IMG_VOID PDumpDeInitCommon(IMG_VOID);
 
112
        IMG_VOID PDumpInit(IMG_VOID);
 
113
        IMG_VOID PDumpDeInit(IMG_VOID);
 
114
        PVRSRV_ERROR PDumpStartInitPhaseKM(IMG_VOID);
 
115
        PVRSRV_ERROR PDumpStopInitPhaseKM(IMG_VOID);
 
116
        IMG_IMPORT PVRSRV_ERROR PDumpSetFrameKM(IMG_UINT32 ui32Frame);
 
117
        IMG_IMPORT PVRSRV_ERROR PDumpCommentKM(IMG_CHAR *pszComment, IMG_UINT32 ui32Flags);
 
118
        IMG_IMPORT PVRSRV_ERROR PDumpDriverInfoKM(IMG_CHAR *pszString, IMG_UINT32 ui32Flags);
 
119
 
 
120
        PVRSRV_ERROR PDumpRegWithFlagsKM(IMG_UINT32 ui32RegAddr,
 
121
                                                                         IMG_UINT32 ui32RegValue,
 
122
                                                                         IMG_UINT32 ui32Flags);
 
123
        PVRSRV_ERROR PDumpRegPolWithFlagsKM(IMG_UINT32 ui32RegAddr,
 
124
                                                                                IMG_UINT32 ui32RegValue,
 
125
                                                                                IMG_UINT32 ui32Mask,
 
126
                                                                                IMG_UINT32 ui32Flags);
 
127
        PVRSRV_ERROR PDumpRegPolKM(IMG_UINT32 ui32RegAddr,
 
128
                                                           IMG_UINT32 ui32RegValue,
 
129
                                                           IMG_UINT32 ui32Mask);
 
130
 
 
131
        IMG_IMPORT PVRSRV_ERROR PDumpBitmapKM(IMG_CHAR *pszFileName,
 
132
                                                                                  IMG_UINT32 ui32FileOffset,
 
133
                                                                                  IMG_UINT32 ui32Width,
 
134
                                                                                  IMG_UINT32 ui32Height,
 
135
                                                                                  IMG_UINT32 ui32StrideInBytes,
 
136
                                                                                  IMG_DEV_VIRTADDR sDevBaseAddr,
 
137
                                                                                  IMG_UINT32 ui32Size,
 
138
                                                                                  PDUMP_PIXEL_FORMAT ePixelFormat,
 
139
                                                                                  PDUMP_MEM_FORMAT eMemFormat,
 
140
                                                                                  IMG_UINT32 ui32PDumpFlags);
 
141
        IMG_IMPORT PVRSRV_ERROR PDumpReadRegKM(IMG_CHAR *pszFileName,
 
142
                                                                                   IMG_UINT32 ui32FileOffset,
 
143
                                                                                   IMG_UINT32 ui32Address,
 
144
                                                                                   IMG_UINT32 ui32Size,
 
145
                                                                                   IMG_UINT32 ui32PDumpFlags);
 
146
 
 
147
        IMG_BOOL PDumpIsSuspended(IMG_VOID);
 
148
 
 
149
#if defined(SGX_SUPPORT_COMMON_PDUMP) || !defined(SUPPORT_VGX)
 
150
        
 
151
        PVRSRV_ERROR PDumpRegKM(IMG_UINT32              dwReg,
 
152
                                                        IMG_UINT32              dwData);
 
153
        PVRSRV_ERROR PDumpComment(IMG_CHAR* pszFormat, ...);
 
154
        PVRSRV_ERROR PDumpCommentWithFlags(IMG_UINT32   ui32Flags,
 
155
                                                                           IMG_CHAR*    pszFormat,
 
156
                                                                           ...);
 
157
 
 
158
        PVRSRV_ERROR PDumpPDReg(IMG_UINT32      ui32Reg,
 
159
                                                        IMG_UINT32      ui32dwData,
 
160
                                                        IMG_HANDLE      hUniqueTag);
 
161
        PVRSRV_ERROR PDumpPDRegWithFlags(IMG_UINT32             ui32Reg,
 
162
                                                                         IMG_UINT32             ui32Data,
 
163
                                                                         IMG_UINT32             ui32Flags,
 
164
                                                                         IMG_HANDLE             hUniqueTag);
 
165
#else
 
166
        IMG_VOID PDumpRegKM(IMG_UINT32          dwReg,
 
167
                                                        IMG_UINT32              dwData);
 
168
        IMG_VOID PDumpComment(IMG_CHAR* pszFormat, ...);
 
169
        IMG_VOID PDumpCommentWithFlags(IMG_UINT32       ui32Flags,
 
170
                                                                           IMG_CHAR*    pszFormat,
 
171
                                                                           ...);
 
172
 
 
173
        
 
174
        IMG_VOID PDumpPDReg(IMG_UINT32  ui32Reg,
 
175
                                                        IMG_UINT32      ui32dwData,
 
176
                                                        IMG_HANDLE      hUniqueTag);
 
177
        IMG_VOID PDumpPDRegWithFlags(IMG_UINT32         ui32Reg,
 
178
                                                                         IMG_UINT32             ui32Data,
 
179
                                                                         IMG_UINT32             ui32Flags,
 
180
                                                                         IMG_HANDLE             hUniqueTag);
 
181
#endif 
 
182
 
 
183
        IMG_VOID PDumpMsvdxRegRead(const IMG_CHAR* const        pRegRegion,
 
184
                                                           const IMG_UINT32             dwRegOffset);
 
185
 
 
186
        IMG_VOID PDumpMsvdxRegWrite(const IMG_CHAR* const       pRegRegion,
 
187
                                                                const IMG_UINT32                dwRegOffset,
 
188
                                                                const IMG_UINT32                dwData);
 
189
 
 
190
        PVRSRV_ERROR PDumpMsvdxRegPol(const IMG_CHAR* const     pRegRegion,
 
191
                                                                  const IMG_UINT32              ui32Offset,
 
192
                                                                  const IMG_UINT32              ui32CheckFuncIdExt,
 
193
                                                                  const IMG_UINT32              ui32RequValue,
 
194
                                                                  const IMG_UINT32              ui32Enable,
 
195
                                                                  const IMG_UINT32              ui32PollCount,
 
196
                                                                  const IMG_UINT32              ui32TimeOut);
 
197
 
 
198
        PVRSRV_ERROR  PDumpMsvdxWriteRef(const IMG_CHAR* const  pRegRegion,
 
199
                                                                         const IMG_UINT32               ui32VLROffset,
 
200
                                                                         const IMG_UINT32               ui32Physical );
 
201
 
 
202
        IMG_BOOL PDumpIsLastCaptureFrameKM(IMG_VOID);
 
203
        IMG_IMPORT IMG_BOOL PDumpIsCaptureFrameKM(IMG_VOID);
 
204
 
 
205
        IMG_VOID PDumpMallocPagesPhys(PVRSRV_DEVICE_TYPE        eDeviceType,
 
206
                                                                  IMG_UINT32                    ui32DevVAddr,
 
207
                                                                  IMG_PUINT32                   pui32PhysPages,
 
208
                                                                  IMG_UINT32                    ui32NumPages,
 
209
                                                                  IMG_HANDLE                    hUniqueTag);
 
210
        PVRSRV_ERROR PDumpSetMMUContext(PVRSRV_DEVICE_TYPE eDeviceType,
 
211
                                                                        IMG_CHAR *pszMemSpace,
 
212
                                                                        IMG_UINT32 *pui32MMUContextID,
 
213
                                                                        IMG_UINT32 ui32MMUType,
 
214
                                                                        IMG_HANDLE hUniqueTag1,
 
215
                                                                        IMG_VOID *pvPDCPUAddr);
 
216
        PVRSRV_ERROR PDumpClearMMUContext(PVRSRV_DEVICE_TYPE eDeviceType,
 
217
                                                                        IMG_CHAR *pszMemSpace,
 
218
                                                                        IMG_UINT32 ui32MMUContextID,
 
219
                                                                        IMG_UINT32 ui32MMUType);
 
220
 
 
221
        PVRSRV_ERROR PDumpPDDevPAddrKM(PVRSRV_KERNEL_MEM_INFO *psMemInfo,
 
222
                                                                   IMG_UINT32 ui32Offset,
 
223
                                                                   IMG_DEV_PHYADDR sPDDevPAddr,
 
224
                                                                   IMG_HANDLE hUniqueTag1,
 
225
                                                                   IMG_HANDLE hUniqueTag2);
 
226
 
 
227
        IMG_BOOL PDumpTestNextFrame(IMG_UINT32 ui32CurrentFrame);
 
228
 
 
229
 
 
230
#if defined (COMMON_PDUMP_OS_SUPPORT) && !defined(SUPPORT_VGX)
 
231
        
 
232
        PVRSRV_ERROR PDumpTASignatureRegisters(IMG_UINT32       ui32DumpFrameNum,
 
233
                                                                   IMG_UINT32   ui32TAKickCount,
 
234
                                                                   IMG_BOOL             bLastFrame,
 
235
                                                                   IMG_UINT32 *pui32Registers,
 
236
                                                                   IMG_UINT32 ui32NumRegisters);
 
237
 
 
238
        PVRSRV_ERROR PDump3DSignatureRegisters(IMG_UINT32 ui32DumpFrameNum,
 
239
                                                                                                                        IMG_BOOL bLastFrame,
 
240
                                                                                                                        IMG_UINT32 *pui32Registers,
 
241
                                                                                                                        IMG_UINT32 ui32NumRegisters);
 
242
 
 
243
        PVRSRV_ERROR PDumpCounterRegisters(IMG_UINT32 ui32DumpFrameNum,
 
244
                                        IMG_BOOL                bLastFrame,
 
245
                                        IMG_UINT32 *pui32Registers,
 
246
                                        IMG_UINT32 ui32NumRegisters);
 
247
 
 
248
        PVRSRV_ERROR PDumpRegRead(const IMG_UINT32 dwRegOffset, IMG_UINT32      ui32Flags);
 
249
 
 
250
        PVRSRV_ERROR PDumpCycleCountRegRead(const IMG_UINT32 dwRegOffset, IMG_BOOL bLastFrame);
 
251
 
 
252
        PVRSRV_ERROR PDumpIDLWithFlags(IMG_UINT32 ui32Clocks, IMG_UINT32 ui32Flags);
 
253
        PVRSRV_ERROR PDumpIDL(IMG_UINT32 ui32Clocks);
 
254
 
 
255
        PVRSRV_ERROR PDumpMallocPages(PVRSRV_DEVICE_TYPE        eDeviceType,
 
256
                                                          IMG_UINT32                    ui32DevVAddr,
 
257
                                                          IMG_CPU_VIRTADDR              pvLinAddr,
 
258
                                                          IMG_HANDLE                    hOSMemHandle,
 
259
                                                          IMG_UINT32                    ui32NumBytes,
 
260
                                                          IMG_UINT32                    ui32PageSize,
 
261
                                                          IMG_HANDLE                    hUniqueTag);
 
262
        PVRSRV_ERROR PDumpMallocPageTable(PVRSRV_DEVICE_TYPE    eDeviceType,
 
263
                                                                  IMG_CPU_VIRTADDR              pvLinAddr,
 
264
                                                                  IMG_UINT32                    ui32NumBytes,
 
265
                                                                  IMG_HANDLE                    hUniqueTag);
 
266
        PVRSRV_ERROR PDumpFreePages(struct _BM_HEAP_    *psBMHeap,
 
267
                                                        IMG_DEV_VIRTADDR        sDevVAddr,
 
268
                                                        IMG_UINT32                      ui32NumBytes,
 
269
                                                        IMG_UINT32                      ui32PageSize,
 
270
                                                        IMG_HANDLE              hUniqueTag,
 
271
                                                        IMG_BOOL                        bInterleaved);
 
272
        PVRSRV_ERROR PDumpFreePageTable(PVRSRV_DEVICE_TYPE      eDeviceType,
 
273
                                                                IMG_CPU_VIRTADDR        pvLinAddr,
 
274
                                                                IMG_UINT32                      ui32NumBytes,
 
275
                                                                IMG_HANDLE                      hUniqueTag);
 
276
 
 
277
        IMG_IMPORT PVRSRV_ERROR PDumpHWPerfCBKM(IMG_CHAR                        *pszFileName,
 
278
                                                                                IMG_UINT32                      ui32FileOffset,
 
279
                                                                                IMG_DEV_VIRTADDR        sDevBaseAddr,
 
280
                                                                                IMG_UINT32                      ui32Size,
 
281
                                                                                IMG_UINT32                      ui32PDumpFlags);
 
282
 
 
283
        PVRSRV_ERROR PDumpCBP(PPVRSRV_KERNEL_MEM_INFO   psROffMemInfo,
 
284
                                  IMG_UINT32                            ui32ROffOffset,
 
285
                                  IMG_UINT32                            ui32WPosVal,
 
286
                                  IMG_UINT32                            ui32PacketSize,
 
287
                                  IMG_UINT32                            ui32BufferSize,
 
288
                                  IMG_UINT32                            ui32Flags,
 
289
                                  IMG_HANDLE                            hUniqueTag);
 
290
 
 
291
#else 
 
292
        IMG_VOID PDumpTASignatureRegisters(IMG_UINT32   ui32DumpFrameNum,
 
293
                           IMG_UINT32   ui32TAKickCount,
 
294
                           IMG_BOOL             bLastFrame,
 
295
                           IMG_UINT32 *pui32Registers,
 
296
                           IMG_UINT32 ui32NumRegisters);
 
297
        IMG_VOID PDump3DSignatureRegisters(IMG_UINT32 ui32DumpFrameNum,
 
298
                        IMG_BOOL bLastFrame,
 
299
                        IMG_UINT32 *pui32Registers,
 
300
                        IMG_UINT32 ui32NumRegisters);
 
301
        IMG_VOID PDumpCounterRegisters(IMG_UINT32 ui32DumpFrameNum,
 
302
                        IMG_BOOL                bLastFrame,
 
303
                        IMG_UINT32 *pui32Registers,
 
304
                        IMG_UINT32 ui32NumRegisters);
 
305
 
 
306
        IMG_VOID PDumpRegRead(const IMG_UINT32 dwRegOffset, IMG_UINT32  ui32Flags);
 
307
        IMG_VOID PDumpCycleCountRegRead(const IMG_UINT32 dwRegOffset, IMG_BOOL bLastFrame);
 
308
 
 
309
        IMG_VOID PDumpIDLWithFlags(IMG_UINT32 ui32Clocks, IMG_UINT32 ui32Flags);
 
310
        IMG_VOID PDumpIDL(IMG_UINT32 ui32Clocks);
 
311
 
 
312
        
 
313
        IMG_VOID PDumpMallocPages(PVRSRV_DEVICE_TYPE    eDeviceType,
 
314
                                                          IMG_UINT32                    ui32DevVAddr,
 
315
                                                          IMG_CPU_VIRTADDR              pvLinAddr,
 
316
                                                          IMG_HANDLE                    hOSMemHandle,
 
317
                                                          IMG_UINT32                    ui32NumBytes,
 
318
                                                          IMG_UINT32                    ui32PageSize,
 
319
                                                          IMG_HANDLE                    hUniqueTag);
 
320
        IMG_VOID PDumpMallocPageTable(PVRSRV_DEVICE_TYPE        eDeviceType,
 
321
                                                                  IMG_CPU_VIRTADDR              pvLinAddr,
 
322
                                                                  IMG_UINT32                    ui32NumBytes,
 
323
                                                                  IMG_HANDLE                    hUniqueTag);
 
324
        IMG_VOID PDumpFreePages(struct _BM_HEAP_        *psBMHeap,
 
325
                                                        IMG_DEV_VIRTADDR        sDevVAddr,
 
326
                                                        IMG_UINT32                      ui32NumBytes,
 
327
                                                        IMG_UINT32                      ui32PageSize,
 
328
                                                        IMG_HANDLE              hUniqueTag,
 
329
                                                        IMG_BOOL                        bInterleaved);
 
330
        IMG_VOID PDumpFreePageTable(PVRSRV_DEVICE_TYPE  eDeviceType,
 
331
                                                                IMG_CPU_VIRTADDR        pvLinAddr,
 
332
                                                                IMG_UINT32                      ui32NumBytes,
 
333
                                                                IMG_HANDLE                      hUniqueTag);
 
334
 
 
335
        IMG_IMPORT IMG_VOID PDumpHWPerfCBKM(IMG_CHAR                    *pszFileName,
 
336
                                                                                IMG_UINT32                      ui32FileOffset,
 
337
                                                                                IMG_DEV_VIRTADDR        sDevBaseAddr,
 
338
                                                                                IMG_UINT32                      ui32Size,
 
339
                                                                                IMG_UINT32                      ui32PDumpFlags);
 
340
 
 
341
        IMG_VOID PDumpCBP(PPVRSRV_KERNEL_MEM_INFO       psROffMemInfo,
 
342
                                  IMG_UINT32                            ui32ROffOffset,
 
343
                                  IMG_UINT32                            ui32WPosVal,
 
344
                                  IMG_UINT32                            ui32PacketSize,
 
345
                                  IMG_UINT32                            ui32BufferSize,
 
346
                                  IMG_UINT32                            ui32Flags,
 
347
                                  IMG_HANDLE                            hUniqueTag);
 
348
 
 
349
#endif 
 
350
 
 
351
        IMG_VOID PDumpVGXMemToFile(IMG_CHAR *pszFileName,
 
352
                                                           IMG_UINT32 ui32FileOffset, 
 
353
                                                           PVRSRV_KERNEL_MEM_INFO *psMemInfo,
 
354
                                                           IMG_UINT32 uiAddr, 
 
355
                                                           IMG_UINT32 ui32Size,
 
356
                                                           IMG_UINT32 ui32PDumpFlags,
 
357
                                                           IMG_HANDLE hUniqueTag);
 
358
 
 
359
        IMG_VOID PDumpSuspendKM(IMG_VOID);
 
360
        IMG_VOID PDumpResumeKM(IMG_VOID);
 
361
 
 
362
        #define PDUMPMEMPOL                             PDumpMemPolKM
 
363
        #define PDUMPMEM                                PDumpMemKM
 
364
        #define PDUMPMEM2                               PDumpMem2KM
 
365
        #define PDUMPMEMUM                              PDumpMemUM
 
366
        #define PDUMPINIT                               PDumpInitCommon
 
367
        #define PDUMPDEINIT                             PDumpDeInitCommon
 
368
        #define PDUMPISLASTFRAME                PDumpIsLastCaptureFrameKM
 
369
        #define PDUMPTESTFRAME                  PDumpIsCaptureFrameKM
 
370
        #define PDUMPTESTNEXTFRAME              PDumpTestNextFrame
 
371
        #define PDUMPREGWITHFLAGS               PDumpRegWithFlagsKM
 
372
        #define PDUMPREG                                PDumpRegKM
 
373
        #define PDUMPCOMMENT                    PDumpComment
 
374
        #define PDUMPCOMMENTWITHFLAGS   PDumpCommentWithFlags
 
375
        #define PDUMPREGPOL                             PDumpRegPolKM
 
376
        #define PDUMPREGPOLWITHFLAGS    PDumpRegPolWithFlagsKM
 
377
        #define PDUMPMALLOCPAGES                PDumpMallocPages
 
378
        #define PDUMPMALLOCPAGETABLE    PDumpMallocPageTable
 
379
        #define PDUMPSETMMUCONTEXT              PDumpSetMMUContext
 
380
        #define PDUMPCLEARMMUCONTEXT    PDumpClearMMUContext
 
381
        #define PDUMPFREEPAGES                  PDumpFreePages
 
382
        #define PDUMPFREEPAGETABLE              PDumpFreePageTable
 
383
        #define PDUMPPDREG                              PDumpPDReg
 
384
        #define PDUMPPDREGWITHFLAGS             PDumpPDRegWithFlags
 
385
        #define PDUMPCBP                                PDumpCBP
 
386
        #define PDUMPMALLOCPAGESPHYS    PDumpMallocPagesPhys
 
387
        #define PDUMPENDINITPHASE               PDumpStopInitPhaseKM
 
388
        #define PDUMPMSVDXREGWRITE              PDumpMsvdxRegWrite
 
389
        #define PDUMPMSVDXREGREAD               PDumpMsvdxRegRead
 
390
        #define PDUMPMSVDXPOL                   PDumpMsvdxRegPol
 
391
        #define PDUMPMSVDXWRITEREF              PDumpMsvdxWriteRef
 
392
        #define PDUMPBITMAPKM                   PDumpBitmapKM
 
393
        #define PDUMPDRIVERINFO                 PDumpDriverInfoKM
 
394
        #define PDUMPIDLWITHFLAGS               PDumpIDLWithFlags
 
395
        #define PDUMPIDL                                PDumpIDL
 
396
        #define PDUMPSUSPEND                    PDumpSuspendKM
 
397
        #define PDUMPRESUME                             PDumpResumeKM
 
398
 
 
399
#else
 
400
                #if ((defined(LINUX) || defined(GCC_IA32)) || defined(GCC_ARM))
 
401
                        #define PDUMPMEMPOL(args...)
 
402
                        #define PDUMPMEM(args...)
 
403
                        #define PDUMPMEM2(args...)
 
404
                        #define PDUMPMEMUM(args...)
 
405
                        #define PDUMPINIT(args...)
 
406
                        #define PDUMPDEINIT(args...)
 
407
                        #define PDUMPISLASTFRAME(args...)
 
408
                        #define PDUMPTESTFRAME(args...)
 
409
                        #define PDUMPTESTNEXTFRAME(args...)
 
410
                        #define PDUMPREGWITHFLAGS(args...)
 
411
                        #define PDUMPREG(args...)
 
412
                        #define PDUMPCOMMENT(args...)
 
413
                        #define PDUMPREGPOL(args...)
 
414
                        #define PDUMPREGPOLWITHFLAGS(args...)
 
415
                        #define PDUMPMALLOCPAGES(args...)
 
416
                        #define PDUMPMALLOCPAGETABLE(args...)
 
417
                        #define PDUMPSETMMUCONTEXT(args...)
 
418
                        #define PDUMPCLEARMMUCONTEXT(args...)
 
419
                        #define PDUMPFREEPAGES(args...)
 
420
                        #define PDUMPFREEPAGETABLE(args...)
 
421
                        #define PDUMPPDREG(args...)
 
422
                        #define PDUMPPDREGWITHFLAGS(args...)
 
423
                        #define PDUMPSYNC(args...)
 
424
                        #define PDUMPCOPYTOMEM(args...)
 
425
                        #define PDUMPWRITE(args...)
 
426
                        #define PDUMPCBP(args...)
 
427
                        #define PDUMPCOMMENTWITHFLAGS(args...)
 
428
                        #define PDUMPMALLOCPAGESPHYS(args...)
 
429
                        #define PDUMPENDINITPHASE(args...)
 
430
                        #define PDUMPMSVDXREG(args...)
 
431
                        #define PDUMPMSVDXREGWRITE(args...)
 
432
                        #define PDUMPMSVDXREGREAD(args...)
 
433
                        #define PDUMPMSVDXPOLEQ(args...)
 
434
                        #define PDUMPMSVDXPOL(args...)
 
435
                        #define PDUMPBITMAPKM(args...)
 
436
                        #define PDUMPDRIVERINFO(args...)
 
437
                        #define PDUMPIDLWITHFLAGS(args...)
 
438
                        #define PDUMPIDL(args...)
 
439
                        #define PDUMPSUSPEND(args...)
 
440
                        #define PDUMPRESUME(args...)
 
441
                        #define PDUMPMSVDXWRITEREF(args...)
 
442
                #else
 
443
                        #error Compiler not specified
 
444
                #endif
 
445
#endif
 
446
 
 
447
#if defined (__cplusplus)
 
448
}
 
449
#endif
 
450
 
 
451
#endif 
 
452