/* is called from OS specific driver entry point */ _mali_osk_errcode_t mali_kernel_constructor( void ) { _mali_osk_errcode_t err; err = mali_platform_init(); if (_MALI_OSK_ERR_OK != err) goto error1; err = _mali_osk_init(); if (_MALI_OSK_ERR_OK != err) goto error2; MALI_DEBUG_PRINT(2, ("\n")); MALI_DEBUG_PRINT(2, ("Inserting Mali v%d device driver. \n",_MALI_API_VERSION)); MALI_DEBUG_PRINT(2, ("Compiled: %s, time: %s.\n", __DATE__, __TIME__)); MALI_DEBUG_PRINT(2, ("Svn revision: %s\n", SVN_REV_STRING)); err = initialize_subsystems(); if (_MALI_OSK_ERR_OK != err) goto error3; MALI_PRINT(("Mali device driver %s loaded\n", SVN_REV_STRING)); MALI_SUCCESS; error3: MALI_PRINT(("Mali subsystems failed\n")); _mali_osk_term(); error2: MALI_PRINT(("Mali device driver init failed\n")); if (_MALI_OSK_ERR_OK != mali_platform_deinit()) { MALI_PRINT(("Failed to deinit platform\n")); } error1: MALI_PRINT(("Failed to init platform\n")); MALI_ERROR(err); }
int mali_platform_device_register(void) { int err; MALI_DEBUG_PRINT(4, ("mali_platform_device_register() called\n")); /* Connect resources to the device */ err = platform_device_add_resources(&exynos4_device_g3d, mali_gpu_resources, sizeof(mali_gpu_resources) / sizeof(mali_gpu_resources[0])); if (0 == err) { err = platform_device_add_data(&exynos4_device_g3d, &mali_gpu_data, sizeof(mali_gpu_data)); if (0 == err) { mali_platform_init(&(exynos4_device_g3d.dev)); #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37)) pm_runtime_set_autosuspend_delay(&(exynos4_device_g3d.dev), 200); pm_runtime_use_autosuspend(&(exynos4_device_g3d.dev)); #endif pm_runtime_enable(&(exynos4_device_g3d.dev)); return 0; } } return err; }
static int mali_probe(struct platform_device *pdev) { int err; MALI_DEBUG_PRINT(2, ("mali_probe(): Called for platform device %s\n", pdev->name)); if (NULL != mali_platform_device) { /* Already connected to a device, return error */ MALI_PRINT_ERROR(("mali_probe(): The Mali driver is already connected with a Mali device.")); return -EEXIST; } mali_platform_device = pdev; if (mali_platform_init() != _MALI_OSK_ERR_OK) { /* Platform-specific initialization failed, return error */ MALI_PRINT_ERROR(("mali_probe(): mali_platform_init() failed.")); return -EFAULT; } if (_MALI_OSK_ERR_OK == _mali_osk_wq_init()) { /* Initialize the Mali GPU HW specified by pdev */ if (_MALI_OSK_ERR_OK == mali_initialize_subsystems()) { /* Register a misc device (so we are accessible from user space) */ err = mali_miscdevice_register(pdev); if (0 == err) { /* Setup sysfs entries */ err = mali_sysfs_register(mali_dev_name); if (0 == err) { MALI_DEBUG_PRINT(2, ("mali_probe(): Successfully initialized driver for platform device %s\n", pdev->name)); return 0; } else { MALI_PRINT_ERROR(("mali_probe(): failed to register sysfs entries")); } mali_miscdevice_unregister(); } else { MALI_PRINT_ERROR(("mali_probe(): failed to register Mali misc device.")); } mali_terminate_subsystems(); } else { MALI_PRINT_ERROR(("mali_probe(): Failed to initialize Mali device driver.")); } _mali_osk_wq_term(); } mali_platform_device = NULL; return -EFAULT; }
/* *************************************************************** @Function :sunxi_mali_platform_device_register @Description :Register mali platform device @Input :None @Return :0 or error code *************************************************************** */ int sunxi_mali_platform_device_register(void) { int err; unsigned long mem_size = 0; struct __fb_addr_para fb_addr_para={0}; sunxi_get_fb_addr_para(&fb_addr_para); err = platform_device_add_resources(&mali_gpu_device, mali_gpu_resources, sizeof(mali_gpu_resources) / sizeof(mali_gpu_resources[0])); if (0 == err){ mali_gpu_data.fb_start = fb_addr_para.fb_paddr; mali_gpu_data.fb_size = fb_addr_para.fb_size; mem_size = (totalram_pages * PAGE_SIZE )/1024; /* KB */ if(mem_size > 512*1024) { mali_gpu_data.shared_mem_size = 1024*1024*1024; } else { mali_gpu_data.shared_mem_size = 512*1024*1024; } err = platform_device_add_data(&mali_gpu_device, &mali_gpu_data, sizeof(mali_gpu_data)); if(0 == err) { err = platform_device_register(&mali_gpu_device); if (0 == err){ if(_MALI_OSK_ERR_OK != mali_platform_init()) { return _MALI_OSK_ERR_FAULT; } #ifdef CONFIG_PM_RUNTIME #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37)) pm_runtime_set_autosuspend_delay(&(mali_gpu_device.dev), 1000); pm_runtime_use_autosuspend(&(mali_gpu_device.dev)); #endif pm_runtime_enable(&(mali_gpu_device.dev)); #endif /* CONFIG_PM_RUNTIME */ /* print mali gpu information */ printk(KERN_INFO "=========================================================\n"); printk(KERN_INFO " Mali GPU Information \n"); printk(KERN_INFO "voltage : %d mV\n", regulator_get_voltage(mali_regulator)/1000); printk(KERN_INFO "initial frequency : %ld MHz\n", clk_get_rate(h_mali_clk)/(1000*1000)); printk(KERN_INFO "frame buffer address: 0x%lx - 0x%lx\n", mali_gpu_data.fb_start, mali_gpu_data.fb_start + mali_gpu_data.shared_mem_size); printk(KERN_INFO "frame buffer size : %ld MB\n", mali_gpu_data.shared_mem_size/(1024*1024)); printk(KERN_INFO "=========================================================\n"); return 0; } } platform_device_unregister(&mali_gpu_device); } #ifdef CONFIG_CPU_BUDGET_THERMAL register_budget_cooling_notifier(&mali_throttle_notifier); #endif /* CONFIG_CPU_BUDGET_THERMAL */ return err; }
int init_mali(void) { int ret = 0; ret = map_errcode(initialize_kernel_device()); if (0 != ret) goto initialize_kernel_device_failed; ret = map_errcode(mali_platform_init()); if (0 != ret) goto platform_init_failed; mali_osk_low_level_mem_init(); ret = map_errcode(mali_initialize_subsystems()); if (0 != ret) goto initialize_subsystems_failed; ret = initialize_sysfs(); if (0 != ret) goto initialize_sysfs_failed; MALI_PRINT(("Mali device driver loaded\n")); return 0; /* Success */ /* Error handling */ initialize_sysfs_failed: mali_terminate_subsystems(); initialize_subsystems_failed: mali_osk_low_level_mem_term(); mali_platform_deinit(); platform_init_failed: terminate_kernel_device(); initialize_kernel_device_failed: _mali_dev_platform_unregister(); platform_register_failed: return ret; }
int mali_platform_device_register(void) { int err; MALI_DEBUG_PRINT(4, ("mali_platform_device_register() called\n")); /* Connect resources to the device */ err = platform_device_add_resources(&exynos4_device_g3d, mali_gpu_resources, sizeof(mali_gpu_resources) / sizeof(mali_gpu_resources[0])); if (0 == err) { err = platform_device_add_data(&exynos4_device_g3d, &mali_gpu_data, sizeof(mali_gpu_data)); if (0 == err) { mali_platform_init(&(exynos4_device_g3d.dev)); #ifdef CONFIG_PM_RUNTIME pm_runtime_set_autosuspend_delay(&(exynos4_device_g3d.dev), 50); pm_runtime_use_autosuspend(&(exynos4_device_g3d.dev)); pm_runtime_enable(&(exynos4_device_g3d.dev)); #endif return 0; } } return err; }
/***************************************************************************** function name : mali_platform_device_register description : mali platform device register input vars : void output vars : NA return value : void calls : mali_platform_init called : os history : 1.data : 18/10/2012 modify : new *****************************************************************************/ int mali_platform_device_register(void) { int err = -1; MALI_DEBUG_PRINT(4, ("mali_platform_device_register() called\n")); MALI_DEBUG_PRINT(4, ("Registering Mali-450 MP8 device\n")); /* init the mem first of hisi */ mali_hisi_mem_init(); mali_gpu_device.num_resources = ARRAY_SIZE(mali_gpu_resources_m450_mp4); mali_gpu_device.resource = mali_gpu_resources_m450_mp4; /* Register the platform device */ err = platform_device_register(&mali_gpu_device); if (0 == err) { mali_platform_init(); #ifdef CONFIG_PM_RUNTIME #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37)) pm_runtime_set_autosuspend_delay(&(mali_gpu_device.dev), 1000); pm_runtime_use_autosuspend(&(mali_gpu_device.dev)); #endif pm_runtime_enable(&(mali_gpu_device.dev)); #endif return 0; } return err; }
int mali_platform_device_register(void) { int err; MALI_DEBUG_PRINT(4, ("mali_platform_device_register() called\n")); #if LINUX_VERSION_CODE >= KERNEL_VERSION(3,4,0) exynos_pm_add_dev_to_genpd(&mali_gpu_device, &exynos4_pd_g3d); #endif /* Connect resources to the device */ err = platform_device_add_resources(&mali_gpu_device, mali_gpu_resources, sizeof(mali_gpu_resources) / sizeof(mali_gpu_resources[0])); if (0 == err) { err = platform_device_add_data(&mali_gpu_device, &mali_gpu_data, sizeof(mali_gpu_data)); if (0 == err) { #ifdef CONFIG_PM_RUNTIME #if defined(USE_PM_NOTIFIER) err = register_pm_notifier(&mali_pwr_notif_block); if (err) { goto plat_init_err; } #endif #endif /* CONFIG_PM_RUNTIME */ /* Register the platform device */ err = platform_device_register(&mali_gpu_device); if (0 == err) { mali_platform_init(&(mali_gpu_device.dev)); #ifdef CONFIG_PM_RUNTIME #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37)) pm_runtime_set_autosuspend_delay(&(mali_gpu_device.dev), 1000); pm_runtime_use_autosuspend(&(mali_gpu_device.dev)); #endif pm_runtime_enable(&(mali_gpu_device.dev)); #endif return 0; } } #ifdef CONFIG_PM_RUNTIME #if defined(USE_PM_NOTIFIER) plat_init_err: unregister_pm_notifier(&mali_pwr_notif_block); #endif #endif /* CONFIG_PM_RUNTIME */ platform_device_unregister(&mali_gpu_device); } return err; }
int mali_driver_init(void) { int ret = 0; MALI_DEBUG_PRINT(2, ("\n")); MALI_DEBUG_PRINT(2, ("Inserting Mali v%d device driver. \n",_MALI_API_VERSION)); MALI_DEBUG_PRINT(2, ("Compiled: %s, time: %s.\n", __DATE__, __TIME__)); MALI_DEBUG_PRINT(2, ("Driver revision: %s\n", SVN_REV_STRING)); ret = _mali_dev_platform_register(); if (0 != ret) goto platform_register_failed; ret = map_errcode(initialize_kernel_device()); if (0 != ret) goto initialize_kernel_device_failed; ret = map_errcode(mali_platform_init()); if (0 != ret) goto platform_init_failed; mali_osk_low_level_mem_init(); ret = map_errcode(mali_initialize_subsystems()); if (0 != ret) goto initialize_subsystems_failed; #if MALI_INTERNAL_TIMELINE_PROFILING_ENABLED ret = _mali_internal_profiling_init(mali_boot_profiling ? MALI_TRUE : MALI_FALSE); if (0 != ret) { /* No biggie if we wheren't able to initialize the profiling */ MALI_PRINT_ERROR(("Failed to initialize profiling, feature will be unavailable\n")); } #endif ret = initialize_sysfs(); if (0 != ret) goto initialize_sysfs_failed; MALI_PRINT(("Mali device driver loaded\n")); return 0; /* Success */ /* Error handling */ initialize_sysfs_failed: #if MALI_INTERNAL_TIMELINE_PROFILING_ENABLED _mali_internal_profiling_term(); #endif mali_terminate_subsystems(); initialize_subsystems_failed: mali_osk_low_level_mem_term(); mali_platform_deinit(); platform_init_failed: terminate_kernel_device(); initialize_kernel_device_failed: _mali_dev_platform_unregister(); platform_register_failed: return ret; }
_mali_osk_errcode_t mali_pm_initialize(void) { mali_pm_lock_execute_state_change = _mali_osk_lock_init(_MALI_OSK_LOCKFLAG_ORDERED | _MALI_OSK_LOCKFLAG_ORDERED |_MALI_OSK_LOCKFLAG_NONINTERRUPTABLE, 0, _MALI_OSK_LOCK_ORDER_PM_EXECUTE); if (NULL != mali_pm_lock_execute_state_change ) { mali_pm_lock_set_next_state = _mali_osk_lock_init(_MALI_OSK_LOCKFLAG_ONELOCK| _MALI_OSK_LOCKFLAG_SPINLOCK_IRQ |_MALI_OSK_LOCKFLAG_NONINTERRUPTABLE, 0, _MALI_OSK_LOCK_ORDER_LAST); if (NULL != mali_pm_lock_set_next_state) { mali_pm_lock_set_core_states = _mali_osk_lock_init(_MALI_OSK_LOCKFLAG_ORDERED | _MALI_OSK_LOCKFLAG_NONINTERRUPTABLE, 0, _MALI_OSK_LOCK_ORDER_PM_CORE_STATE); if (NULL != mali_pm_lock_set_core_states) { idle_timer = _mali_osk_timer_init(); if (NULL != idle_timer) { wq_irq = _mali_osk_irq_init(_MALI_OSK_IRQ_NUMBER_PMM, mali_pm_upper_half, mali_pm_bottom_half, NULL, NULL, (void *)NULL, "Mali PM deferred work"); if (NULL != wq_irq) { if (_MALI_OSK_ERR_OK == mali_platform_init()) { #if MALI_PMM_RUNTIME_JOB_CONTROL_ON _mali_osk_pm_dev_enable(); mali_pm_powerup(); #endif return _MALI_OSK_ERR_OK; } _mali_osk_irq_term(wq_irq); } _mali_osk_timer_del(idle_timer); _mali_osk_timer_term(idle_timer); } _mali_osk_lock_term(mali_pm_lock_set_core_states); } _mali_osk_lock_term(mali_pm_lock_set_next_state); } _mali_osk_lock_term(mali_pm_lock_execute_state_change); } return _MALI_OSK_ERR_FAULT; }
int mali_driver_init(void) { int ret = 0; MALI_DEBUG_PRINT(2, ("\n")); MALI_DEBUG_PRINT(2, ("Inserting Mali v%d device driver. \n",_MALI_API_VERSION)); MALI_DEBUG_PRINT(2, ("Compiled: %s, time: %s.\n", __DATE__, __TIME__)); MALI_DEBUG_PRINT(2, ("Driver revision: %s\n", SVN_REV_STRING)); ret = _mali_dev_platform_register(); if (0 != ret) goto platform_register_failed; ret = map_errcode(initialize_kernel_device()); if (0 != ret) goto initialize_kernel_device_failed; ret = map_errcode(mali_platform_init()); if (0 != ret) goto platform_init_failed; mali_osk_low_level_mem_init(); ret = map_errcode(mali_initialize_subsystems()); if (0 != ret) goto initialize_subsystems_failed; ret = initialize_sysfs(); if (0 != ret) goto initialize_sysfs_failed; MALI_PRINT(("Mali device driver loaded\n")); return 0; /* Success */ /* Error handling */ initialize_sysfs_failed: mali_terminate_subsystems(); initialize_subsystems_failed: mali_osk_low_level_mem_term(); mali_platform_deinit(); platform_init_failed: terminate_kernel_device(); initialize_kernel_device_failed: _mali_dev_platform_unregister(); platform_register_failed: return ret; }
int mali_platform_device_register(void) { int err = -1; # if MESON_CPU_TYPE == MESON_CPU_TYPE_MESON6 static_pp_mmu_cnt = 1; # endif MALI_DEBUG_PRINT(4, ("mali_platform_device_register() called\n")); /* Detect present Mali GPU and connect the correct resources to the device */ MALI_DEBUG_PRINT(4, ("Registering Mali-450 MP8 device\n")); err = platform_device_add_resources(&mali_gpu_device, meson_mali_resources, sizeof(meson_mali_resources) / sizeof(meson_mali_resources[0])); if (0 == err) { err = platform_device_add_data(&mali_gpu_device, &mali_gpu_data, sizeof(mali_gpu_data)); if (0 == err) { /* Register the platform device */ err = platform_device_register(&mali_gpu_device); if (0 == err) { mali_platform_init(); #ifdef CONFIG_PM_RUNTIME #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37)) pm_runtime_set_autosuspend_delay(&(mali_gpu_device.dev), 1000); pm_runtime_use_autosuspend(&(mali_gpu_device.dev)); #endif pm_runtime_enable(&(mali_gpu_device.dev)); #endif return 0; } } platform_device_unregister(&mali_gpu_device); } return err; }
int mali_driver_init(void) { int ret = 0; MALI_DEBUG_PRINT(2, ("\n")); MALI_DEBUG_PRINT(2, ("Inserting Mali v%d device driver. \n",_MALI_API_VERSION)); MALI_DEBUG_PRINT(2, ("Compiled: %s, time: %s.\n", __DATE__, __TIME__)); MALI_DEBUG_PRINT(2, ("Driver revision: %s\n", SVN_REV_STRING)); ret = _mali_dev_platform_register(); if (0 != ret) goto platform_register_failed; ret = map_errcode(initialize_kernel_device()); if (0 != ret) goto initialize_kernel_device_failed; ret = map_errcode(mali_platform_init()); if (0 != ret) goto platform_init_failed; mali_osk_low_level_mem_init(); ret = map_errcode(mali_initialize_subsystems()); if (0 != ret) goto initialize_subsystems_failed; #if MALI_INTERNAL_TIMELINE_PROFILING_ENABLED ret = _mali_internal_profiling_init(mali_boot_profiling ? MALI_TRUE : MALI_FALSE); if (0 != ret) { /* No biggie if we wheren't able to initialize the profiling */ MALI_PRINT_ERROR(("Failed to initialize profiling, feature will be unavailable\n")); } #endif ret = initialize_sysfs(); if (0 != ret) goto initialize_sysfs_failed; #if MALI_LICENSE_IS_GPL && defined(CONFIG_MALI_UMP_R3P1_DEBUG_MEM_USAGE_FOR_OOM) ret = register_oom_notifier(&mali_oom_notifier); if (0 != ret) goto initialize_oom_nofifier_failed; #endif MALI_PRINT(("Mali device driver loaded\n")); return 0; /* Success */ /* Error handling */ #if MALI_LICENSE_IS_GPL && defined(CONFIG_MALI_UMP_R3P1_DEBUG_MEM_USAGE_FOR_OOM) initialize_oom_nofifier_failed: /* No need to terminate sysfs, this will be done automatically * along with device termination */ #endif initialize_sysfs_failed: #if MALI_INTERNAL_TIMELINE_PROFILING_ENABLED _mali_internal_profiling_term(); #endif mali_terminate_subsystems(); initialize_subsystems_failed: mali_osk_low_level_mem_term(); mali_platform_deinit(); platform_init_failed: terminate_kernel_device(); initialize_kernel_device_failed: _mali_dev_platform_unregister(); platform_register_failed: return ret; }
_mali_osk_errcode_t malipmm_create(_mali_osk_resource_t *resource) { /* Create PMM state memory */ MALI_DEBUG_ASSERT( pmm_state == NULL ); pmm_state = (_mali_pmm_internal_state_t *) _mali_osk_malloc(sizeof(*pmm_state)); MALI_CHECK_NON_NULL( pmm_state, _MALI_OSK_ERR_NOMEM ); /* All values get 0 as default */ _mali_osk_memset(pmm_state, 0, sizeof(*pmm_state)); /* Set up the initial PMM state */ pmm_state->waiting = 0; pmm_state->status = MALI_PMM_STATUS_IDLE; pmm_state->state = MALI_PMM_STATE_UNAVAILABLE; /* Until a core registers */ /* Set up policy via compile time option for the moment */ #if MALI_PMM_ALWAYS_ON pmm_state->policy = MALI_PMM_POLICY_ALWAYS_ON; #else pmm_state->policy = MALI_PMM_POLICY_JOB_CONTROL; #endif #if MALI_PMM_TRACE _mali_pmm_trace_policy_change( MALI_PMM_POLICY_NONE, pmm_state->policy ); #endif /* Set up assumes all values are initialized to NULL or MALI_FALSE, so * we can exit halfway through set up and perform clean up */ #if !MALI_PMM_NO_PMU if( mali_platform_init(resource) != _MALI_OSK_ERR_OK ) goto pmm_fail_cleanup; pmm_state->pmu_initialized = MALI_TRUE; #endif pmm_state->queue = _mali_osk_notification_queue_init(); if( !pmm_state->queue ) goto pmm_fail_cleanup; pmm_state->iqueue = _mali_osk_notification_queue_init(); if( !pmm_state->iqueue ) goto pmm_fail_cleanup; /* We are creating an IRQ handler just for the worker thread it gives us */ pmm_state->irq = _mali_osk_irq_init( _MALI_OSK_IRQ_NUMBER_PMM, malipmm_irq_uhandler, malipmm_irq_bhandler, NULL, NULL, (void *)pmm_state, /* PMM state is passed to IRQ */ "PMM handler" ); if( !pmm_state->irq ) goto pmm_fail_cleanup; #ifdef CONFIG_SMP mali_pmm_lock = _mali_osk_lock_init((_mali_osk_lock_flags_t)( _MALI_OSK_LOCKFLAG_READERWRITER | _MALI_OSK_LOCKFLAG_ORDERED), 0, 0); if( !mali_pmm_lock ) goto pmm_fail_cleanup; #endif /* CONFIG_SMP */ pmm_state->lock = _mali_osk_lock_init((_mali_osk_lock_flags_t)(_MALI_OSK_LOCKFLAG_READERWRITER | _MALI_OSK_LOCKFLAG_ORDERED), 0, 75); if( !pmm_state->lock ) goto pmm_fail_cleanup; if( _mali_osk_atomic_init( &(pmm_state->messages_queued), 0 ) != _MALI_OSK_ERR_OK ) { goto pmm_fail_cleanup; } MALIPMM_DEBUG_PRINT( ("PMM: subsystem created, policy=%d\n", pmm_state->policy) ); MALI_SUCCESS; pmm_fail_cleanup: MALI_PRINT_ERROR( ("PMM: subsystem failed to be created\n") ); if( pmm_state ) { _mali_osk_resource_type_t t = PMU; if( pmm_state->lock ) _mali_osk_lock_term( pmm_state->lock ); if( pmm_state->irq ) _mali_osk_irq_term( pmm_state->irq ); if( pmm_state->queue ) _mali_osk_notification_queue_term( pmm_state->queue ); if( pmm_state->iqueue ) _mali_osk_notification_queue_term( pmm_state->iqueue ); if( pmm_state->pmu_initialized ) ( mali_platform_deinit(&t) ); _mali_osk_free(pmm_state); pmm_state = NULL; } MALI_ERROR( _MALI_OSK_ERR_FAULT ); }
int mali_meson_init_finish(struct platform_device* ptr_plt_dev) { mali_platform_init(); return 0; }