void
gckIOMMU_Destory(
IN gckOS Os,
IN gckIOMMU Iommu
)
{
gcmkHEADER();
if (Iommu->domain && Iommu->device)
{
iommu_attach_device(Iommu->domain, Iommu->device);
}
if (Iommu->domain)
{
iommu_domain_free(Iommu->domain);
}
if (Iommu)
{
gcmkOS_SAFE_FREE(Os, Iommu);
}
gcmkFOOTER_NO();
}
gceSTATUS
gckKERNEL_SecurityUnmapMemory(
IN gckKERNEL Kernel,
IN gctUINT32 GPUAddress,
IN gctUINT32 PageCount
)
{
gceSTATUS status;
gcsTA_INTERFACE iface;
gcmkHEADER();
iface.command = KERNEL_UNMAP_MEMORY;
iface.u.UnmapMemory.gpuAddress = GPUAddress;
iface.u.UnmapMemory.pageCount = PageCount;
gcmkONERROR(gckKERNEL_SecurityCallService(Kernel->securityChannel, &iface));
gcmkFOOTER_NO();
return gcvSTATUS_OK;
OnError:
gcmkFOOTER();
return status;
}
static void drv_exit(void)
#endif
{
gcmkHEADER();
gcmkASSERT(gpuClass != gcvNULL);
device_destroy(gpuClass, MKDEV(major, 0));
class_destroy(gpuClass);
unregister_chrdev(major, DEVICE_NAME);
gcmkVERIFY_OK(gckGALDEVICE_Stop(galDevice));
gcmkVERIFY_OK(gckGALDEVICE_Destroy(galDevice));
if(gckDEBUGFS_IsEnabled())
{
gckDEBUGFS_Terminate();
}
#if ENABLE_GPU_CLOCK_BY_DRIVER && LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,28)
{
struct clk * clk = NULL;
#if defined(CONFIG_PXA_DVFM) && (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,29))
gc_pwr(0);
#endif
clk = clk_get(NULL, "GCCLK");
clk_disable(clk);
}
#endif
gcmkFOOTER_NO();
}
gceSTATUS
gckKERNEL_SecurityMapMemory(
IN gckKERNEL Kernel,
IN gctUINT32 *PhysicalArray,
IN gctUINT32 PageCount,
OUT gctUINT32 * GPUAddress
)
{
gceSTATUS status;
gcsTA_INTERFACE iface;
gcmkHEADER();
iface.command = KERNEL_MAP_MEMORY;
#if defined(LINUX)
gcmkONERROR(gckOS_GetPhysicalAddress(Kernel->os, PhysicalArray,
(gctUINT32 *)&iface.u.MapMemory.physicals));
#endif
iface.u.MapMemory.pageCount = PageCount;
gcmkONERROR(gckKERNEL_SecurityCallService(Kernel->securityChannel, &iface));
*GPUAddress = iface.u.MapMemory.gpuAddress;
gcmkFOOTER_NO();
return gcvSTATUS_OK;
OnError:
gcmkFOOTER();
return status;
}
static void drv_exit(void)
#endif
{
gcmkHEADER();
gcmkASSERT(gpuClass != gcvNULL);
device_destroy(gpuClass, MKDEV(major, 0));
class_destroy(gpuClass);
unregister_chrdev(major, DRV_NAME);
gcmkVERIFY_OK(gckGALDEVICE_Stop(galDevice));
gcmkVERIFY_OK(gckGALDEVICE_Destroy(galDevice));
if(gckDebugFileSystemIsEnabled())
{
gckDebugFileSystemTerminate();
}
#if ENABLE_GPU_CLOCK_BY_DRIVER && LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,28)
{
#if MRVL_PLATFORM_PXA1088
gcmkVERIFY_OK(gckOS_GpuPowerDisable(galDevice->os, gcvCORE_2D, gcvTRUE, gcvFALSE));
#endif
gcmkVERIFY_OK(gckOS_GpuPowerDisable(galDevice->os, gcvCORE_MAJOR, gcvTRUE, gcvTRUE));
}
#endif
gcmkFOOTER_NO();
}
gceSTATUS
gckKERNEL_SecurityAllocateSecurityMemory(
IN gckKERNEL Kernel,
IN gctUINT32 Bytes,
OUT gctUINT32 * Handle
)
{
gceSTATUS status;
gcsTA_INTERFACE iface;
gcmkHEADER();
iface.command = KERNEL_ALLOCATE_SECRUE_MEMORY;
iface.u.AllocateSecurityMemory.bytes = Bytes;
gcmkONERROR(gckKERNEL_SecurityCallService(Kernel->securityChannel, &iface));
*Handle = iface.u.AllocateSecurityMemory.memory_handle;
gcmkFOOTER_NO();
return gcvSTATUS_OK;
OnError:
gcmkFOOTER();
return status;
}
static int __devinit gpu_remove(struct platform_device *pdev)
{
gcmkHEADER();
#if MRVL_CONFIG_USE_PM_RUNTIME
pm_runtime_put_sync(&pdev->dev);
pm_runtime_disable(&pdev->dev);
#endif
#if MRVL_CONFIG_ENABLE_GPUFREQ
__disable_gpufreq(galDevice);
#endif
remove_gc_sysfs_file(pdev);
drv_exit();
#if MRVL_CONFIG_ENABLE_EARLYSUSPEND
unregister_early_suspend(&gpu_early_suspend_handler);
#endif
#if MRVL_CONFIG_PROC
remove_gc_proc_file();
#endif
gcmkFOOTER_NO();
return 0;
}
static int __devinit gpu_probe(struct platform_device *pdev)
#endif
{
int ret = -ENODEV;
struct resource* res;
gcmkHEADER();
res = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "gpu_irq");
if (!res)
{
printk(KERN_ERR "%s: No irq line supplied.\n",__FUNCTION__);
goto gpu_probe_fail;
}
irqLine = res->start;
res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "gpu_base");
if (!res)
{
printk(KERN_ERR "%s: No register base supplied.\n",__FUNCTION__);
goto gpu_probe_fail;
}
registerMemBase = res->start;
registerMemSize = res->end - res->start + 1;
res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "gpu_mem");
if (!res)
{
printk(KERN_ERR "%s: No memory base supplied.\n",__FUNCTION__);
goto gpu_probe_fail;
}
contiguousBase = res->start;
contiguousSize = res->end - res->start + 1;
/*####modified for marvell-bg2*/
ret = drv_get_dts_for_gpu();
/*if there is no gpu2d, it will also return error*/
/*####end for marvell-bg2*/
ret = drv_init();
if (!ret)
{
platform_set_drvdata(pdev, galDevice);
gcmkFOOTER_NO();
return ret;
}
gpu_probe_fail:
gcmkFOOTER_ARG(KERN_INFO "Failed to register gpu driver: %d\n", ret);
return ret;
}
static int __devexit gpu_remove(struct platform_device *pdev)
#endif
{
gcmkHEADER();
drv_exit();
gcmkFOOTER_NO();
return 0;
}
gceSTATUS
gckIOMMU_Construct(
IN gckOS Os,
OUT gckIOMMU * Iommu
)
{
gceSTATUS status;
gckIOMMU iommu = gcvNULL;
struct device *dev;
int ret;
gcmkHEADER();
dev = &Os->device->platform->device->dev;
gcmkONERROR(gckOS_Allocate(Os, gcmSIZEOF(gcsIOMMU), (gctPOINTER *)&iommu));
gckOS_ZeroMemory(iommu, gcmSIZEOF(gcsIOMMU));
iommu->domain = iommu_domain_alloc(&platform_bus_type);
if (!iommu->domain)
{
gcmkTRACE_ZONE(gcvLEVEL_INFO, gcvZONE_OS, "iommu_domain_alloc() fail");
gcmkONERROR(gcvSTATUS_NOT_SUPPORTED);
}
iommu_set_fault_handler(iommu->domain, _IOMMU_Fault_Handler, dev);
ret = iommu_attach_device(iommu->domain, dev);
if (ret)
{
gcmkTRACE_ZONE(
gcvLEVEL_INFO, gcvZONE_OS, "iommu_attach_device() fail %d", ret);
gcmkONERROR(gcvSTATUS_NOT_SUPPORTED);
}
iommu->device = dev;
_FlatMapping(iommu);
*Iommu = iommu;
gcmkFOOTER_NO();
return gcvSTATUS_OK;
OnError:
gckIOMMU_Destory(Os, iommu);
gcmkFOOTER();
return status;
}
static int __devinit gpu_remove(struct platform_device *pdev)
{
gcmkHEADER();
drv_exit();
#ifdef CONFIG_G2D
clk_put(g2d_core_clk);
clk_put(g2d_axi_clkhb);
clk_put(g2d_cfg_clk);
#endif
gcmkFOOTER_NO();
return 0;
}
gceSTATUS
gckIOMMU_Unmap(
IN gckIOMMU Iommu,
IN gctUINT32 DomainAddress,
IN gctUINT32 Bytes
)
{
gcmkHEADER();
iommu_unmap(Iommu->domain, DomainAddress, Bytes);
gcmkFOOTER_NO();
return gcvSTATUS_OK;
}
static int __devexit gpu_remove(struct platform_device *pdev)
#endif
{
gcmkHEADER();
drv_exit();
if (platform.ops->putPower)
{
platform.ops->putPower(&platform);
}
gcmkFOOTER_NO();
return 0;
}
static void drv_exit(void)
#endif
{
gcmkHEADER();
#ifdef CONFIG_GPU_LOW_MEMORY_KILLER
task_free_unregister(&task_nb);
#endif
#ifdef CONFIG_ANDROID_RESERVED_MEMORY_ACCOUNT
unregister_reserved_memory_account(&viv_gpu_resmem_handler);
#endif
gcmkASSERT(gpuClass != gcvNULL);
device_destroy(gpuClass, MKDEV(major, 0));
class_destroy(gpuClass);
unregister_chrdev(major, DRV_NAME);
gcmkVERIFY_OK(gckGALDEVICE_Stop(galDevice));
gcmkVERIFY_OK(gckGALDEVICE_Destroy(galDevice));
if(gckDebugFileSystemIsEnabled())
{
gckDebugFileSystemTerminate();
}
#if ENABLE_GPU_CLOCK_BY_DRIVER && LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,28)
{
# if 0
struct clk * clk = NULL;
#if defined(CONFIG_PXA_DVFM) && (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,29))
gc_pwr(0);
#endif
clk = clk_get(NULL, "GCCLK");
clk_disable(clk);
# endif
}
#endif
gcmkFOOTER_NO();
}
static int __devexit gpu_remove(struct platform_device *pdev)
#endif
{
#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,10,0)
gckGALDEVICE device = platform_get_drvdata(pdev);
struct contiguous_mem_pool *pool = device->pool;
#endif
gcmkHEADER();
#if gcdENABLE_FSCALE_VAL_ADJUST
if(galDevice->kernels[gcvCORE_MAJOR])
UNREG_THERMAL_NOTIFIER(&thermal_hot_pm_notifier);
#endif
drv_exit();
#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,10,0)
dma_free_attrs(&pdev->dev, pool->size, pool->virt, pool->phys,
&pool->attrs);
#endif
gcmkFOOTER_NO();
return 0;
}
static void drv_exit(void)
#endif
{
gcmkHEADER();
gcmkASSERT(gpuClass != gcvNULL);
device_destroy(gpuClass, MKDEV(major, 0));
class_destroy(gpuClass);
unregister_chrdev(major, DEVICE_NAME);
gcmkVERIFY_OK(gckGALDEVICE_Stop(galDevice));
gcmkVERIFY_OK(gckGALDEVICE_Destroy(galDevice));
if(gckDEBUGFS_IsEnabled())
{
gckDEBUGFS_Terminate();
}
gcmkFOOTER_NO();
}
gceSTATUS
gckKERNEL_SecurityStartCommand(
IN gckKERNEL Kernel
)
{
gceSTATUS status;
gcsTA_INTERFACE iface;
gcmkHEADER();
iface.command = KERNEL_START_COMMAND;
iface.u.StartCommand.gpu = Kernel->core;
gcmkONERROR(gckKERNEL_SecurityCallService(Kernel->securityChannel, &iface));
gcmkFOOTER_NO();
return gcvSTATUS_OK;
OnError:
gcmkFOOTER();
return status;
}
/*
** Security service interface.
*/
gceSTATUS
gckKERNEL_SecurityCallService(
IN gctUINT32 Channel,
IN OUT gcsTA_INTERFACE * Interface
)
{
gceSTATUS status;
gcmkHEADER();
gcmkVERIFY_ARGUMENT(Interface != gcvNULL);
gckOS_CallSecurityService(Channel, Interface);
status = Interface->result;
gcmkONERROR(status);
gcmkFOOTER_NO();
return gcvSTATUS_OK;
OnError:
gcmkFOOTER();
return status;
}
gceSTATUS
gckKERNEL_SecurityExecute(
IN gckKERNEL Kernel,
IN gctPOINTER Buffer,
IN gctUINT32 Bytes
)
{
gceSTATUS status;
gcsTA_INTERFACE iface;
gcmkHEADER();
iface.command = KERNEL_EXECUTE;
iface.u.Execute.command_buffer = (gctUINT32 *)Buffer;
iface.u.Execute.gpu = Kernel->core;
iface.u.Execute.command_buffer_length = Bytes;
#if defined(LINUX)
gcmkONERROR(gckOS_GetPhysicalAddress(Kernel->os, Buffer,
(gctUINT32 *)&iface.u.Execute.command_buffer));
#endif
gcmkONERROR(gckKERNEL_SecurityCallService(Kernel->securityChannel, &iface));
/* Update queue tail pointer. */
gcmkONERROR(gckHARDWARE_UpdateQueueTail(
Kernel->hardware, 0, 0
));
gcmkFOOTER_NO();
return gcvSTATUS_OK;
OnError:
gcmkFOOTER();
return status;
}
static int drv_init(void)
#endif
{
int ret;
int result = -EINVAL;
gceSTATUS status;
gckGALDEVICE device = gcvNULL;
struct class* device_class = gcvNULL;
gcsDEVICE_CONSTRUCT_ARGS args = {
.recovery = recovery,
.stuckDump = stuckDump,
};
gcmkHEADER();
#if ENABLE_GPU_CLOCK_BY_DRIVER && (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,28))
{
struct clk * clk;
clk = clk_get(NULL, "GCCLK");
if (IS_ERR(clk))
{
gcmkTRACE_ZONE(
gcvLEVEL_ERROR, gcvZONE_DRIVER,
"%s(%d): clk get error: %d\n",
__FUNCTION__, __LINE__,
PTR_ERR(clk)
);
result = -ENODEV;
gcmkONERROR(gcvSTATUS_GENERIC_IO);
}
/*
* APMU_GC_156M, APMU_GC_312M, APMU_GC_PLL2, APMU_GC_PLL2_DIV2 currently.
* Use the 2X clock.
*/
if (clk_set_rate(clk, coreClock * 2))
{
gcmkTRACE_ZONE(
gcvLEVEL_ERROR, gcvZONE_DRIVER,
"%s(%d): Failed to set core clock.\n",
__FUNCTION__, __LINE__
);
result = -EAGAIN;
gcmkONERROR(gcvSTATUS_GENERIC_IO);
}
clk_enable(clk);
#if defined(CONFIG_PXA_DVFM) && (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,29))
gc_pwr(1);
# endif
}
#endif
printk(KERN_INFO "Galcore version %d.%d.%d.%d\n",
gcvVERSION_MAJOR, gcvVERSION_MINOR, gcvVERSION_PATCH, gcvVERSION_BUILD);
/* when enable gpu profiler, we need to turn off gpu powerMangement */
if(gpuProfiler)
powerManagement = 0;
if (showArgs)
{
gckOS_DumpParam();
}
if(logFileSize != 0)
{
gckDEBUGFS_Initialize();
}
/* Create the GAL device. */
status = gckGALDEVICE_Construct(
#if gcdMULTI_GPU || gcdMULTI_GPU_AFFINITY
irqLine3D0,
registerMemBase3D0, registerMemSize3D0,
irqLine3D1,
registerMemBase3D1, registerMemSize3D1,
#else
irqLine,
registerMemBase, registerMemSize,
#endif
irqLine2D,
registerMemBase2D, registerMemSize2D,
irqLineVG,
registerMemBaseVG, registerMemSizeVG,
contiguousBase, contiguousSize,
bankSize, fastClear, compression, baseAddress, physSize, signal,
logFileSize,
powerManagement,
gpuProfiler,
&args,
&device
);
if (gcmIS_ERROR(status))
{
gcmkTRACE_ZONE(gcvLEVEL_ERROR, gcvZONE_DRIVER,
"%s(%d): Failed to create the GAL device: status=%d\n",
__FUNCTION__, __LINE__, status);
goto OnError;
}
/* Start the GAL device. */
gcmkONERROR(gckGALDEVICE_Start(device));
if ((physSize != 0)
&& (device->kernels[gcvCORE_MAJOR] != gcvNULL)
&& (device->kernels[gcvCORE_MAJOR]->hardware->mmuVersion != 0))
{
#if !gcdSECURITY
status = gckMMU_Enable(device->kernels[gcvCORE_MAJOR]->mmu, baseAddress, physSize);
gcmkTRACE_ZONE(gcvLEVEL_INFO, gcvZONE_DRIVER,
"Enable new MMU: status=%d\n", status);
#if gcdMULTI_GPU_AFFINITY
status = gckMMU_Enable(device->kernels[gcvCORE_OCL]->mmu, baseAddress, physSize);
gcmkTRACE_ZONE(gcvLEVEL_INFO, gcvZONE_DRIVER,
"Enable new MMU: status=%d\n", status);
#endif
if ((device->kernels[gcvCORE_2D] != gcvNULL)
&& (device->kernels[gcvCORE_2D]->hardware->mmuVersion != 0))
{
status = gckMMU_Enable(device->kernels[gcvCORE_2D]->mmu, baseAddress, physSize);
gcmkTRACE_ZONE(gcvLEVEL_INFO, gcvZONE_DRIVER,
"Enable new MMU for 2D: status=%d\n", status);
}
#endif
/* Reset the base address */
device->baseAddress = 0;
}
/* Register the character device. */
ret = register_chrdev(major, DEVICE_NAME, &driver_fops);
if (ret < 0)
{
gcmkTRACE_ZONE(
gcvLEVEL_ERROR, gcvZONE_DRIVER,
"%s(%d): Could not allocate major number for mmap.\n",
__FUNCTION__, __LINE__
);
gcmkONERROR(gcvSTATUS_OUT_OF_MEMORY);
}
if (major == 0)
{
major = ret;
}
/* Create the device class. */
/*####modified for marvell-bg2*/
device_class = class_create(THIS_MODULE, "graphics_3d_class");
/*####end for marvell-bg2*/
if (IS_ERR(device_class))
{
gcmkTRACE_ZONE(
gcvLEVEL_ERROR, gcvZONE_DRIVER,
"%s(%d): Failed to create the class.\n",
__FUNCTION__, __LINE__
);
gcmkONERROR(gcvSTATUS_OUT_OF_RESOURCES);
}
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)
device_create(device_class, NULL, MKDEV(major, 0), NULL, DEVICE_NAME);
#else
device_create(device_class, NULL, MKDEV(major, 0), DEVICE_NAME);
#endif
galDevice = device;
gpuClass = device_class;
#if gcdMULTI_GPU || gcdMULTI_GPU_AFFINITY
gcmkTRACE_ZONE(
gcvLEVEL_INFO, gcvZONE_DRIVER,
"%s(%d): irqLine3D0=%d, contiguousSize=%lu, memBase3D0=0x%lX\n",
__FUNCTION__, __LINE__,
irqLine3D0, contiguousSize, registerMemBase3D0
);
#else
gcmkTRACE_ZONE(
gcvLEVEL_INFO, gcvZONE_DRIVER,
"%s(%d): irqLine=%d, contiguousSize=%lu, memBase=0x%lX\n",
__FUNCTION__, __LINE__,
irqLine, contiguousSize, registerMemBase
);
#endif
/* Success. */
gcmkFOOTER_NO();
return 0;
OnError:
/* Roll back. */
if (device_class != gcvNULL)
{
device_destroy(device_class, MKDEV(major, 0));
class_destroy(device_class);
}
if (device != gcvNULL)
{
gcmkVERIFY_OK(gckGALDEVICE_Stop(device));
gcmkVERIFY_OK(gckGALDEVICE_Destroy(device));
}
gcmkFOOTER();
return result;
}
static int __devinit gpu_probe(struct platform_device *pdev)
{
int ret = -ENODEV;
struct resource* res;
gcmkHEADER();
res = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "gpu_irq");
if (!res)
{
printk(KERN_ERR "%s: No irq line supplied.\n",__FUNCTION__);
goto gpu_probe_fail;
}
irqLine = res->start;
res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "gpu_base");
if (!res)
{
printk(KERN_ERR "%s: No register base supplied.\n",__FUNCTION__);
goto gpu_probe_fail;
}
registerMemBase = res->start;
registerMemSize = res->end - res->start + 1;
#if MRVL_USE_GPU_RESERVE_MEM
gcmkPRINT(KERN_INFO "[galcore] info: GC use memblock to reserve video memory.\n");
res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "gpu_mem");
if (!res)
{
printk(KERN_ERR "%s: No gpu reserved memory supplied. res = %p\n",__FUNCTION__, res);
goto gpu_probe_fail;
}
contiguousBase = res->start;
contiguousSize = res->end - res->start + 1;
#endif
printk("\n[galcore] GC Version: %s\n", _GC_VERSION_STRING_);
printk("\ncontiguousBase:%08x, contiguousSize:%08x\n", (gctUINT32)contiguousBase, (gctUINT32)contiguousSize);
pdevice = &pdev->dev;
ret = drv_init();
if (!ret)
{
platform_set_drvdata(pdev, galDevice);
#if MRVL_CONFIG_PROC
create_gc_proc_file();
#endif
create_gc_sysfs_file(pdev);
#if MRVL_CONFIG_ENABLE_GPUFREQ
__enable_gpufreq(galDevice);
#endif
#if MRVL_CONFIG_ENABLE_EARLYSUSPEND
register_early_suspend(&gpu_early_suspend_handler);
#endif
#if (MRVL_VIDEO_MEMORY_USE_TYPE == gcdMEM_TYPE_ION)
#if (gcdMEM_TYPE_IONAF_3_4_39 == 1)
gc_ion_client = ion_client_create(pxa_ion_dev, "gc ion");
#else
gc_ion_client = ion_client_create(pxa_ion_dev, ION_HEAP_CARVEOUT_MASK, "gc ion");
#endif
#endif
#if MRVL_CONFIG_USE_PM_RUNTIME
pm_runtime_enable(&pdev->dev);
pm_runtime_forbid(&pdev->dev);
#endif
/* save device pointer to GALDEVICE */
galDevice->dev = &pdev->dev;
gcmkFOOTER_NO();
return ret;
}
gpu_probe_fail:
gcmkFOOTER_ARG(KERN_INFO "Failed to register gpu driver: %d\n", ret);
return ret;
}
static int drv_init(void)
#endif
{
int ret, i;
int result = -EINVAL;
gceSTATUS status = gcvSTATUS_OK;
gckGALDEVICE device = gcvNULL;
struct class* device_class = gcvNULL;
gcmkHEADER();
#if ENABLE_GPU_CLOCK_BY_DRIVER && (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,28))
gcmkONERROR(gckOS_GpuPowerEnable(gcvNULL, gcvCORE_MAJOR, gcvTRUE, gcvTRUE, coreClock*1000*1000));
#if MRVL_PLATFORM_PXA1088
/* PXA1088: 2D power is shared with 3D */
gcmkONERROR(gckOS_GpuPowerEnable(gcvNULL, gcvCORE_2D, gcvTRUE, gcvFALSE, coreClock*1000*1000));
#endif
#endif
#if MRVL_PLATFORM_NEVO
if (cpu_is_pxa978_Dx())
{
baseAddress = 0x0;
}
else
{
baseAddress = 0x80000000;
}
#endif
if (showArgs)
{
printk("galcore options:\n");
printk(" irqLine = %d\n", irqLine);
printk(" registerMemBase = 0x%08lX\n", registerMemBase);
printk(" registerMemSize = 0x%08lX\n", registerMemSize);
if (irqLine2D != -1)
{
printk(" irqLine2D = %d\n", irqLine2D);
printk(" registerMemBase2D = 0x%08lX\n", registerMemBase2D);
printk(" registerMemSize2D = 0x%08lX\n", registerMemSize2D);
}
if (irqLineVG != -1)
{
printk(" irqLineVG = %d\n", irqLineVG);
printk(" registerMemBaseVG = 0x%08lX\n", registerMemBaseVG);
printk(" registerMemSizeVG = 0x%08lX\n", registerMemSizeVG);
}
printk(" contiguousSize = %ld\n", contiguousSize);
printk(" contiguousBase = 0x%08lX\n", contiguousBase);
printk(" bankSize = 0x%08lX\n", bankSize);
#if (MRVL_VIDEO_MEMORY_USE_TYPE != gcdMEM_TYPE_NONE)
printk(" pmemSize = %ld\n", pmemSize);
#endif
printk(" fastClear = %d\n", fastClear);
printk(" compression = %d\n", compression);
printk(" signal = %d\n", signal);
printk(" baseAddress = 0x%08lX\n", baseAddress);
printk(" physSize = 0x%08lX\n", physSize);
printk(" logFileSize = %d KB \n", logFileSize);
#if ENABLE_GPU_CLOCK_BY_DRIVER
printk(" coreClock = %lu\n", coreClock);
#endif
}
physSize = 0x80000000;
#ifndef CONFIG_CPU_PXA988
pmemSize = 0x0;
#endif
printk(" physSize modified to = 0x%08lX\n", physSize);
if(logFileSize != 0)
{
gckDebugFileSystemInitialize();
}
/* Create the GAL device. */
gcmkONERROR(gckGALDEVICE_Construct(
irqLine,
registerMemBase, registerMemSize,
irqLine2D,
registerMemBase2D, registerMemSize2D,
irqLineVG,
registerMemBaseVG, registerMemSizeVG,
contiguousBase, contiguousSize,
#if (MRVL_VIDEO_MEMORY_USE_TYPE != gcdMEM_TYPE_NONE)
pmemSize,
#endif
bankSize, fastClear, compression, baseAddress, physSize, signal,
logFileSize,
&device
));
/* Start the GAL device. */
gcmkONERROR(gckGALDEVICE_Start(device));
if ((physSize != 0)
&& (device->kernels[gcvCORE_MAJOR] != gcvNULL)
&& (device->kernels[gcvCORE_MAJOR]->hardware->mmuVersion != 0))
{
status = gckMMU_Enable(device->kernels[gcvCORE_MAJOR]->mmu, mmuBaseAddress, physSize);
//status = gckMMU_Enable(device->kernels[gcvCORE_MAJOR]->mmu, (gctUINT32)device->contiguousStart, contiguousSize);
gcmkTRACE_ZONE(gcvLEVEL_INFO, gcvZONE_DRIVER,
"Enable new MMU: status=%d\n", status);
if ((device->kernels[gcvCORE_2D] != gcvNULL)
&& (device->kernels[gcvCORE_2D]->hardware->mmuVersion != 0))
{
status = gckMMU_Enable(device->kernels[gcvCORE_2D]->mmu, mmuBaseAddress, physSize);
gcmkTRACE_ZONE(gcvLEVEL_INFO, gcvZONE_DRIVER,
"Enable new MMU for 2D: status=%d\n", status);
}
/* Reset the base address */
device->baseAddress = 0;
}
for (i = 0; i < gcdMAX_GPU_COUNT; i++)
{
if(device->kernels[i] != gcvNULL)
{
device->kernels[i]->bTryIdleGPUEnable = gcvTRUE;
}
}
/* Register the character device. */
ret = register_chrdev(major, DRV_NAME, &driver_fops);
if (ret < 0)
{
gcmkTRACE_ZONE(
gcvLEVEL_ERROR, gcvZONE_DRIVER,
"%s(%d): Could not allocate major number for mmap.\n",
__FUNCTION__, __LINE__
);
gcmkONERROR(gcvSTATUS_OUT_OF_MEMORY);
}
if (major == 0)
{
major = ret;
}
/* Create the device class. */
device_class = class_create(THIS_MODULE, "graphics_class");
if (IS_ERR(device_class))
{
gcmkTRACE_ZONE(
gcvLEVEL_ERROR, gcvZONE_DRIVER,
"%s(%d): Failed to create the class.\n",
__FUNCTION__, __LINE__
);
gcmkONERROR(gcvSTATUS_OUT_OF_RESOURCES);
}
if (pdevice == gcvNULL)
gcmkONERROR(gcvSTATUS_DEVICE);
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)
device_create(device_class, pdevice, MKDEV(major, 0), NULL, "galcore");
#else
device_create(device_class, pdevice, MKDEV(major, 0), "galcore");
#endif
galDevice = device;
gpuClass = device_class;
gcmkTRACE_ZONE(
gcvLEVEL_INFO, gcvZONE_DRIVER,
"%s(%d): irqLine=%d, contiguousSize=%lu, memBase=0x%lX\n",
__FUNCTION__, __LINE__,
irqLine, contiguousSize, registerMemBase
);
/* Success. */
gcmkFOOTER_NO();
return 0;
OnError:
/* Roll back. */
if (device_class != gcvNULL)
{
device_destroy(device_class, MKDEV(major, 0));
class_destroy(device_class);
}
if (device != gcvNULL)
{
gcmkVERIFY_OK(gckGALDEVICE_Stop(device));
gcmkVERIFY_OK(gckGALDEVICE_Destroy(device));
}
gcmkFOOTER();
return result;
}
static int drv_init(void)
#endif
{
int ret;
int result = -EINVAL;
gceSTATUS status;
gckGALDEVICE device = gcvNULL;
struct class* device_class = gcvNULL;
gcsDEVICE_CONSTRUCT_ARGS args = {
.recovery = recovery,
.stuckDump = stuckDump,
.gpu3DMinClock = gpu3DMinClock,
.contiguousRequested = contiguousRequested,
.platform = &platform,
.mmu = mmu,
};
gcmkHEADER();
printk(KERN_INFO "Galcore version %d.%d.%d.%d\n",
gcvVERSION_MAJOR, gcvVERSION_MINOR, gcvVERSION_PATCH, gcvVERSION_BUILD);
#if !VIVANTE_PROFILER_PM
/* when enable gpu profiler, we need to turn off gpu powerMangement */
if (gpuProfiler)
{
powerManagement = 0;
}
#endif
if (showArgs)
{
gckOS_DumpParam();
}
if (logFileSize != 0)
{
gckDEBUGFS_Initialize();
}
/* Create the GAL device. */
status = gckGALDEVICE_Construct(
#if gcdMULTI_GPU || gcdMULTI_GPU_AFFINITY
irqLine3D0,
registerMemBase3D0, registerMemSize3D0,
irqLine3D1,
registerMemBase3D1, registerMemSize3D1,
#else
irqLine,
registerMemBase, registerMemSize,
#endif
irqLine2D,
registerMemBase2D, registerMemSize2D,
irqLineVG,
registerMemBaseVG, registerMemSizeVG,
contiguousBase, contiguousSize,
bankSize, fastClear, compression, baseAddress, physSize, signal,
logFileSize,
powerManagement,
gpuProfiler,
&args,
&device
);
if (gcmIS_ERROR(status))
{
gcmkTRACE_ZONE(gcvLEVEL_ERROR, gcvZONE_DRIVER,
"%s(%d): Failed to create the GAL device: status=%d\n",
__FUNCTION__, __LINE__, status);
goto OnError;
}
/* Start the GAL device. */
gcmkONERROR(gckGALDEVICE_Start(device));
if ((physSize != 0)
&& (device->kernels[gcvCORE_MAJOR] != gcvNULL)
&& (device->kernels[gcvCORE_MAJOR]->hardware->mmuVersion != 0))
{
/* Reset the base address */
device->baseAddress = 0;
}
/* Register the character device. */
ret = register_chrdev(major, DEVICE_NAME, &driver_fops);
if (ret < 0)
{
gcmkTRACE_ZONE(
gcvLEVEL_ERROR, gcvZONE_DRIVER,
"%s(%d): Could not allocate major number for mmap.\n",
__FUNCTION__, __LINE__
);
gcmkONERROR(gcvSTATUS_OUT_OF_MEMORY);
}
if (major == 0)
{
major = ret;
}
/* Create the device class. */
device_class = class_create(THIS_MODULE, "graphics_class");
if (IS_ERR(device_class))
{
gcmkTRACE_ZONE(
gcvLEVEL_ERROR, gcvZONE_DRIVER,
"%s(%d): Failed to create the class.\n",
__FUNCTION__, __LINE__
);
gcmkONERROR(gcvSTATUS_OUT_OF_RESOURCES);
}
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)
device_create(device_class, NULL, MKDEV(major, 0), NULL, DEVICE_NAME);
#else
device_create(device_class, NULL, MKDEV(major, 0), DEVICE_NAME);
#endif
galDevice = device;
gpuClass = device_class;
#if gcdMULTI_GPU || gcdMULTI_GPU_AFFINITY
gcmkTRACE_ZONE(
gcvLEVEL_INFO, gcvZONE_DRIVER,
"%s(%d): irqLine3D0=%d, contiguousSize=%lu, memBase3D0=0x%lX\n",
__FUNCTION__, __LINE__,
irqLine3D0, contiguousSize, registerMemBase3D0
);
#else
gcmkTRACE_ZONE(
gcvLEVEL_INFO, gcvZONE_DRIVER,
"%s(%d): irqLine=%d, contiguousSize=%lu, memBase=0x%lX\n",
__FUNCTION__, __LINE__,
irqLine, contiguousSize, registerMemBase
);
#endif
/* Success. */
gcmkFOOTER_NO();
return 0;
OnError:
/* Roll back. */
if (device_class != gcvNULL)
{
device_destroy(device_class, MKDEV(major, 0));
class_destroy(device_class);
}
if (device != gcvNULL)
{
gcmkVERIFY_OK(gckGALDEVICE_Stop(device));
gcmkVERIFY_OK(gckGALDEVICE_Destroy(device));
}
gcmkFOOTER();
return result;
}
int __devinit gpu_probe(struct platform_device *pdev)
{
int ret = -ENODEV;
struct resource* res;
gcmkHEADER();
#ifdef CONFIG_G2D
#ifdef CONFIG_G2D_K3
g2d_core_clk = clk_get(NULL, "clk_g2d");
if (IS_ERR(g2d_core_clk)) {
printk(KERN_ERR "Could not get clk_g2d!\n");
return ret;
}
ret = clk_set_rate(g2d_core_clk, 480000000);
if (ret) {
printk(KERN_ERR "G2D, %s: failed to set G2D clk rete, G2D clk = %p \n", __func__, g2d_core_clk);
return ret;
}
#else
g2d_core_clk = clk_get(NULL, CLK_5G2D_CORE_CLK);
if (IS_ERR(g2d_core_clk)) {
printk(KERN_ERR "Could not get g2d_core_clk!\n");
goto gpu_probe_fail;
}
g2d_axi_clkhb = clk_get(NULL, CLK_4G2D_AXI_CLKHB);
if (IS_ERR(g2d_axi_clkhb)) {
printk(KERN_ERR "Could not get g2d_axi_clkhb!\n");
goto gpu_probe_fail;
}
g2d_cfg_clk = clk_get(NULL, CLK_3G2D_CFG_CLK);
if (IS_ERR(g2d_cfg_clk)) {
printk(KERN_ERR "Could not get g2d_cfg_clk!\n");
goto gpu_probe_fail;
}
if (clk_set_rate(g2d_core_clk, G2D_CLK_RATE)) {
printk(KERN_ERR "G2D, %s: failed to set G2D clk rete, G2D clk = %p \n", __func__, g2d_core_clk);
goto gpu_probe_fail;
}
#endif
res = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "g2d_irq");
if (!res)
{
printk(KERN_ERR "%s: No irq line supplied.\n",__FUNCTION__);
goto gpu_probe_fail;
}
irqLine = res->start;
res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "g2d_base");
if (!res)
{
printk(KERN_ERR "%s: No register base supplied.\n",__FUNCTION__);
goto gpu_probe_fail;
}
registerMemBase = res->start;
registerMemSize = res->end - res->start + 1;
#endif
/*
res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "gpu_mem");
if (!res)
{
printk(KERN_ERR "%s: No memory base supplied.\n",__FUNCTION__);
goto gpu_probe_fail;
}
contiguousBase = res->start;
contiguousSize = res->end - res->start + 1;
*/
ret = drv_init();
if (!ret)
{
platform_set_drvdata(pdev, galDevice);
gcmkFOOTER_NO();
return ret;
}
gpu_probe_fail:
gcmkFOOTER_ARG(KERN_INFO "Failed to register gpu driver: %d\n", ret);
return ret;
}
static int __devinit gpu_probe(struct platform_device *pdev)
#endif
{
int ret = -ENODEV;
gcsMODULE_PARAMETERS moduleParam = {
#if gcdMULTI_GPU || gcdMULTI_GPU_AFFINITY
#else
.irqLine = irqLine,
.registerMemBase = registerMemBase,
.registerMemSize = registerMemSize,
#endif
.irqLine2D = irqLine2D,
.registerMemBase2D = registerMemBase2D,
.registerMemSize2D = registerMemSize2D,
.irqLineVG = irqLineVG,
.registerMemBaseVG = registerMemBaseVG,
.registerMemSizeVG = registerMemSizeVG,
.contiguousSize = contiguousSize,
.contiguousBase = contiguousBase,
.bankSize = bankSize,
.fastClear = fastClear,
.compression = compression,
.powerManagement = powerManagement,
.gpuProfiler = gpuProfiler,
.signal = signal,
.baseAddress = baseAddress,
.physSize = physSize,
.logFileSize = logFileSize,
.recovery = recovery,
.stuckDump = stuckDump,
.showArgs = showArgs,
.gpu3DMinClock = gpu3DMinClock,
};
gcmkHEADER();
platform.device = pdev;
if (platform.ops->getPower)
{
if (gcmIS_ERROR(platform.ops->getPower(&platform)))
{
gcmkFOOTER_NO();
return ret;
}
}
if (platform.ops->adjustParam)
{
/* Override default module param. */
platform.ops->adjustParam(&platform, &moduleParam);
/* Update module param because drv_init() uses them directly. */
_UpdateModuleParam(&moduleParam);
}
ret = drv_init();
if (!ret)
{
platform_set_drvdata(pdev, galDevice);
gcmkFOOTER_NO();
return ret;
}
gcmkFOOTER_ARG(KERN_INFO "Failed to register gpu driver: %d\n", ret);
return ret;
}
static int drv_init(struct device *pdev)
#endif
{
int ret;
int result = -EINVAL;
gceSTATUS status;
gckGALDEVICE device = gcvNULL;
struct class* device_class = gcvNULL;
gcmkHEADER();
#if ENABLE_GPU_CLOCK_BY_DRIVER && (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,28))
{
# if 0
struct clk * clk;
clk = clk_get(NULL, "GCCLK");
if (IS_ERR(clk))
{
gcmkTRACE_ZONE(
gcvLEVEL_ERROR, gcvZONE_DRIVER,
"%s(%d): clk get error: %d\n",
__FUNCTION__, __LINE__,
PTR_ERR(clk)
);
result = -ENODEV;
gcmkONERROR(gcvSTATUS_GENERIC_IO);
}
/*
* APMU_GC_156M, APMU_GC_312M, APMU_GC_PLL2, APMU_GC_PLL2_DIV2 currently.
* Use the 2X clock.
*/
if (clk_set_rate(clk, coreClock * 2))
{
gcmkTRACE_ZONE(
gcvLEVEL_ERROR, gcvZONE_DRIVER,
"%s(%d): Failed to set core clock.\n",
__FUNCTION__, __LINE__
);
result = -EAGAIN;
gcmkONERROR(gcvSTATUS_GENERIC_IO);
}
clk_enable(clk);
#if defined(CONFIG_PXA_DVFM) && (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,29))
gc_pwr(1);
# endif
# endif
}
#endif
printk(KERN_INFO "Galcore version %d.%d.%d.%d\n",
gcvVERSION_MAJOR, gcvVERSION_MINOR, gcvVERSION_PATCH, gcvVERSION_BUILD);
/* when enable gpu profiler, we need to turn off gpu powerMangement */
if(gpuProfiler)
powerManagement = 0;
if (showArgs)
{
printk("galcore options:\n");
printk(" irqLine = %d\n", irqLine);
printk(" registerMemBase = 0x%08lX\n", registerMemBase);
printk(" registerMemSize = 0x%08lX\n", registerMemSize);
if (irqLine2D != -1)
{
printk(" irqLine2D = %d\n", irqLine2D);
printk(" registerMemBase2D = 0x%08lX\n", registerMemBase2D);
printk(" registerMemSize2D = 0x%08lX\n", registerMemSize2D);
}
if (irqLineVG != -1)
{
printk(" irqLineVG = %d\n", irqLineVG);
printk(" registerMemBaseVG = 0x%08lX\n", registerMemBaseVG);
printk(" registerMemSizeVG = 0x%08lX\n", registerMemSizeVG);
}
printk(" contiguousSize = %ld\n", contiguousSize);
printk(" contiguousBase = 0x%08lX\n", contiguousBase);
printk(" bankSize = 0x%08lX\n", bankSize);
printk(" fastClear = %d\n", fastClear);
printk(" compression = %d\n", compression);
printk(" signal = %d\n", signal);
printk(" baseAddress = 0x%08lX\n", baseAddress);
printk(" physSize = 0x%08lX\n", physSize);
printk(" logFileSize = %d KB \n", logFileSize);
printk(" powerManagement = %d\n", powerManagement);
printk(" gpuProfiler = %d\n", gpuProfiler);
#if ENABLE_GPU_CLOCK_BY_DRIVER
printk(" coreClock = %lu\n", coreClock);
#endif
}
if(logFileSize != 0)
{
gckDebugFileSystemInitialize();
}
/* Create the GAL device. */
gcmkONERROR(gckGALDEVICE_Construct(
irqLine,
registerMemBase, registerMemSize,
irqLine2D,
registerMemBase2D, registerMemSize2D,
irqLineVG,
registerMemBaseVG, registerMemSizeVG,
contiguousBase, contiguousSize,
bankSize, fastClear, compression, baseAddress, physSize, signal,
logFileSize,
pdev,
powerManagement,
gpuProfiler,
&device
));
#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,10,0)
device->pool = dev_get_drvdata(pdev);
#endif
/* Start the GAL device. */
gcmkONERROR(gckGALDEVICE_Start(device));
if ((physSize != 0)
&& (device->kernels[gcvCORE_MAJOR] != gcvNULL)
&& (device->kernels[gcvCORE_MAJOR]->hardware->mmuVersion != 0))
{
status = gckMMU_Enable(device->kernels[gcvCORE_MAJOR]->mmu, baseAddress, physSize);
gcmkTRACE_ZONE(gcvLEVEL_INFO, gcvZONE_DRIVER,
"Enable new MMU: status=%d\n", status);
if ((device->kernels[gcvCORE_2D] != gcvNULL)
&& (device->kernels[gcvCORE_2D]->hardware->mmuVersion != 0))
{
status = gckMMU_Enable(device->kernels[gcvCORE_2D]->mmu, baseAddress, physSize);
gcmkTRACE_ZONE(gcvLEVEL_INFO, gcvZONE_DRIVER,
"Enable new MMU for 2D: status=%d\n", status);
}
/* Reset the base address */
device->baseAddress = 0;
}
#ifdef CONFIG_ANDROID_RESERVED_MEMORY_ACCOUNT
task_free_register(&task_nb);
viv_gpu_resmem_handler.data = device->kernels[gcvCORE_MAJOR];
register_reserved_memory_account(&viv_gpu_resmem_handler);
#endif
/* Register the character device. */
ret = register_chrdev(major, DRV_NAME, &driver_fops);
if (ret < 0)
{
gcmkTRACE_ZONE(
gcvLEVEL_ERROR, gcvZONE_DRIVER,
"%s(%d): Could not allocate major number for mmap.\n",
__FUNCTION__, __LINE__
);
gcmkONERROR(gcvSTATUS_OUT_OF_MEMORY);
}
if (major == 0)
{
major = ret;
}
/* Create the device class. */
device_class = class_create(THIS_MODULE, "graphics_class");
if (IS_ERR(device_class))
{
gcmkTRACE_ZONE(
gcvLEVEL_ERROR, gcvZONE_DRIVER,
"%s(%d): Failed to create the class.\n",
__FUNCTION__, __LINE__
);
gcmkONERROR(gcvSTATUS_OUT_OF_RESOURCES);
}
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)
device_create(device_class, NULL, MKDEV(major, 0), NULL, "galcore");
#else
device_create(device_class, NULL, MKDEV(major, 0), "galcore");
#endif
galDevice = device;
gpuClass = device_class;
gcmkTRACE_ZONE(
gcvLEVEL_INFO, gcvZONE_DRIVER,
"%s(%d): irqLine=%d, contiguousSize=%lu, memBase=0x%lX\n",
__FUNCTION__, __LINE__,
irqLine, contiguousSize, registerMemBase
);
/* Success. */
gcmkFOOTER_NO();
return 0;
OnError:
/* Roll back. */
if (device_class != gcvNULL)
{
device_destroy(device_class, MKDEV(major, 0));
class_destroy(device_class);
}
if (device != gcvNULL)
{
gcmkVERIFY_OK(gckGALDEVICE_Stop(device));
gcmkVERIFY_OK(gckGALDEVICE_Destroy(device));
}
gcmkFOOTER();
return result;
}
static int __devinit gpu_probe(struct platform_device *pdev)
#endif
{
int ret = -ENODEV;
struct resource* res;
#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,10,0)
struct contiguous_mem_pool *pool;
struct reset_control *rstc;
#elif LINUX_VERSION_CODE >= KERNEL_VERSION(3,5,0)
struct device_node *dn =pdev->dev.of_node;
const u32 *prop;
#else
struct viv_gpu_platform_data *pdata;
#endif
gcmkHEADER();
res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "phys_baseaddr");
if (res)
baseAddress = res->start;
res = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "irq_3d");
if (res)
irqLine = res->start;
res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "iobase_3d");
if (res)
{
registerMemBase = res->start;
registerMemSize = res->end - res->start + 1;
}
res = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "irq_2d");
if (res)
irqLine2D = res->start;
res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "iobase_2d");
if (res)
{
registerMemBase2D = res->start;
registerMemSize2D = res->end - res->start + 1;
}
res = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "irq_vg");
if (res)
irqLineVG = res->start;
res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "iobase_vg");
if (res)
{
registerMemBaseVG = res->start;
registerMemSizeVG = res->end - res->start + 1;
}
#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,10,0)
pool = devm_kzalloc(&pdev->dev, sizeof(*pool), GFP_KERNEL);
if (!pool)
return -ENOMEM;
pool->size = contiguousSize;
init_dma_attrs(&pool->attrs);
dma_set_attr(DMA_ATTR_WRITE_COMBINE, &pool->attrs);
pool->virt = dma_alloc_attrs(&pdev->dev, pool->size, &pool->phys,
GFP_KERNEL, &pool->attrs);
if (!pool->virt) {
dev_err(&pdev->dev, "Failed to allocate contiguous memory\n");
return -ENOMEM;
}
contiguousBase = pool->phys;
dev_set_drvdata(&pdev->dev, pool);
#elif LINUX_VERSION_CODE >= KERNEL_VERSION(3,5,0)
prop = of_get_property(dn, "contiguousbase", NULL);
if(prop)
contiguousBase = *prop;
of_property_read_u32(dn,"contiguoussize", (u32 *)&contiguousSize);
#else
pdata = pdev->dev.platform_data;
if (pdata) {
contiguousBase = pdata->reserved_mem_base;
contiguousSize = pdata->reserved_mem_size;
}
#endif
if (contiguousSize == 0)
gckOS_Print("Warning: No contiguous memory is reserverd for gpu.!\n ");
ret = drv_init(&pdev->dev);
if (!ret)
{
#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,10,0)
rstc = devm_reset_control_get(&pdev->dev, "gpu3d");
galDevice->rstc[gcvCORE_MAJOR] = IS_ERR(rstc) ? NULL : rstc;
rstc = devm_reset_control_get(&pdev->dev, "gpu2d");
galDevice->rstc[gcvCORE_2D] = IS_ERR(rstc) ? NULL : rstc;
rstc = devm_reset_control_get(&pdev->dev, "gpuvg");
galDevice->rstc[gcvCORE_VG] = IS_ERR(rstc) ? NULL : rstc;
#endif
platform_set_drvdata(pdev, galDevice);
#if gcdENABLE_FSCALE_VAL_ADJUST
if (galDevice->kernels[gcvCORE_MAJOR])
REG_THERMAL_NOTIFIER(&thermal_hot_pm_notifier);
#endif
gcmkFOOTER_NO();
return ret;
}
#if gcdENABLE_FSCALE_VAL_ADJUST
UNREG_THERMAL_NOTIFIER(&thermal_hot_pm_notifier);
#endif
#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,10,0)
dma_free_attrs(&pdev->dev, pool->size, pool->virt, pool->phys,
&pool->attrs);
#endif
gcmkFOOTER_ARG(KERN_INFO "Failed to register gpu driver: %d\n", ret);
return ret;
}