← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise-security

« back to all changes in this revision

Viewing changes to drivers/gpu/pvr/sgx/sgxkick.c

  • Committer: Package Import Robot
  • Author(s): Paolo Pisati, Paolo Pisati
  • Date: 2011-12-06 15:56:07 UTC
  • Revision ID: package-import@ubuntu.com-20111206155607-pcf44kv5fmhk564f
Tags: 3.2.0-1401.1
[ Paolo Pisati ]

* Rebased on top of Ubuntu-3.2.0-3.8
* Tilt-tracking @ ef2487af4bb15bdd0689631774b5a5e3a59f74e2
* Delete debian.ti-omap4/control, it shoudln't be tracked
* Fix architecture spelling (s/armel/armhf/)
* [Config] Update configs following 3.2 import
* [Config] Fix compilation: disable CODA and ARCH_OMAP3
* [Config] Fix compilation: disable Ethernet Faraday
* Update series to precise

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/gpu/pvr/sgx/sgxkick.c
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
 
#include <stddef.h> 
28
 
#include "services_headers.h"
29
 
#include "sgxinfo.h"
30
 
#include "sgxinfokm.h"
31
 
#if defined (PDUMP)
32
 
#include "sgxapi_km.h"
33
 
#include "pdump_km.h"
34
 
#endif
35
 
#include "sgx_bridge_km.h"
36
 
#include "osfunc.h"
37
 
#include "pvr_debug.h"
38
 
#include "sgxutils.h"
39
 
#include "ttrace.h"
40
 
 
41
 
IMG_EXPORT
42
 
#if defined (SUPPORT_SID_INTERFACE)
43
 
PVRSRV_ERROR SGXDoKickKM(IMG_HANDLE hDevHandle, SGX_CCB_KICK_KM *psCCBKick)
44
 
#else
45
 
PVRSRV_ERROR SGXDoKickKM(IMG_HANDLE hDevHandle, SGX_CCB_KICK *psCCBKick)
46
 
#endif
47
 
{
48
 
        PVRSRV_ERROR eError;
49
 
        PVRSRV_KERNEL_SYNC_INFO *psSyncInfo;
50
 
        PVRSRV_KERNEL_MEM_INFO  *psCCBMemInfo = (PVRSRV_KERNEL_MEM_INFO *) psCCBKick->hCCBKernelMemInfo;
51
 
        SGXMKIF_CMDTA_SHARED *psTACmd;
52
 
        IMG_UINT32 i;
53
 
        IMG_HANDLE hDevMemContext = IMG_NULL;
54
 
#if defined(FIX_HW_BRN_31620)
55
 
        hDevMemContext = psCCBKick->hDevMemContext;
56
 
#endif
57
 
        PVR_TTRACE(PVRSRV_TRACE_GROUP_KICK, PVRSRV_TRACE_CLASS_FUNCTION_ENTER, KICK_TOKEN_DOKICK);
58
 
 
59
 
        if (!CCB_OFFSET_IS_VALID(SGXMKIF_CMDTA_SHARED, psCCBMemInfo, psCCBKick, ui32CCBOffset))
60
 
        {
61
 
                PVR_DPF((PVR_DBG_ERROR, "SGXDoKickKM: Invalid CCB offset"));
62
 
                PVR_TTRACE(PVRSRV_TRACE_GROUP_KICK, PVRSRV_TRACE_CLASS_FUNCTION_EXIT, KICK_TOKEN_DOKICK);
63
 
                return PVRSRV_ERROR_INVALID_PARAMS;
64
 
        }
65
 
        
66
 
        
67
 
        psTACmd = CCB_DATA_FROM_OFFSET(SGXMKIF_CMDTA_SHARED, psCCBMemInfo, psCCBKick, ui32CCBOffset);
68
 
 
69
 
        PVR_TTRACE(PVRSRV_TRACE_GROUP_KICK, PVRSRV_TRACE_CLASS_CMD_START, KICK_TOKEN_DOKICK);
70
 
        PVR_TTRACE_UI32(PVRSRV_TRACE_GROUP_KICK, PVRSRV_TRACE_CLASS_CCB,
71
 
                        KICK_TOKEN_CCB_OFFSET, psCCBKick->ui32CCBOffset);
72
 
 
73
 
        
74
 
        if (psCCBKick->hTA3DSyncInfo)
75
 
        {
76
 
                psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psCCBKick->hTA3DSyncInfo;
77
 
 
78
 
                PVR_TTRACE_SYNC_OBJECT(PVRSRV_TRACE_GROUP_KICK, KICK_TOKEN_TA3D_SYNC,
79
 
                                          psSyncInfo, PVRSRV_SYNCOP_SAMPLE);
80
 
 
81
 
                psTACmd->sTA3DDependency.sWriteOpsCompleteDevVAddr = psSyncInfo->sWriteOpsCompleteDevVAddr;
82
 
 
83
 
                psTACmd->sTA3DDependency.ui32WriteOpsPendingVal   = psSyncInfo->psSyncData->ui32WriteOpsPending;
84
 
 
85
 
                if (psCCBKick->bTADependency)
86
 
                {
87
 
                        psSyncInfo->psSyncData->ui32WriteOpsPending++;
88
 
                }
89
 
        }
90
 
 
91
 
        if (psCCBKick->hTASyncInfo != IMG_NULL)
92
 
        {
93
 
                psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psCCBKick->hTASyncInfo;
94
 
 
95
 
                PVR_TTRACE_SYNC_OBJECT(PVRSRV_TRACE_GROUP_KICK, KICK_TOKEN_TA_SYNC,
96
 
                                          psSyncInfo, PVRSRV_SYNCOP_SAMPLE);
97
 
 
98
 
                psTACmd->sTATQSyncReadOpsCompleteDevVAddr  = psSyncInfo->sReadOpsCompleteDevVAddr;
99
 
                psTACmd->sTATQSyncWriteOpsCompleteDevVAddr = psSyncInfo->sWriteOpsCompleteDevVAddr;
100
 
 
101
 
                psTACmd->ui32TATQSyncReadOpsPendingVal = psSyncInfo->psSyncData->ui32ReadOpsPending++;
102
 
                psTACmd->ui32TATQSyncWriteOpsPendingVal = psSyncInfo->psSyncData->ui32WriteOpsPending;
103
 
        }
104
 
 
105
 
        if (psCCBKick->h3DSyncInfo != IMG_NULL)
106
 
        {
107
 
                psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psCCBKick->h3DSyncInfo;
108
 
 
109
 
                PVR_TTRACE_SYNC_OBJECT(PVRSRV_TRACE_GROUP_KICK, KICK_TOKEN_3D_SYNC,
110
 
                                          psSyncInfo, PVRSRV_SYNCOP_SAMPLE);
111
 
 
112
 
                psTACmd->s3DTQSyncReadOpsCompleteDevVAddr  = psSyncInfo->sReadOpsCompleteDevVAddr;
113
 
                psTACmd->s3DTQSyncWriteOpsCompleteDevVAddr = psSyncInfo->sWriteOpsCompleteDevVAddr;
114
 
 
115
 
                psTACmd->ui323DTQSyncReadOpsPendingVal = psSyncInfo->psSyncData->ui32ReadOpsPending++;
116
 
                psTACmd->ui323DTQSyncWriteOpsPendingVal  = psSyncInfo->psSyncData->ui32WriteOpsPending;
117
 
        }
118
 
 
119
 
        psTACmd->ui32NumTAStatusVals = psCCBKick->ui32NumTAStatusVals;
120
 
        if (psCCBKick->ui32NumTAStatusVals != 0)
121
 
        {
122
 
                
123
 
                for (i = 0; i < psCCBKick->ui32NumTAStatusVals; i++)
124
 
                {
125
 
#if defined(SUPPORT_SGX_NEW_STATUS_VALS)
126
 
                        psTACmd->sCtlTAStatusInfo[i] = psCCBKick->asTAStatusUpdate[i].sCtlStatus;
127
 
#else
128
 
                        psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psCCBKick->ahTAStatusSyncInfo[i];
129
 
                        psTACmd->sCtlTAStatusInfo[i].sStatusDevAddr = psSyncInfo->sReadOpsCompleteDevVAddr;
130
 
                        psTACmd->sCtlTAStatusInfo[i].ui32StatusValue = psSyncInfo->psSyncData->ui32ReadOpsPending;
131
 
#endif
132
 
                }
133
 
        }
134
 
 
135
 
        psTACmd->ui32Num3DStatusVals = psCCBKick->ui32Num3DStatusVals;
136
 
        if (psCCBKick->ui32Num3DStatusVals != 0)
137
 
        {
138
 
                
139
 
                for (i = 0; i < psCCBKick->ui32Num3DStatusVals; i++)
140
 
                {
141
 
#if defined(SUPPORT_SGX_NEW_STATUS_VALS)
142
 
                        psTACmd->sCtl3DStatusInfo[i] = psCCBKick->as3DStatusUpdate[i].sCtlStatus;
143
 
#else
144
 
                        psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psCCBKick->ah3DStatusSyncInfo[i];
145
 
                        psTACmd->sCtl3DStatusInfo[i].sStatusDevAddr = psSyncInfo->sReadOpsCompleteDevVAddr;
146
 
                        psTACmd->sCtl3DStatusInfo[i].ui32StatusValue = psSyncInfo->psSyncData->ui32ReadOpsPending;
147
 
#endif
148
 
                }
149
 
        }
150
 
 
151
 
 
152
 
#if defined(SUPPORT_SGX_GENERALISED_SYNCOBJECTS)
153
 
        
154
 
        psTACmd->ui32NumTASrcSyncs = psCCBKick->ui32NumTASrcSyncs;
155
 
        for (i=0; i<psCCBKick->ui32NumTASrcSyncs; i++)
156
 
        {
157
 
                psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *) psCCBKick->ahTASrcKernelSyncInfo[i];
158
 
 
159
 
                psTACmd->asTASrcSyncs[i].sWriteOpsCompleteDevVAddr = psSyncInfo->sWriteOpsCompleteDevVAddr;
160
 
                psTACmd->asTASrcSyncs[i].sReadOpsCompleteDevVAddr = psSyncInfo->sReadOpsCompleteDevVAddr;
161
 
 
162
 
                
163
 
                psTACmd->asTASrcSyncs[i].ui32ReadOpsPendingVal = psSyncInfo->psSyncData->ui32ReadOpsPending++;
164
 
                
165
 
                psTACmd->asTASrcSyncs[i].ui32WriteOpsPendingVal = psSyncInfo->psSyncData->ui32WriteOpsPending;
166
 
        }
167
 
 
168
 
        psTACmd->ui32NumTADstSyncs = psCCBKick->ui32NumTADstSyncs;
169
 
        for (i=0; i<psCCBKick->ui32NumTADstSyncs; i++)
170
 
        {
171
 
                psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *) psCCBKick->ahTADstKernelSyncInfo[i];
172
 
 
173
 
                psTACmd->asTADstSyncs[i].sWriteOpsCompleteDevVAddr = psSyncInfo->sWriteOpsCompleteDevVAddr;
174
 
                psTACmd->asTADstSyncs[i].sReadOpsCompleteDevVAddr = psSyncInfo->sReadOpsCompleteDevVAddr;
175
 
 
176
 
                
177
 
                psTACmd->asTADstSyncs[i].ui32ReadOpsPendingVal = psSyncInfo->psSyncData->ui32ReadOpsPending;
178
 
                
179
 
                psTACmd->asTADstSyncs[i].ui32WriteOpsPendingVal = psSyncInfo->psSyncData->ui32WriteOpsPending++;
180
 
        }
181
 
 
182
 
        psTACmd->ui32Num3DSrcSyncs = psCCBKick->ui32Num3DSrcSyncs;
183
 
        for (i=0; i<psCCBKick->ui32Num3DSrcSyncs; i++)
184
 
        {
185
 
                psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *) psCCBKick->ah3DSrcKernelSyncInfo[i];
186
 
 
187
 
                psTACmd->as3DSrcSyncs[i].sWriteOpsCompleteDevVAddr = psSyncInfo->sWriteOpsCompleteDevVAddr;
188
 
                psTACmd->as3DSrcSyncs[i].sReadOpsCompleteDevVAddr = psSyncInfo->sReadOpsCompleteDevVAddr;
189
 
 
190
 
                
191
 
                psTACmd->as3DSrcSyncs[i].ui32ReadOpsPendingVal = psSyncInfo->psSyncData->ui32ReadOpsPending++;
192
 
                
193
 
                psTACmd->as3DSrcSyncs[i].ui32WriteOpsPendingVal = psSyncInfo->psSyncData->ui32WriteOpsPending;
194
 
        }
195
 
#else 
196
 
        
197
 
        psTACmd->ui32NumSrcSyncs = psCCBKick->ui32NumSrcSyncs;
198
 
        for (i=0; i<psCCBKick->ui32NumSrcSyncs; i++)
199
 
        {
200
 
                psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *) psCCBKick->ahSrcKernelSyncInfo[i];
201
 
 
202
 
                PVR_TTRACE_SYNC_OBJECT(PVRSRV_TRACE_GROUP_KICK, KICK_TOKEN_SRC_SYNC,
203
 
                                          psSyncInfo, PVRSRV_SYNCOP_SAMPLE);
204
 
 
205
 
                psTACmd->asSrcSyncs[i].sWriteOpsCompleteDevVAddr = psSyncInfo->sWriteOpsCompleteDevVAddr;
206
 
                psTACmd->asSrcSyncs[i].sReadOpsCompleteDevVAddr = psSyncInfo->sReadOpsCompleteDevVAddr;
207
 
 
208
 
                
209
 
                psTACmd->asSrcSyncs[i].ui32ReadOpsPendingVal = psSyncInfo->psSyncData->ui32ReadOpsPending++;
210
 
                
211
 
                psTACmd->asSrcSyncs[i].ui32WriteOpsPendingVal = psSyncInfo->psSyncData->ui32WriteOpsPending;
212
 
        }
213
 
#endif
214
 
 
215
 
        if (psCCBKick->bFirstKickOrResume && psCCBKick->ui32NumDstSyncObjects > 0)
216
 
        {
217
 
                PVRSRV_KERNEL_MEM_INFO  *psHWDstSyncListMemInfo =
218
 
                                                                (PVRSRV_KERNEL_MEM_INFO *)psCCBKick->hKernelHWSyncListMemInfo;
219
 
                SGXMKIF_HWDEVICE_SYNC_LIST *psHWDeviceSyncList = psHWDstSyncListMemInfo->pvLinAddrKM;
220
 
                IMG_UINT32      ui32NumDstSyncs = psCCBKick->ui32NumDstSyncObjects;
221
 
 
222
 
                PVR_ASSERT(((PVRSRV_KERNEL_MEM_INFO *)psCCBKick->hKernelHWSyncListMemInfo)->uAllocSize >= (sizeof(SGXMKIF_HWDEVICE_SYNC_LIST) +
223
 
                                                                (sizeof(PVRSRV_DEVICE_SYNC_OBJECT) * ui32NumDstSyncs)));
224
 
 
225
 
                psHWDeviceSyncList->ui32NumSyncObjects = ui32NumDstSyncs;
226
 
#if defined(PDUMP)
227
 
                if (PDumpIsCaptureFrameKM())
228
 
                {
229
 
                        PDUMPCOMMENT("HWDeviceSyncList for TACmd\r\n");
230
 
                        PDUMPMEM(IMG_NULL,
231
 
                                         psHWDstSyncListMemInfo,
232
 
                                         0,
233
 
                                         sizeof(SGXMKIF_HWDEVICE_SYNC_LIST),
234
 
                                         0,
235
 
                                         MAKEUNIQUETAG(psHWDstSyncListMemInfo));
236
 
                }
237
 
#endif
238
 
 
239
 
                for (i=0; i<ui32NumDstSyncs; i++)
240
 
                {
241
 
                        psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psCCBKick->pahDstSyncHandles[i];
242
 
 
243
 
                        if (psSyncInfo)
244
 
                        {
245
 
 
246
 
                                PVR_TTRACE_SYNC_OBJECT(PVRSRV_TRACE_GROUP_KICK, KICK_TOKEN_DST_SYNC,
247
 
                                                        psSyncInfo, PVRSRV_SYNCOP_SAMPLE);
248
 
 
249
 
                                psHWDeviceSyncList->asSyncData[i].sWriteOpsCompleteDevVAddr = psSyncInfo->sWriteOpsCompleteDevVAddr;
250
 
                                psHWDeviceSyncList->asSyncData[i].sReadOpsCompleteDevVAddr = psSyncInfo->sReadOpsCompleteDevVAddr;
251
 
 
252
 
                                psHWDeviceSyncList->asSyncData[i].ui32ReadOpsPendingVal = psSyncInfo->psSyncData->ui32ReadOpsPending;
253
 
                                psHWDeviceSyncList->asSyncData[i].ui32WriteOpsPendingVal = psSyncInfo->psSyncData->ui32WriteOpsPending++;
254
 
 
255
 
        #if defined(PDUMP)
256
 
                                if (PDumpIsCaptureFrameKM())
257
 
                                {
258
 
                                        IMG_UINT32 ui32ModifiedValue;
259
 
                                        IMG_UINT32 ui32SyncOffset = offsetof(SGXMKIF_HWDEVICE_SYNC_LIST, asSyncData)
260
 
                                                                                                + (i * sizeof(PVRSRV_DEVICE_SYNC_OBJECT));
261
 
                                        IMG_UINT32 ui32WOpsOffset = ui32SyncOffset
262
 
                                                                                                + offsetof(PVRSRV_DEVICE_SYNC_OBJECT, ui32WriteOpsPendingVal);
263
 
                                        IMG_UINT32 ui32ROpsOffset = ui32SyncOffset
264
 
                                                                                                + offsetof(PVRSRV_DEVICE_SYNC_OBJECT, ui32ReadOpsPendingVal);
265
 
 
266
 
                                        PDUMPCOMMENT("HWDeviceSyncObject for RT: %i\r\n", i);
267
 
 
268
 
                                        PDUMPMEM(IMG_NULL,
269
 
                                                         psHWDstSyncListMemInfo,
270
 
                                                         ui32SyncOffset,
271
 
                                                         sizeof(PVRSRV_DEVICE_SYNC_OBJECT),
272
 
                                                         0,
273
 
                                                         MAKEUNIQUETAG(psHWDstSyncListMemInfo));
274
 
 
275
 
                                        if ((psSyncInfo->psSyncData->ui32LastOpDumpVal == 0) &&
276
 
                                                (psSyncInfo->psSyncData->ui32LastReadOpDumpVal == 0))
277
 
                                        {
278
 
                                                
279
 
                                                PDUMPCOMMENT("Init RT ROpsComplete\r\n");
280
 
                                                PDUMPMEM(&psSyncInfo->psSyncData->ui32LastReadOpDumpVal,
281
 
                                                        psSyncInfo->psSyncDataMemInfoKM,
282
 
                                                        offsetof(PVRSRV_SYNC_DATA, ui32ReadOpsComplete),
283
 
                                                        sizeof(psSyncInfo->psSyncData->ui32ReadOpsComplete),
284
 
                                                        0,
285
 
                                                        MAKEUNIQUETAG(psSyncInfo->psSyncDataMemInfoKM));
286
 
                                                
287
 
                                                PDUMPCOMMENT("Init RT WOpsComplete\r\n");
288
 
                                                        PDUMPMEM(&psSyncInfo->psSyncData->ui32LastOpDumpVal,
289
 
                                                                psSyncInfo->psSyncDataMemInfoKM,
290
 
                                                                offsetof(PVRSRV_SYNC_DATA, ui32WriteOpsComplete),
291
 
                                                                sizeof(psSyncInfo->psSyncData->ui32WriteOpsComplete),
292
 
                                                                0,
293
 
                                                                MAKEUNIQUETAG(psSyncInfo->psSyncDataMemInfoKM));
294
 
                                        }
295
 
 
296
 
                                        psSyncInfo->psSyncData->ui32LastOpDumpVal++;
297
 
 
298
 
                                        ui32ModifiedValue = psSyncInfo->psSyncData->ui32LastOpDumpVal - 1;
299
 
 
300
 
                                        PDUMPCOMMENT("Modify RT %d WOpPendingVal in HWDevSyncList\r\n", i);
301
 
 
302
 
                                        PDUMPMEM(&ui32ModifiedValue,
303
 
                                                psHWDstSyncListMemInfo,
304
 
                                                ui32WOpsOffset,
305
 
                                                sizeof(IMG_UINT32),
306
 
                                                0,
307
 
                                                MAKEUNIQUETAG(psHWDstSyncListMemInfo));
308
 
 
309
 
                                        ui32ModifiedValue = 0;
310
 
                                        PDUMPCOMMENT("Modify RT %d ROpsPendingVal in HWDevSyncList\r\n", i);
311
 
 
312
 
                                        PDUMPMEM(&psSyncInfo->psSyncData->ui32LastReadOpDumpVal,
313
 
                                                 psHWDstSyncListMemInfo,
314
 
                                                 ui32ROpsOffset,
315
 
                                                 sizeof(IMG_UINT32),
316
 
                                                 0,
317
 
                                                MAKEUNIQUETAG(psHWDstSyncListMemInfo));
318
 
                                }
319
 
        #endif  
320
 
                        }
321
 
                        else
322
 
                        {
323
 
                                psHWDeviceSyncList->asSyncData[i].sWriteOpsCompleteDevVAddr.uiAddr = 0;
324
 
                                psHWDeviceSyncList->asSyncData[i].sReadOpsCompleteDevVAddr.uiAddr = 0;
325
 
 
326
 
                                psHWDeviceSyncList->asSyncData[i].ui32ReadOpsPendingVal = 0;
327
 
                                psHWDeviceSyncList->asSyncData[i].ui32WriteOpsPendingVal = 0;
328
 
                        }
329
 
                }
330
 
        }
331
 
        
332
 
        
333
 
 
334
 
 
335
 
        psTACmd->ui32CtrlFlags |= SGXMKIF_CMDTA_CTRLFLAGS_READY;
336
 
 
337
 
#if defined(PDUMP)
338
 
        if (PDumpIsCaptureFrameKM())
339
 
        {
340
 
                PDUMPCOMMENT("Shared part of TA command\r\n");
341
 
 
342
 
                PDUMPMEM(psTACmd,
343
 
                                 psCCBMemInfo,
344
 
                                 psCCBKick->ui32CCBDumpWOff,
345
 
                                 sizeof(SGXMKIF_CMDTA_SHARED),
346
 
                                 0,
347
 
                                 MAKEUNIQUETAG(psCCBMemInfo));
348
 
 
349
 
#if defined(SUPPORT_SGX_GENERALISED_SYNCOBJECTS)
350
 
                for (i=0; i<psCCBKick->ui32NumTASrcSyncs; i++)
351
 
                {
352
 
                        IMG_UINT32      ui32ModifiedValue;
353
 
                        psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *) psCCBKick->ahTASrcKernelSyncInfo[i];
354
 
 
355
 
                        if ((psSyncInfo->psSyncData->ui32LastOpDumpVal == 0) &&
356
 
                                (psSyncInfo->psSyncData->ui32LastReadOpDumpVal == 0))
357
 
                        {
358
 
                                
359
 
                                PDUMPCOMMENT("Init RT TA-SRC ROpsComplete\r\n", i);
360
 
                                PDUMPMEM(&psSyncInfo->psSyncData->ui32LastReadOpDumpVal,
361
 
                                        psSyncInfo->psSyncDataMemInfoKM,
362
 
                                        offsetof(PVRSRV_SYNC_DATA, ui32ReadOpsComplete),
363
 
                                        sizeof(psSyncInfo->psSyncData->ui32ReadOpsComplete),
364
 
                                        0,
365
 
                                        MAKEUNIQUETAG(psSyncInfo->psSyncDataMemInfoKM));
366
 
                                
367
 
                                PDUMPCOMMENT("Init RT TA-SRC WOpsComplete\r\n");
368
 
                                        PDUMPMEM(&psSyncInfo->psSyncData->ui32LastOpDumpVal,
369
 
                                                psSyncInfo->psSyncDataMemInfoKM,
370
 
                                                offsetof(PVRSRV_SYNC_DATA, ui32WriteOpsComplete),
371
 
                                                sizeof(psSyncInfo->psSyncData->ui32WriteOpsComplete),
372
 
                                                0,
373
 
                                                MAKEUNIQUETAG(psSyncInfo->psSyncDataMemInfoKM));
374
 
                        }
375
 
 
376
 
                        psSyncInfo->psSyncData->ui32LastReadOpDumpVal++;
377
 
 
378
 
                        ui32ModifiedValue = psSyncInfo->psSyncData->ui32LastReadOpDumpVal - 1;
379
 
 
380
 
                        PDUMPCOMMENT("Modify TA SrcSync %d ROpsPendingVal\r\n", i);
381
 
 
382
 
                        PDUMPMEM(&ui32ModifiedValue,
383
 
                                 psCCBMemInfo,
384
 
                                 psCCBKick->ui32CCBDumpWOff + offsetof(SGXMKIF_CMDTA_SHARED, asTASrcSyncs) +
385
 
                                        (i * sizeof(PVRSRV_DEVICE_SYNC_OBJECT)) + offsetof(PVRSRV_DEVICE_SYNC_OBJECT, ui32ReadOpsPendingVal),
386
 
                                 sizeof(IMG_UINT32),
387
 
                                 0,
388
 
                                MAKEUNIQUETAG(psCCBMemInfo));
389
 
 
390
 
                        PDUMPCOMMENT("Modify TA SrcSync %d WOpPendingVal\r\n", i);
391
 
 
392
 
                        PDUMPMEM(&psSyncInfo->psSyncData->ui32LastOpDumpVal,
393
 
                                psCCBMemInfo,
394
 
                                psCCBKick->ui32CCBDumpWOff + offsetof(SGXMKIF_CMDTA_SHARED, asTASrcSyncs) +
395
 
                                        (i * sizeof(PVRSRV_DEVICE_SYNC_OBJECT)) + offsetof(PVRSRV_DEVICE_SYNC_OBJECT, ui32WriteOpsPendingVal),
396
 
                                sizeof(IMG_UINT32),
397
 
                                0,
398
 
                                MAKEUNIQUETAG(psCCBMemInfo));
399
 
                }
400
 
 
401
 
                for (i=0; i<psCCBKick->ui32NumTADstSyncs; i++)
402
 
                {
403
 
                        IMG_UINT32      ui32ModifiedValue;
404
 
                        psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *) psCCBKick->ahTADstKernelSyncInfo[i];
405
 
 
406
 
                        if ((psSyncInfo->psSyncData->ui32LastOpDumpVal == 0) &&
407
 
                                (psSyncInfo->psSyncData->ui32LastReadOpDumpVal == 0))
408
 
                        {
409
 
                                
410
 
                                PDUMPCOMMENT("Init RT TA-DST ROpsComplete\r\n", i);
411
 
                                PDUMPMEM(&psSyncInfo->psSyncData->ui32LastReadOpDumpVal,
412
 
                                        psSyncInfo->psSyncDataMemInfoKM,
413
 
                                        offsetof(PVRSRV_SYNC_DATA, ui32ReadOpsComplete),
414
 
                                        sizeof(psSyncInfo->psSyncData->ui32ReadOpsComplete),
415
 
                                        0,
416
 
                                        MAKEUNIQUETAG(psSyncInfo->psSyncDataMemInfoKM));
417
 
                                
418
 
                                PDUMPCOMMENT("Init RT TA-DST WOpsComplete\r\n");
419
 
                                        PDUMPMEM(&psSyncInfo->psSyncData->ui32LastOpDumpVal,
420
 
                                                psSyncInfo->psSyncDataMemInfoKM,
421
 
                                                offsetof(PVRSRV_SYNC_DATA, ui32WriteOpsComplete),
422
 
                                                sizeof(psSyncInfo->psSyncData->ui32WriteOpsComplete),
423
 
                                                0,
424
 
                                                MAKEUNIQUETAG(psSyncInfo->psSyncDataMemInfoKM));
425
 
                        }
426
 
 
427
 
                        psSyncInfo->psSyncData->ui32LastOpDumpVal++;
428
 
 
429
 
                        ui32ModifiedValue = psSyncInfo->psSyncData->ui32LastOpDumpVal - 1;
430
 
 
431
 
                        PDUMPCOMMENT("Modify TA DstSync %d WOpPendingVal\r\n", i);
432
 
 
433
 
                        PDUMPMEM(&ui32ModifiedValue,
434
 
                                 psCCBMemInfo,
435
 
                                 psCCBKick->ui32CCBDumpWOff + offsetof(SGXMKIF_CMDTA_SHARED, asTADstSyncs) +
436
 
                                        (i * sizeof(PVRSRV_DEVICE_SYNC_OBJECT)) + offsetof(PVRSRV_DEVICE_SYNC_OBJECT, ui32WriteOpsPendingVal),
437
 
                                 sizeof(IMG_UINT32),
438
 
                                 0,
439
 
                                MAKEUNIQUETAG(psCCBMemInfo));
440
 
 
441
 
                        PDUMPCOMMENT("Modify TA DstSync %d ROpsPendingVal\r\n", i);
442
 
 
443
 
                        PDUMPMEM(&psSyncInfo->psSyncData->ui32LastReadOpDumpVal,
444
 
                                psCCBMemInfo,
445
 
                                psCCBKick->ui32CCBDumpWOff + offsetof(SGXMKIF_CMDTA_SHARED, asTADstSyncs) +
446
 
                                        (i * sizeof(PVRSRV_DEVICE_SYNC_OBJECT)) + offsetof(PVRSRV_DEVICE_SYNC_OBJECT, ui32ReadOpsPendingVal),
447
 
                                sizeof(IMG_UINT32),
448
 
                                0,
449
 
                                MAKEUNIQUETAG(psCCBMemInfo));
450
 
                }
451
 
 
452
 
                for (i=0; i<psCCBKick->ui32Num3DSrcSyncs; i++)
453
 
                {
454
 
                        IMG_UINT32      ui32ModifiedValue;
455
 
                        psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *) psCCBKick->ah3DSrcKernelSyncInfo[i];
456
 
 
457
 
                        if ((psSyncInfo->psSyncData->ui32LastOpDumpVal == 0) &&
458
 
                                (psSyncInfo->psSyncData->ui32LastReadOpDumpVal == 0))
459
 
                        {
460
 
                                
461
 
                                PDUMPCOMMENT("Init RT 3D-SRC ROpsComplete\r\n", i);
462
 
                                PDUMPMEM(&psSyncInfo->psSyncData->ui32LastReadOpDumpVal,
463
 
                                        psSyncInfo->psSyncDataMemInfoKM,
464
 
                                        offsetof(PVRSRV_SYNC_DATA, ui32ReadOpsComplete),
465
 
                                        sizeof(psSyncInfo->psSyncData->ui32ReadOpsComplete),
466
 
                                        0,
467
 
                                        MAKEUNIQUETAG(psSyncInfo->psSyncDataMemInfoKM));
468
 
                                
469
 
                                PDUMPCOMMENT("Init RT 3D-SRC WOpsComplete\r\n");
470
 
                                        PDUMPMEM(&psSyncInfo->psSyncData->ui32LastOpDumpVal,
471
 
                                                psSyncInfo->psSyncDataMemInfoKM,
472
 
                                                offsetof(PVRSRV_SYNC_DATA, ui32WriteOpsComplete),
473
 
                                                sizeof(psSyncInfo->psSyncData->ui32WriteOpsComplete),
474
 
                                                0,
475
 
                                                MAKEUNIQUETAG(psSyncInfo->psSyncDataMemInfoKM));
476
 
                        }
477
 
 
478
 
                        psSyncInfo->psSyncData->ui32LastReadOpDumpVal++;
479
 
 
480
 
                        ui32ModifiedValue = psSyncInfo->psSyncData->ui32LastReadOpDumpVal - 1;
481
 
 
482
 
                        PDUMPCOMMENT("Modify 3D SrcSync %d ROpsPendingVal\r\n", i);
483
 
 
484
 
                        PDUMPMEM(&ui32ModifiedValue,
485
 
                                 psCCBMemInfo,
486
 
                                 psCCBKick->ui32CCBDumpWOff + offsetof(SGXMKIF_CMDTA_SHARED, as3DSrcSyncs) +
487
 
                                        (i * sizeof(PVRSRV_DEVICE_SYNC_OBJECT)) + offsetof(PVRSRV_DEVICE_SYNC_OBJECT, ui32ReadOpsPendingVal),
488
 
                                 sizeof(IMG_UINT32),
489
 
                                 0,
490
 
                                MAKEUNIQUETAG(psCCBMemInfo));
491
 
 
492
 
                        PDUMPCOMMENT("Modify 3D SrcSync %d WOpPendingVal\r\n", i);
493
 
 
494
 
                        PDUMPMEM(&psSyncInfo->psSyncData->ui32LastOpDumpVal,
495
 
                                psCCBMemInfo,
496
 
                                psCCBKick->ui32CCBDumpWOff + offsetof(SGXMKIF_CMDTA_SHARED, as3DSrcSyncs) +
497
 
                                        (i * sizeof(PVRSRV_DEVICE_SYNC_OBJECT)) + offsetof(PVRSRV_DEVICE_SYNC_OBJECT, ui32WriteOpsPendingVal),
498
 
                                sizeof(IMG_UINT32),
499
 
                                0,
500
 
                                MAKEUNIQUETAG(psCCBMemInfo));
501
 
                }
502
 
#else
503
 
                for (i=0; i<psCCBKick->ui32NumSrcSyncs; i++)
504
 
                {
505
 
                        IMG_UINT32      ui32ModifiedValue;
506
 
                        psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *) psCCBKick->ahSrcKernelSyncInfo[i];
507
 
 
508
 
                        if ((psSyncInfo->psSyncData->ui32LastOpDumpVal == 0) &&
509
 
                                (psSyncInfo->psSyncData->ui32LastReadOpDumpVal == 0))
510
 
                        {
511
 
                                
512
 
                                PDUMPCOMMENT("Init RT ROpsComplete\r\n");
513
 
                                PDUMPMEM(&psSyncInfo->psSyncData->ui32LastReadOpDumpVal,
514
 
                                        psSyncInfo->psSyncDataMemInfoKM,
515
 
                                        offsetof(PVRSRV_SYNC_DATA, ui32ReadOpsComplete),
516
 
                                        sizeof(psSyncInfo->psSyncData->ui32ReadOpsComplete),
517
 
                                        0,
518
 
                                        MAKEUNIQUETAG(psSyncInfo->psSyncDataMemInfoKM));
519
 
                                
520
 
                                PDUMPCOMMENT("Init RT WOpsComplete\r\n");
521
 
                                        PDUMPMEM(&psSyncInfo->psSyncData->ui32LastOpDumpVal,
522
 
                                                psSyncInfo->psSyncDataMemInfoKM,
523
 
                                                offsetof(PVRSRV_SYNC_DATA, ui32WriteOpsComplete),
524
 
                                                sizeof(psSyncInfo->psSyncData->ui32WriteOpsComplete),
525
 
                                                0,
526
 
                                                MAKEUNIQUETAG(psSyncInfo->psSyncDataMemInfoKM));
527
 
                        }
528
 
 
529
 
                        psSyncInfo->psSyncData->ui32LastReadOpDumpVal++;
530
 
 
531
 
                        ui32ModifiedValue = psSyncInfo->psSyncData->ui32LastReadOpDumpVal - 1;
532
 
 
533
 
                        PDUMPCOMMENT("Modify SrcSync %d ROpsPendingVal\r\n", i);
534
 
 
535
 
                        PDUMPMEM(&ui32ModifiedValue,
536
 
                                 psCCBMemInfo,
537
 
                                 psCCBKick->ui32CCBDumpWOff + offsetof(SGXMKIF_CMDTA_SHARED, asSrcSyncs) +
538
 
                                        (i * sizeof(PVRSRV_DEVICE_SYNC_OBJECT)) + offsetof(PVRSRV_DEVICE_SYNC_OBJECT, ui32ReadOpsPendingVal),
539
 
                                 sizeof(IMG_UINT32),
540
 
                                 0,
541
 
                                MAKEUNIQUETAG(psCCBMemInfo));
542
 
 
543
 
                        PDUMPCOMMENT("Modify SrcSync %d WOpPendingVal\r\n", i);
544
 
 
545
 
                        PDUMPMEM(&psSyncInfo->psSyncData->ui32LastOpDumpVal,
546
 
                                psCCBMemInfo,
547
 
                                psCCBKick->ui32CCBDumpWOff + offsetof(SGXMKIF_CMDTA_SHARED, asSrcSyncs) +
548
 
                                        (i * sizeof(PVRSRV_DEVICE_SYNC_OBJECT)) + offsetof(PVRSRV_DEVICE_SYNC_OBJECT, ui32WriteOpsPendingVal),
549
 
                                sizeof(IMG_UINT32),
550
 
                                0,
551
 
                                MAKEUNIQUETAG(psCCBMemInfo));
552
 
                }
553
 
#endif
554
 
 
555
 
                for (i = 0; i < psCCBKick->ui32NumTAStatusVals; i++)
556
 
                {
557
 
#if !defined(SUPPORT_SGX_NEW_STATUS_VALS)
558
 
                        psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psCCBKick->ahTAStatusSyncInfo[i];
559
 
                        PDUMPCOMMENT("Modify TA status value in TA cmd\r\n");
560
 
                        PDUMPMEM(&psSyncInfo->psSyncData->ui32LastOpDumpVal,
561
 
                                 psCCBMemInfo,
562
 
                                 psCCBKick->ui32CCBDumpWOff + (IMG_UINT32)offsetof(SGXMKIF_CMDTA_SHARED, sCtlTAStatusInfo[i].ui32StatusValue),
563
 
                                 sizeof(IMG_UINT32),
564
 
                                 0,
565
 
                                MAKEUNIQUETAG(psCCBMemInfo));
566
 
#endif
567
 
                }
568
 
 
569
 
                for (i = 0; i < psCCBKick->ui32Num3DStatusVals; i++)
570
 
                {
571
 
#if !defined(SUPPORT_SGX_NEW_STATUS_VALS)
572
 
                        psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psCCBKick->ah3DStatusSyncInfo[i];
573
 
                        PDUMPCOMMENT("Modify 3D status value in TA cmd\r\n");
574
 
                        PDUMPMEM(&psSyncInfo->psSyncData->ui32LastOpDumpVal,
575
 
                                 psCCBMemInfo,
576
 
                                 psCCBKick->ui32CCBDumpWOff + (IMG_UINT32)offsetof(SGXMKIF_CMDTA_SHARED, sCtl3DStatusInfo[i].ui32StatusValue),
577
 
                                 sizeof(IMG_UINT32),
578
 
                                 0,
579
 
                                MAKEUNIQUETAG(psCCBMemInfo));
580
 
#endif
581
 
                }
582
 
        }
583
 
#endif  
584
 
 
585
 
        PVR_TTRACE(PVRSRV_TRACE_GROUP_KICK, PVRSRV_TRACE_CLASS_CMD_END,
586
 
                        KICK_TOKEN_DOKICK);
587
 
 
588
 
        eError = SGXScheduleCCBCommandKM(hDevHandle, SGXMKIF_CMD_TA, &psCCBKick->sCommand, KERNEL_ID, 0, hDevMemContext, psCCBKick->bLastInScene);
589
 
        if (eError == PVRSRV_ERROR_RETRY)
590
 
        {
591
 
                if (psCCBKick->bFirstKickOrResume && psCCBKick->ui32NumDstSyncObjects > 0)
592
 
                {
593
 
                        for (i=0; i < psCCBKick->ui32NumDstSyncObjects; i++)
594
 
                        {
595
 
                                
596
 
                                psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psCCBKick->pahDstSyncHandles[i];
597
 
 
598
 
                                if (psSyncInfo)
599
 
                                {
600
 
                                        psSyncInfo->psSyncData->ui32WriteOpsPending--;
601
 
#if defined(PDUMP)
602
 
                                        if (PDumpIsCaptureFrameKM())
603
 
                                        {
604
 
                                                psSyncInfo->psSyncData->ui32LastOpDumpVal--;
605
 
                                        }
606
 
#endif
607
 
                                }
608
 
                        }
609
 
                }
610
 
 
611
 
#if defined(SUPPORT_SGX_GENERALISED_SYNCOBJECTS)
612
 
                for (i=0; i<psCCBKick->ui32NumTASrcSyncs; i++)
613
 
                {
614
 
                        psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *) psCCBKick->ahTASrcKernelSyncInfo[i];
615
 
                        psSyncInfo->psSyncData->ui32ReadOpsPending--;
616
 
                }
617
 
                for (i=0; i<psCCBKick->ui32NumTADstSyncs; i++)
618
 
                {
619
 
                        psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *) psCCBKick->ahTADstKernelSyncInfo[i];
620
 
                        psSyncInfo->psSyncData->ui32WriteOpsPending--;
621
 
                }
622
 
                for (i=0; i<psCCBKick->ui32Num3DSrcSyncs; i++)
623
 
                {
624
 
                        psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *) psCCBKick->ah3DSrcKernelSyncInfo[i];
625
 
                        psSyncInfo->psSyncData->ui32ReadOpsPending--;
626
 
                }
627
 
#else
628
 
                for (i=0; i<psCCBKick->ui32NumSrcSyncs; i++)
629
 
                {
630
 
                        psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *) psCCBKick->ahSrcKernelSyncInfo[i];
631
 
                        psSyncInfo->psSyncData->ui32ReadOpsPending--;
632
 
                }
633
 
#endif
634
 
 
635
 
                PVR_TTRACE(PVRSRV_TRACE_GROUP_KICK, PVRSRV_TRACE_CLASS_FUNCTION_EXIT,
636
 
                                KICK_TOKEN_DOKICK);
637
 
                return eError;
638
 
        }
639
 
        else if (PVRSRV_OK != eError)
640
 
        {
641
 
                PVR_DPF((PVR_DBG_ERROR, "SGXDoKickKM: SGXScheduleCCBCommandKM failed."));
642
 
                PVR_TTRACE(PVRSRV_TRACE_GROUP_KICK, PVRSRV_TRACE_CLASS_FUNCTION_EXIT,
643
 
                                KICK_TOKEN_DOKICK);
644
 
                return eError;
645
 
        }
646
 
 
647
 
 
648
 
#if defined(NO_HARDWARE)
649
 
 
650
 
 
651
 
        
652
 
        if (psCCBKick->hTA3DSyncInfo)
653
 
        {
654
 
                psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psCCBKick->hTA3DSyncInfo;
655
 
 
656
 
                if (psCCBKick->bTADependency)
657
 
                {
658
 
                        psSyncInfo->psSyncData->ui32WriteOpsComplete = psSyncInfo->psSyncData->ui32WriteOpsPending;
659
 
                }
660
 
        }
661
 
 
662
 
        if (psCCBKick->hTASyncInfo != IMG_NULL)
663
 
        {
664
 
                psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psCCBKick->hTASyncInfo;
665
 
 
666
 
                psSyncInfo->psSyncData->ui32ReadOpsComplete =  psSyncInfo->psSyncData->ui32ReadOpsPending;
667
 
        }
668
 
 
669
 
        if (psCCBKick->h3DSyncInfo != IMG_NULL)
670
 
        {
671
 
                psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psCCBKick->h3DSyncInfo;
672
 
 
673
 
                psSyncInfo->psSyncData->ui32ReadOpsComplete =  psSyncInfo->psSyncData->ui32ReadOpsPending;
674
 
        }
675
 
 
676
 
        
677
 
        for (i = 0; i < psCCBKick->ui32NumTAStatusVals; i++)
678
 
        {
679
 
#if defined(SUPPORT_SGX_NEW_STATUS_VALS)
680
 
                PVRSRV_KERNEL_MEM_INFO *psKernelMemInfo = (PVRSRV_KERNEL_MEM_INFO*)psCCBKick->asTAStatusUpdate[i].hKernelMemInfo;
681
 
                
682
 
                *(IMG_UINT32*)((IMG_UINTPTR_T)psKernelMemInfo->pvLinAddrKM
683
 
                                                + (psTACmd->sCtlTAStatusInfo[i].sStatusDevAddr.uiAddr
684
 
                                                - psKernelMemInfo->sDevVAddr.uiAddr)) = psTACmd->sCtlTAStatusInfo[i].ui32StatusValue;
685
 
#else
686
 
                psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psCCBKick->ahTAStatusSyncInfo[i];
687
 
                psSyncInfo->psSyncData->ui32ReadOpsComplete = psTACmd->sCtlTAStatusInfo[i].ui32StatusValue;
688
 
#endif
689
 
        }
690
 
 
691
 
#if defined(SUPPORT_SGX_GENERALISED_SYNCOBJECTS)
692
 
        
693
 
        for (i=0; i<psCCBKick->ui32NumTASrcSyncs; i++)
694
 
        {
695
 
                psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *) psCCBKick->ahTASrcKernelSyncInfo[i];
696
 
                psSyncInfo->psSyncData->ui32ReadOpsComplete =  psSyncInfo->psSyncData->ui32ReadOpsPending;
697
 
        }
698
 
        for (i=0; i<psCCBKick->ui32NumTADstSyncs; i++)
699
 
        {
700
 
                psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *) psCCBKick->ahTADstKernelSyncInfo[i];
701
 
                psSyncInfo->psSyncData->ui32WriteOpsComplete =  psSyncInfo->psSyncData->ui32WriteOpsPending;
702
 
        }
703
 
        for (i=0; i<psCCBKick->ui32Num3DSrcSyncs; i++)
704
 
        {
705
 
                psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *) psCCBKick->ah3DSrcKernelSyncInfo[i];
706
 
                psSyncInfo->psSyncData->ui32ReadOpsComplete =  psSyncInfo->psSyncData->ui32ReadOpsPending;
707
 
        }
708
 
#else
709
 
        
710
 
        for (i=0; i<psCCBKick->ui32NumSrcSyncs; i++)
711
 
        {
712
 
                psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *) psCCBKick->ahSrcKernelSyncInfo[i];
713
 
                psSyncInfo->psSyncData->ui32ReadOpsComplete =  psSyncInfo->psSyncData->ui32ReadOpsPending;
714
 
        }
715
 
#endif
716
 
 
717
 
        if (psCCBKick->bTerminateOrAbort)
718
 
        {
719
 
                if (psCCBKick->ui32NumDstSyncObjects > 0)
720
 
                {
721
 
                        PVRSRV_KERNEL_MEM_INFO  *psHWDstSyncListMemInfo =
722
 
                                                                (PVRSRV_KERNEL_MEM_INFO *)psCCBKick->hKernelHWSyncListMemInfo;
723
 
                        SGXMKIF_HWDEVICE_SYNC_LIST *psHWDeviceSyncList = psHWDstSyncListMemInfo->pvLinAddrKM;
724
 
 
725
 
                        for (i=0; i<psCCBKick->ui32NumDstSyncObjects; i++)
726
 
                        {
727
 
                                psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psCCBKick->pahDstSyncHandles[i];
728
 
                                if (psSyncInfo)
729
 
                                        psSyncInfo->psSyncData->ui32WriteOpsComplete = psHWDeviceSyncList->asSyncData[i].ui32WriteOpsPendingVal+1;
730
 
                        }
731
 
                }
732
 
 
733
 
                
734
 
                for (i = 0; i < psCCBKick->ui32Num3DStatusVals; i++)
735
 
                {
736
 
#if defined(SUPPORT_SGX_NEW_STATUS_VALS)
737
 
                        PVRSRV_KERNEL_MEM_INFO *psKernelMemInfo = (PVRSRV_KERNEL_MEM_INFO*)psCCBKick->as3DStatusUpdate[i].hKernelMemInfo;
738
 
                        
739
 
                        *(IMG_UINT32*)((IMG_UINTPTR_T)psKernelMemInfo->pvLinAddrKM
740
 
                                                        + (psTACmd->sCtl3DStatusInfo[i].sStatusDevAddr.uiAddr
741
 
                                                        - psKernelMemInfo->sDevVAddr.uiAddr)) = psTACmd->sCtl3DStatusInfo[i].ui32StatusValue;
742
 
#else
743
 
                        psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)psCCBKick->ah3DStatusSyncInfo[i];
744
 
                        psSyncInfo->psSyncData->ui32ReadOpsComplete = psTACmd->sCtl3DStatusInfo[i].ui32StatusValue;
745
 
#endif
746
 
                }
747
 
        }
748
 
#endif
749
 
        PVR_TTRACE(PVRSRV_TRACE_GROUP_KICK, PVRSRV_TRACE_CLASS_FUNCTION_EXIT,
750
 
                        KICK_TOKEN_DOKICK);
751
 
        return eError;
752
 
}
753