aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/gpu/pvr/sgx/sgxtransfer.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/gpu/pvr/sgx/sgxtransfer.c')
-rw-r--r--drivers/gpu/pvr/sgx/sgxtransfer.c573
1 files changed, 573 insertions, 0 deletions
diff --git a/drivers/gpu/pvr/sgx/sgxtransfer.c b/drivers/gpu/pvr/sgx/sgxtransfer.c
new file mode 100644
index 00000000000..abe5767e25d
--- /dev/null
+++ b/drivers/gpu/pvr/sgx/sgxtransfer.c
@@ -0,0 +1,573 @@
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#if defined(TRANSFER_QUEUE)
28
29#include <stddef.h>
30
31#include "sgxdefs.h"
32#include "services_headers.h"
33#include "buffer_manager.h"
34#include "sgxinfo.h"
35#include "sysconfig.h"
36#include "regpaths.h"
37#include "pdump_km.h"
38#include "mmu.h"
39#include "pvr_bridge.h"
40#include "sgx_bridge_km.h"
41#include "sgxinfokm.h"
42#include "osfunc.h"
43#include "pvr_debug.h"
44#include "sgxutils.h"
45
46IMG_EXPORT PVRSRV_ERROR SGXSubmitTransferKM(IMG_HANDLE hDevHandle, PVRSRV_TRANSFER_SGX_KICK *psKick)
47{
48 PVRSRV_KERNEL_MEM_INFO *psCCBMemInfo = (PVRSRV_KERNEL_MEM_INFO *)psKick->hCCBMemInfo;
49 SGXMKIF_COMMAND sCommand = {0};
50 SGXMKIF_TRANSFERCMD_SHARED *psSharedTransferCmd;
51 PVRSRV_KERNEL_SYNC_INFO *psSyncInfo;
52 PVRSRV_ERROR eError;
53
54#if defined(PDUMP)
55 IMG_BOOL bPersistentProcess = IMG_FALSE;
56
57 {
58 PVRSRV_PER_PROCESS_DATA* psPerProc = PVRSRVFindPerProcessData();
59 if(psPerProc != IMG_NULL)
60 {
61 bPersistentProcess = psPerProc->bPDumpPersistent;
62 }
63 }
64#endif
65
66 if (!CCB_OFFSET_IS_VALID(SGXMKIF_TRANSFERCMD_SHARED, psCCBMemInfo, psKick, ui32SharedCmdCCBOffset))
67 {
68 PVR_DPF((PVR_DBG_ERROR, "SGXSubmitTransferKM: Invalid CCB offset"));
69 return PVRSRV_ERROR_INVALID_PARAMS;
70 }
71
72
73 psSharedTransferCmd = CCB_DATA_FROM_OFFSET(SGXMKIF_TRANSFERCMD_SHARED, psCCBMemInfo, psKick, ui32SharedCmdCCBOffset);
74
75 if (psKick->hTASyncInfo != IMG_NULL)
76 {
77 psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->hTASyncInfo;
78
79 psSharedTransferCmd->ui32TASyncWriteOpsPendingVal = psSyncInfo->psSyncData->ui32WriteOpsPending++;
80 psSharedTransferCmd->ui32TASyncReadOpsPendingVal = psSyncInfo->psSyncData->ui32ReadOpsPending;
81
82 psSharedTransferCmd->sTASyncWriteOpsCompleteDevVAddr = psSyncInfo->sWriteOpsCompleteDevVAddr;
83 psSharedTransferCmd->sTASyncReadOpsCompleteDevVAddr = psSyncInfo->sReadOpsCompleteDevVAddr;
84 }
85 else
86 {
87 psSharedTransferCmd->sTASyncWriteOpsCompleteDevVAddr.uiAddr = 0;
88 psSharedTransferCmd->sTASyncReadOpsCompleteDevVAddr.uiAddr = 0;
89 }
90
91 if (psKick->h3DSyncInfo != IMG_NULL)
92 {
93 psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->h3DSyncInfo;
94
95 psSharedTransferCmd->ui323DSyncWriteOpsPendingVal = psSyncInfo->psSyncData->ui32WriteOpsPending++;
96 psSharedTransferCmd->ui323DSyncReadOpsPendingVal = psSyncInfo->psSyncData->ui32ReadOpsPending;
97
98 psSharedTransferCmd->s3DSyncWriteOpsCompleteDevVAddr = psSyncInfo->sWriteOpsCompleteDevVAddr;
99 psSharedTransferCmd->s3DSyncReadOpsCompleteDevVAddr = psSyncInfo->sReadOpsCompleteDevVAddr;
100 }
101 else
102 {
103 psSharedTransferCmd->s3DSyncWriteOpsCompleteDevVAddr.uiAddr = 0;
104 psSharedTransferCmd->s3DSyncReadOpsCompleteDevVAddr.uiAddr = 0;
105 }
106
107 if ((psKick->ui32Flags & SGXMKIF_TQFLAGS_KEEPPENDING) == 0UL)
108 {
109 if (psKick->ui32NumSrcSync > 0)
110 {
111 psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->ahSrcSyncInfo[0];
112
113 psSharedTransferCmd->ui32SrcWriteOpPendingVal = psSyncInfo->psSyncData->ui32WriteOpsPending;
114 psSharedTransferCmd->ui32SrcReadOpPendingVal = psSyncInfo->psSyncData->ui32ReadOpsPending;
115
116 psSharedTransferCmd->sSrcWriteOpsCompleteDevAddr = psSyncInfo->sWriteOpsCompleteDevVAddr;
117 psSharedTransferCmd->sSrcReadOpsCompleteDevAddr = psSyncInfo->sReadOpsCompleteDevVAddr;
118
119 }
120
121 if (psKick->ui32NumDstSync > 0)
122 {
123 psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->ahDstSyncInfo[0];
124
125 psSharedTransferCmd->ui32DstWriteOpPendingVal = psSyncInfo->psSyncData->ui32WriteOpsPending;
126 psSharedTransferCmd->ui32DstReadOpPendingVal = psSyncInfo->psSyncData->ui32ReadOpsPending;
127
128 psSharedTransferCmd->sDstWriteOpsCompleteDevAddr = psSyncInfo->sWriteOpsCompleteDevVAddr;
129 psSharedTransferCmd->sDstReadOpsCompleteDevAddr = psSyncInfo->sReadOpsCompleteDevVAddr;
130
131 }
132
133
134 if (psKick->ui32NumSrcSync > 0)
135 {
136 psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->ahSrcSyncInfo[0];
137 psSyncInfo->psSyncData->ui32ReadOpsPending++;
138 }
139 if (psKick->ui32NumDstSync > 0)
140 {
141 psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->ahDstSyncInfo[0];
142 psSyncInfo->psSyncData->ui32WriteOpsPending++;
143 }
144 }
145
146
147 if (psKick->ui32NumDstSync > 1 || psKick->ui32NumSrcSync > 1)
148 {
149 PVR_DPF((PVR_DBG_ERROR,
150 "Transfer command doesn't support more than 1 sync object per src/dst\ndst: %d, src: %d",
151 psKick->ui32NumDstSync, psKick->ui32NumSrcSync));
152 }
153
154#if defined(PDUMP)
155 if ((PDumpIsCaptureFrameKM()
156 || ((psKick->ui32PDumpFlags & PDUMP_FLAGS_CONTINUOUS) != 0))
157 && (bPersistentProcess == IMG_FALSE) )
158 {
159 PDUMPCOMMENT("Shared part of transfer command\r\n");
160 PDUMPMEM(psSharedTransferCmd,
161 psCCBMemInfo,
162 psKick->ui32CCBDumpWOff,
163 sizeof(SGXMKIF_TRANSFERCMD_SHARED),
164 psKick->ui32PDumpFlags,
165 MAKEUNIQUETAG(psCCBMemInfo));
166
167 if((psKick->ui32NumSrcSync > 0) && ((psKick->ui32Flags & SGXMKIF_TQFLAGS_KEEPPENDING) == 0UL))
168 {
169 psSyncInfo = psKick->ahSrcSyncInfo[0];
170
171 PDUMPCOMMENT("Hack src surface write op in transfer cmd\r\n");
172 PDUMPMEM(&psSyncInfo->psSyncData->ui32LastOpDumpVal,
173 psCCBMemInfo,
174 psKick->ui32CCBDumpWOff + offsetof(SGXMKIF_TRANSFERCMD_SHARED, ui32SrcWriteOpPendingVal),
175 sizeof(psSyncInfo->psSyncData->ui32LastOpDumpVal),
176 psKick->ui32PDumpFlags,
177 MAKEUNIQUETAG(psCCBMemInfo));
178
179 PDUMPCOMMENT("Hack src surface read op in transfer cmd\r\n");
180 PDUMPMEM(&psSyncInfo->psSyncData->ui32LastReadOpDumpVal,
181 psCCBMemInfo,
182 psKick->ui32CCBDumpWOff + offsetof(SGXMKIF_TRANSFERCMD_SHARED, ui32SrcReadOpPendingVal),
183 sizeof(psSyncInfo->psSyncData->ui32LastReadOpDumpVal),
184 psKick->ui32PDumpFlags,
185 MAKEUNIQUETAG(psCCBMemInfo));
186
187 }
188 if((psKick->ui32NumDstSync > 0) && ((psKick->ui32Flags & SGXMKIF_TQFLAGS_KEEPPENDING) == 0UL))
189 {
190 psSyncInfo = psKick->ahDstSyncInfo[0];
191
192 PDUMPCOMMENT("Hack dest surface write op in transfer cmd\r\n");
193 PDUMPMEM(&psSyncInfo->psSyncData->ui32LastOpDumpVal,
194 psCCBMemInfo,
195 psKick->ui32CCBDumpWOff + offsetof(SGXMKIF_TRANSFERCMD_SHARED, ui32DstWriteOpPendingVal),
196 sizeof(psSyncInfo->psSyncData->ui32LastOpDumpVal),
197 psKick->ui32PDumpFlags,
198 MAKEUNIQUETAG(psCCBMemInfo));
199
200 PDUMPCOMMENT("Hack dest surface read op in transfer cmd\r\n");
201 PDUMPMEM(&psSyncInfo->psSyncData->ui32LastReadOpDumpVal,
202 psCCBMemInfo,
203 psKick->ui32CCBDumpWOff + offsetof(SGXMKIF_TRANSFERCMD_SHARED, ui32DstReadOpPendingVal),
204 sizeof(psSyncInfo->psSyncData->ui32LastReadOpDumpVal),
205 psKick->ui32PDumpFlags,
206 MAKEUNIQUETAG(psCCBMemInfo));
207
208 }
209
210
211 if((psKick->ui32NumSrcSync > 0) && ((psKick->ui32Flags & SGXMKIF_TQFLAGS_KEEPPENDING)== 0UL))
212 {
213 psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->ahSrcSyncInfo[0];
214 psSyncInfo->psSyncData->ui32LastReadOpDumpVal++;
215 }
216
217 if((psKick->ui32NumDstSync > 0) && ((psKick->ui32Flags & SGXMKIF_TQFLAGS_KEEPPENDING) == 0UL))
218 {
219 psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->ahDstSyncInfo[0];
220 psSyncInfo->psSyncData->ui32LastOpDumpVal++;
221 }
222 }
223#endif
224
225 sCommand.ui32Data[1] = psKick->sHWTransferContextDevVAddr.uiAddr;
226
227 eError = SGXScheduleCCBCommandKM(hDevHandle, SGXMKIF_CMD_TRANSFER, &sCommand, KERNEL_ID, psKick->ui32PDumpFlags);
228
229 if (eError == PVRSRV_ERROR_RETRY)
230 {
231
232 if ((psKick->ui32Flags & SGXMKIF_TQFLAGS_KEEPPENDING) == 0UL)
233 {
234 if (psKick->ui32NumSrcSync > 0)
235 {
236 psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->ahSrcSyncInfo[0];
237 psSyncInfo->psSyncData->ui32ReadOpsPending--;
238 }
239 if (psKick->ui32NumDstSync > 0)
240 {
241 psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->ahDstSyncInfo[0];
242 psSyncInfo->psSyncData->ui32WriteOpsPending--;
243 }
244#if defined(PDUMP)
245 if (PDumpIsCaptureFrameKM()
246 || ((psKick->ui32PDumpFlags & PDUMP_FLAGS_CONTINUOUS) != 0))
247 {
248 if (psKick->ui32NumSrcSync > 0)
249 {
250 psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->ahSrcSyncInfo[0];
251 psSyncInfo->psSyncData->ui32LastReadOpDumpVal--;
252 }
253 if (psKick->ui32NumDstSync > 0)
254 {
255 psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->ahDstSyncInfo[0];
256 psSyncInfo->psSyncData->ui32LastOpDumpVal--;
257 }
258 }
259#endif
260 }
261
262
263 if (psKick->hTASyncInfo != IMG_NULL)
264 {
265 psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->hTASyncInfo;
266 psSyncInfo->psSyncData->ui32WriteOpsPending--;
267 }
268
269
270 if (psKick->h3DSyncInfo != IMG_NULL)
271 {
272 psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->h3DSyncInfo;
273 psSyncInfo->psSyncData->ui32WriteOpsPending--;
274 }
275 }
276
277 else if (PVRSRV_OK != eError)
278 {
279 PVR_DPF((PVR_DBG_ERROR, "SGXSubmitTransferKM: SGXScheduleCCBCommandKM failed."));
280 return eError;
281 }
282
283
284#if defined(NO_HARDWARE)
285 if ((psKick->ui32Flags & SGXMKIF_TQFLAGS_NOSYNCUPDATE) == 0)
286 {
287 IMG_UINT32 i;
288
289
290 for(i = 0; i < psKick->ui32NumSrcSync; i++)
291 {
292 psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->ahSrcSyncInfo[i];
293 psSyncInfo->psSyncData->ui32ReadOpsComplete = psSyncInfo->psSyncData->ui32ReadOpsPending;
294 }
295
296 for(i = 0; i < psKick->ui32NumDstSync; i++)
297 {
298 psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->ahDstSyncInfo[i];
299 psSyncInfo->psSyncData->ui32WriteOpsComplete = psSyncInfo->psSyncData->ui32WriteOpsPending;
300
301 }
302
303 if (psKick->hTASyncInfo != IMG_NULL)
304 {
305 psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->hTASyncInfo;
306
307 psSyncInfo->psSyncData->ui32WriteOpsComplete = psSyncInfo->psSyncData->ui32WriteOpsPending;
308 }
309
310 if (psKick->h3DSyncInfo != IMG_NULL)
311 {
312 psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->h3DSyncInfo;
313
314 psSyncInfo->psSyncData->ui32WriteOpsComplete = psSyncInfo->psSyncData->ui32WriteOpsPending;
315 }
316 }
317#endif
318
319 return eError;
320}
321
322#if defined(SGX_FEATURE_2D_HARDWARE)
323IMG_EXPORT PVRSRV_ERROR SGXSubmit2DKM(IMG_HANDLE hDevHandle, PVRSRV_2D_SGX_KICK *psKick)
324
325{
326 PVRSRV_KERNEL_MEM_INFO *psCCBMemInfo = (PVRSRV_KERNEL_MEM_INFO *)psKick->hCCBMemInfo;
327 SGXMKIF_COMMAND sCommand = {0};
328 SGXMKIF_2DCMD_SHARED *ps2DCmd;
329 PVRSRV_KERNEL_SYNC_INFO *psSyncInfo;
330 PVRSRV_ERROR eError;
331 IMG_UINT32 i;
332#if defined(PDUMP)
333 IMG_BOOL bPersistentProcess = IMG_FALSE;
334
335 {
336 PVRSRV_PER_PROCESS_DATA* psPerProc = PVRSRVFindPerProcessData();
337 if(psPerProc != IMG_NULL)
338 {
339 bPersistentProcess = psPerProc->bPDumpPersistent;
340 }
341 }
342#endif
343
344 if (!CCB_OFFSET_IS_VALID(SGXMKIF_2DCMD_SHARED, psCCBMemInfo, psKick, ui32SharedCmdCCBOffset))
345 {
346 PVR_DPF((PVR_DBG_ERROR, "SGXSubmit2DKM: Invalid CCB offset"));
347 return PVRSRV_ERROR_INVALID_PARAMS;
348 }
349
350
351 ps2DCmd = CCB_DATA_FROM_OFFSET(SGXMKIF_2DCMD_SHARED, psCCBMemInfo, psKick, ui32SharedCmdCCBOffset);
352
353 OSMemSet(ps2DCmd, 0, sizeof(*ps2DCmd));
354
355
356 if (psKick->hTASyncInfo != IMG_NULL)
357 {
358 psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->hTASyncInfo;
359
360 ps2DCmd->sTASyncData.ui32WriteOpsPendingVal = psSyncInfo->psSyncData->ui32WriteOpsPending++;
361 ps2DCmd->sTASyncData.ui32ReadOpsPendingVal = psSyncInfo->psSyncData->ui32ReadOpsPending;
362
363 ps2DCmd->sTASyncData.sWriteOpsCompleteDevVAddr = psSyncInfo->sWriteOpsCompleteDevVAddr;
364 ps2DCmd->sTASyncData.sReadOpsCompleteDevVAddr = psSyncInfo->sReadOpsCompleteDevVAddr;
365 }
366
367
368 if (psKick->h3DSyncInfo != IMG_NULL)
369 {
370 psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->h3DSyncInfo;
371
372 ps2DCmd->s3DSyncData.ui32WriteOpsPendingVal = psSyncInfo->psSyncData->ui32WriteOpsPending++;
373 ps2DCmd->s3DSyncData.ui32ReadOpsPendingVal = psSyncInfo->psSyncData->ui32ReadOpsPending;
374
375 ps2DCmd->s3DSyncData.sWriteOpsCompleteDevVAddr = psSyncInfo->sWriteOpsCompleteDevVAddr;
376 ps2DCmd->s3DSyncData.sReadOpsCompleteDevVAddr = psSyncInfo->sReadOpsCompleteDevVAddr;
377 }
378
379
380 ps2DCmd->ui32NumSrcSync = psKick->ui32NumSrcSync;
381 for (i = 0; i < psKick->ui32NumSrcSync; i++)
382 {
383 psSyncInfo = psKick->ahSrcSyncInfo[i];
384
385 ps2DCmd->sSrcSyncData[i].ui32WriteOpsPendingVal = psSyncInfo->psSyncData->ui32WriteOpsPending;
386 ps2DCmd->sSrcSyncData[i].ui32ReadOpsPendingVal = psSyncInfo->psSyncData->ui32ReadOpsPending;
387
388 ps2DCmd->sSrcSyncData[i].sWriteOpsCompleteDevVAddr = psSyncInfo->sWriteOpsCompleteDevVAddr;
389 ps2DCmd->sSrcSyncData[i].sReadOpsCompleteDevVAddr = psSyncInfo->sReadOpsCompleteDevVAddr;
390 }
391
392 if (psKick->hDstSyncInfo != IMG_NULL)
393 {
394 psSyncInfo = psKick->hDstSyncInfo;
395
396 ps2DCmd->sDstSyncData.ui32WriteOpsPendingVal = psSyncInfo->psSyncData->ui32WriteOpsPending;
397 ps2DCmd->sDstSyncData.ui32ReadOpsPendingVal = psSyncInfo->psSyncData->ui32ReadOpsPending;
398
399 ps2DCmd->sDstSyncData.sWriteOpsCompleteDevVAddr = psSyncInfo->sWriteOpsCompleteDevVAddr;
400 ps2DCmd->sDstSyncData.sReadOpsCompleteDevVAddr = psSyncInfo->sReadOpsCompleteDevVAddr;
401 }
402
403
404 for (i = 0; i < psKick->ui32NumSrcSync; i++)
405 {
406 psSyncInfo = psKick->ahSrcSyncInfo[i];
407 psSyncInfo->psSyncData->ui32ReadOpsPending++;
408 }
409
410 if (psKick->hDstSyncInfo != IMG_NULL)
411 {
412 psSyncInfo = psKick->hDstSyncInfo;
413 psSyncInfo->psSyncData->ui32WriteOpsPending++;
414 }
415
416#if defined(PDUMP)
417 if ((PDumpIsCaptureFrameKM()
418 || ((psKick->ui32PDumpFlags & PDUMP_FLAGS_CONTINUOUS) != 0))
419 && (bPersistentProcess == IMG_FALSE) )
420 {
421
422 PDUMPCOMMENT("Shared part of 2D command\r\n");
423 PDUMPMEM(ps2DCmd,
424 psCCBMemInfo,
425 psKick->ui32CCBDumpWOff,
426 sizeof(SGXMKIF_2DCMD_SHARED),
427 psKick->ui32PDumpFlags,
428 MAKEUNIQUETAG(psCCBMemInfo));
429
430 for (i = 0; i < psKick->ui32NumSrcSync; i++)
431 {
432 psSyncInfo = psKick->ahSrcSyncInfo[i];
433
434 PDUMPCOMMENT("Hack src surface write op in 2D cmd\r\n");
435 PDUMPMEM(&psSyncInfo->psSyncData->ui32LastOpDumpVal,
436 psCCBMemInfo,
437 psKick->ui32CCBDumpWOff + offsetof(SGXMKIF_2DCMD_SHARED, sSrcSyncData[i].ui32WriteOpsPendingVal),
438 sizeof(psSyncInfo->psSyncData->ui32LastOpDumpVal),
439 psKick->ui32PDumpFlags,
440 MAKEUNIQUETAG(psCCBMemInfo));
441
442 PDUMPCOMMENT("Hack src surface read op in 2D cmd\r\n");
443 PDUMPMEM(&psSyncInfo->psSyncData->ui32LastReadOpDumpVal,
444 psCCBMemInfo,
445 psKick->ui32CCBDumpWOff + offsetof(SGXMKIF_2DCMD_SHARED, sSrcSyncData[i].ui32ReadOpsPendingVal),
446 sizeof(psSyncInfo->psSyncData->ui32LastReadOpDumpVal),
447 psKick->ui32PDumpFlags,
448 MAKEUNIQUETAG(psCCBMemInfo));
449 }
450
451 if (psKick->hDstSyncInfo != IMG_NULL)
452 {
453 psSyncInfo = psKick->hDstSyncInfo;
454
455 PDUMPCOMMENT("Hack dest surface write op in 2D cmd\r\n");
456 PDUMPMEM(&psSyncInfo->psSyncData->ui32LastOpDumpVal,
457 psCCBMemInfo,
458 psKick->ui32CCBDumpWOff + offsetof(SGXMKIF_2DCMD_SHARED, sDstSyncData.ui32WriteOpsPendingVal),
459 sizeof(psSyncInfo->psSyncData->ui32LastOpDumpVal),
460 psKick->ui32PDumpFlags,
461 MAKEUNIQUETAG(psCCBMemInfo));
462
463 PDUMPCOMMENT("Hack dest surface read op in 2D cmd\r\n");
464 PDUMPMEM(&psSyncInfo->psSyncData->ui32LastReadOpDumpVal,
465 psCCBMemInfo,
466 psKick->ui32CCBDumpWOff + offsetof(SGXMKIF_2DCMD_SHARED, sDstSyncData.ui32ReadOpsPendingVal),
467 sizeof(psSyncInfo->psSyncData->ui32LastReadOpDumpVal),
468 psKick->ui32PDumpFlags,
469 MAKEUNIQUETAG(psCCBMemInfo));
470 }
471
472
473 for (i = 0; i < psKick->ui32NumSrcSync; i++)
474 {
475 psSyncInfo = psKick->ahSrcSyncInfo[i];
476 psSyncInfo->psSyncData->ui32LastReadOpDumpVal++;
477 }
478
479 if (psKick->hDstSyncInfo != IMG_NULL)
480 {
481 psSyncInfo = psKick->hDstSyncInfo;
482 psSyncInfo->psSyncData->ui32LastOpDumpVal++;
483 }
484 }
485#endif
486
487 sCommand.ui32Data[1] = psKick->sHW2DContextDevVAddr.uiAddr;
488
489 eError = SGXScheduleCCBCommandKM(hDevHandle, SGXMKIF_CMD_2D, &sCommand, KERNEL_ID, psKick->ui32PDumpFlags);
490
491 if (eError == PVRSRV_ERROR_RETRY)
492 {
493
494
495#if defined(PDUMP)
496 if (PDumpIsCaptureFrameKM())
497 {
498 for (i = 0; i < psKick->ui32NumSrcSync; i++)
499 {
500 psSyncInfo = psKick->ahSrcSyncInfo[i];
501 psSyncInfo->psSyncData->ui32LastReadOpDumpVal--;
502 }
503
504 if (psKick->hDstSyncInfo != IMG_NULL)
505 {
506 psSyncInfo = psKick->hDstSyncInfo;
507 psSyncInfo->psSyncData->ui32LastOpDumpVal--;
508 }
509 }
510#endif
511
512 for (i = 0; i < psKick->ui32NumSrcSync; i++)
513 {
514 psSyncInfo = psKick->ahSrcSyncInfo[i];
515 psSyncInfo->psSyncData->ui32ReadOpsPending--;
516 }
517
518 if (psKick->hDstSyncInfo != IMG_NULL)
519 {
520 psSyncInfo = psKick->hDstSyncInfo;
521 psSyncInfo->psSyncData->ui32WriteOpsPending--;
522 }
523
524
525 if (psKick->hTASyncInfo != IMG_NULL)
526 {
527 psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->hTASyncInfo;
528
529 psSyncInfo->psSyncData->ui32WriteOpsPending--;
530 }
531
532
533 if (psKick->h3DSyncInfo != IMG_NULL)
534 {
535 psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->h3DSyncInfo;
536
537 psSyncInfo->psSyncData->ui32WriteOpsPending--;
538 }
539 }
540
541
542
543
544#if defined(NO_HARDWARE)
545
546 for(i = 0; i < psKick->ui32NumSrcSync; i++)
547 {
548 psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->ahSrcSyncInfo[i];
549 psSyncInfo->psSyncData->ui32ReadOpsComplete = psSyncInfo->psSyncData->ui32ReadOpsPending;
550 }
551
552 psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->hDstSyncInfo;
553 psSyncInfo->psSyncData->ui32WriteOpsComplete = psSyncInfo->psSyncData->ui32WriteOpsPending;
554
555 if (psKick->hTASyncInfo != IMG_NULL)
556 {
557 psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->hTASyncInfo;
558
559 psSyncInfo->psSyncData->ui32WriteOpsComplete = psSyncInfo->psSyncData->ui32WriteOpsPending;
560 }
561
562 if (psKick->h3DSyncInfo != IMG_NULL)
563 {
564 psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psKick->h3DSyncInfo;
565
566 psSyncInfo->psSyncData->ui32WriteOpsComplete = psSyncInfo->psSyncData->ui32WriteOpsPending;
567 }
568#endif
569
570 return eError;
571}
572#endif
573#endif
generated by cgit v1.2.2 (git 2.25.0) at 2025-04-25 14:04:05 -0400