1. Instead kmalloc to kzalloc.
2. Clear cleanup_sync in pvr_sync_clean_freelist.
goto err_out;
}
- psBuffer = kmalloc(sizeof(DC_FBDEV_BUFFER), GFP_KERNEL);
+ psBuffer = kzalloc(sizeof(DC_FBDEV_BUFFER), GFP_KERNEL);
if (!psBuffer)
{
eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto err_module_put;
}
- gpsDeviceData = kmalloc(sizeof(DC_FBDEV_DEVICE), GFP_KERNEL);
+ gpsDeviceData = kzalloc(sizeof(DC_FBDEV_DEVICE), GFP_KERNEL);
if(!gpsDeviceData)
goto err_module_put;
#define PVRVERSION_UNPACK_MIN(VERSION) (((VERSION) >> 0) & 0xFFFF)
//chenli:define rockchip version
-#define RKVERSION "L 0.11"
+#define RKVERSION "L 0.12"
#endif /* _PVRVERSION_H_ */
* handle cases e.g. during fence timeouts where validates
* are called without corresponding posts.
*/
- int *validates = kmalloc(sizeof(int), GFP_KERNEL);
+ int *validates = kzalloc(sizeof(int), GFP_KERNEL);
*validates = atomic_inc_return(&pdp->num_validates);
*driver_state = validates;
} else {
if (list_empty(&sync_pool_free_list)) {
/* If there is nothing in the pool, create a new sync prim. */
- sync = kmalloc(sizeof(struct pvr_sync_native_sync_prim),
+ sync = kzalloc(sizeof(struct pvr_sync_native_sync_prim),
GFP_KERNEL);
if (!sync) {
pr_err("pvr_sync: %s: Failed to allocate sync data",
goto err_out;
}
- kernel = kmalloc(sizeof(struct pvr_sync_kernel_pair), GFP_KERNEL);
+ kernel = kzalloc(sizeof(struct pvr_sync_kernel_pair), GFP_KERNEL);
if (!kernel) {
pr_err("pvr_sync: %s: Failed to allocate sync kernel",
__func__);
goto err_put_fence;
}
- sync_fence = kmalloc(sizeof(struct pvr_sync_fence), GFP_KERNEL);
+ sync_fence = kzalloc(sizeof(struct pvr_sync_fence), GFP_KERNEL);
if (!sync_fence) {
pr_err("pvr_sync: %s: Failed to allocate pvr sync fence",
__func__);
kernel->cleanup_sync->next_value++;
/* The custom waiter structure is freed in the waiter callback */
- waiter = kmalloc(sizeof(struct pvr_sync_fence_waiter), GFP_KERNEL);
+ waiter = kzalloc(sizeof(struct pvr_sync_fence_waiter), GFP_KERNEL);
if (!waiter) {
pr_err("pvr_sync: %s: Failed to allocate waiter", __func__);
goto err_free_cleanup_sync;
continue;
}
+ kernel->cleanup_sync=NULL;
/* Remove the entry from the free list. */
list_move_tail(&kernel->list, &unlocked_free_list);
}
if (signal) {
timeline_to_signal =
- kmalloc(sizeof(struct pvr_sync_tl_to_signal),
+ kzalloc(sizeof(struct pvr_sync_tl_to_signal),
GFP_KERNEL);
if (!timeline_to_signal)
break;
#define OSLockCreate(phLock, eLockType) ({ \
PVRSRV_ERROR e = PVRSRV_ERROR_OUT_OF_MEMORY; \
- *(phLock) = kmalloc(sizeof(struct mutex), GFP_KERNEL); \
+ *(phLock) = kzalloc(sizeof(struct mutex), GFP_KERNEL); \
if (*(phLock)) { mutex_init(*(phLock)); e = PVRSRV_OK; }; \
e;})
#define OSLockDestroy(hLock) ({mutex_destroy((hLock)); kfree((hLock)); PVRSRV_OK;})
}
else
{
- pvRet = kmalloc(ui32Size, GFP_KERNEL);
+ pvRet = kzalloc(ui32Size, GFP_KERNEL);
}
#if defined(PVRSRV_ENABLE_PROCESS_STATS)
}
IMG_INTERNAL IMG_PVOID OSAllocMemstatMem(IMG_UINT32 ui32Size)
{
- IMG_PVOID pvRet = kmalloc(ui32Size, GFP_KERNEL);
+ IMG_PVOID pvRet = kzalloc(ui32Size, GFP_KERNEL);
return pvRet;
}
LISR_DATA *psLISRData;
unsigned long flags = 0;
- psLISRData = kmalloc(sizeof(LISR_DATA), GFP_KERNEL);
+ psLISRData = kzalloc(sizeof(LISR_DATA), GFP_KERNEL);
psLISRData->pfnLISR = pfnLISR;
psLISRData->pvData = pvData;
{
MISR_DATA *psMISRData;
- psMISRData = kmalloc(sizeof(MISR_DATA), GFP_KERNEL);
+ psMISRData = kzalloc(sizeof(MISR_DATA), GFP_KERNEL);
if (psMISRData == NULL)
{
return PVRSRV_ERROR_OUT_OF_MEMORY;
{
MISR_DATA *psMISRData;
- psMISRData = kmalloc(sizeof(MISR_DATA), GFP_KERNEL);
+ psMISRData = kzalloc(sizeof(MISR_DATA), GFP_KERNEL);
if (psMISRData == NULL)
{
return PVRSRV_ERROR_OUT_OF_MEMORY;
{
MISR_DATA *psMISRData;
- psMISRData = kmalloc(sizeof(MISR_DATA), GFP_KERNEL);
+ psMISRData = kzalloc(sizeof(MISR_DATA), GFP_KERNEL);
if (psMISRData == NULL)
{
return PVRSRV_ERROR_OUT_OF_MEMORY;
OSThreadData *psOSThreadData;
PVRSRV_ERROR eError;
- psOSThreadData = kmalloc(sizeof(OSThreadData), GFP_KERNEL);
+ psOSThreadData = kzalloc(sizeof(OSThreadData), GFP_KERNEL);
if (psOSThreadData == IMG_NULL)
{
eError = PVRSRV_ERROR_OUT_OF_MEMORY;
{
POSWR_LOCK psLock;
- psLock = kmalloc(sizeof(*psLock), GFP_KERNEL);
+ psLock = kzalloc(sizeof(*psLock), GFP_KERNEL);
if (psLock == NULL)
{
return PVRSRV_ERROR_OUT_OF_MEMORY;
PVR_ASSERT(gpsPVRDebugFSEntryDir != NULL);
- psPrivData = kmalloc(sizeof(*psPrivData), GFP_KERNEL);
+ psPrivData = kzalloc(sizeof(*psPrivData), GFP_KERNEL);
if (psPrivData == NULL)
{
return -ENOMEM;
IMG_UINT32 i;
PVR_PCI_DEV *psPVRPCI;
- psPVRPCI = kmalloc(sizeof(*psPVRPCI), GFP_KERNEL);
+ psPVRPCI = kzalloc(sizeof(*psPVRPCI), GFP_KERNEL);
if (psPVRPCI == IMG_NULL)
{
printk(KERN_ERR "OSPCISetDev: Couldn't allocate PVR PCI structure\n");
if (NULL == platform)
{
- PVR_DPF((PVR_DBG_ERROR, "RgxRkInit: Failed to kmalloc rk_context"));
+ PVR_DPF((PVR_DBG_ERROR, "RgxRkInit: Failed to kzalloc rk_context"));
return;
}
{
MUTEX *psMutex;
- psMutex = kmalloc(sizeof(*psMutex), GFP_KERNEL);
+ psMutex = kzalloc(sizeof(*psMutex), GFP_KERNEL);
if (psMutex)
{
INIT_MUTEX(psMutex);