void mali_driver_exit(void) { MALI_DEBUG_PRINT(2, ("\n")); MALI_DEBUG_PRINT(2, ("Unloading Mali v%d device driver.\n",_MALI_API_VERSION)); #if MALI_LICENSE_IS_GPL && defined(CONFIG_MALI_UMP_R3P1_DEBUG_MEM_USAGE_FOR_OOM) unregister_oom_notifier(&mali_oom_notifier); #endif /* No need to terminate sysfs, this will be done automatically along with device termination */ #if MALI_INTERNAL_TIMELINE_PROFILING_ENABLED _mali_internal_profiling_term(); #endif mali_terminate_subsystems(); mali_osk_low_level_mem_term(); mali_platform_deinit(); terminate_kernel_device(); _mali_dev_platform_unregister(); #if MALI_LICENSE_IS_GPL /* @@@@ clean up the work queues! This should not be terminated here, since it isn't inited in the function above! */ flush_workqueue(mali_wq); destroy_workqueue(mali_wq); mali_wq = NULL; #endif MALI_PRINT(("Mali device driver unloaded\n")); }
/* 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 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; }
void malipmm_kernel_subsystem_terminate( mali_kernel_subsystem_identifier id ) { /* Check this is the right system */ MALI_DEBUG_ASSERT( id == mali_subsystem_pmm_id ); MALI_DEBUG_ASSERT_POINTER(pmm_state); if( pmm_state ) { _mali_osk_resource_type_t t = PMU; #if PMM_OS_TEST power_test_end(); #endif /* Get the lock so we can shutdown */ MALI_PMM_LOCK(pmm_state); pmm_state->status = MALI_PMM_STATUS_OFF; MALI_PMM_UNLOCK(pmm_state); pmm_policy_term(pmm_state); _mali_osk_irq_term( pmm_state->irq ); #ifdef CONFIG_SMP _mali_osk_lock_term(mali_pmm_lock); #endif /* CONFIG_SMP */ _mali_osk_notification_queue_term( pmm_state->queue ); _mali_osk_notification_queue_term( pmm_state->iqueue ); if( pmm_state->pmu_initialized ) mali_platform_deinit(&t); _mali_osk_atomic_term( &(pmm_state->messages_queued) ); MALI_PMM_LOCK_TERM(pmm_state); _mali_osk_free(pmm_state); pmm_state = NULL; } MALIPMM_DEBUG_PRINT( ("PMM: subsystem terminated\n") ); }
void mali_driver_exit(void) { MALI_DEBUG_PRINT(2, ("\n")); MALI_DEBUG_PRINT(2, ("Unloading Mali v%d device driver.\n",_MALI_API_VERSION)); /* No need to terminate sysfs, this will be done automatically along with device termination */ mali_terminate_subsystems(); mali_osk_low_level_mem_term(); mali_platform_deinit(); terminate_kernel_device(); _mali_dev_platform_unregister(); #if MALI_LICENSE_IS_GPL /* @@@@ clean up the work queues! This should not be terminated here, since it isn't inited in the function above! */ flush_workqueue(mali_wq); destroy_workqueue(mali_wq); mali_wq = NULL; #endif MALI_PRINT(("Mali device driver unloaded\n")); }
/***************************************************************************** function name : mali_platform_device_unregister description : mali platform device unregister input vars : void output vars : NA return value : void calls : platform_device_unregister called : os history : 1.data : 18/10/2012 modify : new *****************************************************************************/ void mali_platform_device_unregister(void) { MALI_DEBUG_PRINT(4, ("mali_platform_device_unregister() called\n")); mali_platform_deinit(); platform_device_unregister(&mali_gpu_device); platform_device_put(&mali_gpu_device); }
void mali_pm_terminate(void) { mali_platform_deinit(); _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_execute_state_change); _mali_osk_lock_term(mali_pm_lock_set_next_state); _mali_osk_lock_term(mali_pm_lock_set_core_states); }
static int mali_remove(struct platform_device *pdev) { MALI_DEBUG_PRINT(2, ("mali_remove() called for platform device %s\n", pdev->name)); mali_sysfs_unregister(); mali_miscdevice_unregister(); mali_terminate_subsystems(); _mali_osk_wq_term(); mali_platform_deinit(); mali_platform_device = NULL; return 0; }
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; }
void mali_platform_device_unregister(void) { MALI_DEBUG_PRINT(4, ("mali_platform_device_unregister() called\n")); #ifdef CONFIG_PM_RUNTIME unregister_pm_notifier(&mali_pwr_notif_block); #endif /* CONFIG_PM_RUNTIME */ mali_platform_deinit(&(mali_gpu_device.dev)); platform_device_unregister(&mali_gpu_device); }
/* is called from OS specific driver exit point */ void mali_kernel_destructor( void ) { MALI_DEBUG_PRINT(2, ("\n")); MALI_DEBUG_PRINT(2, ("Unloading Mali v%d device driver.\n",_MALI_API_VERSION)); terminate_subsystems(); /* subsystems are responsible for their registered resources */ _mali_osk_term(); if (_MALI_OSK_ERR_OK != mali_platform_deinit(NULL)) { MALI_PRINT(("Failed to deinit platform\n")); } MALI_DEBUG_PRINT(2, ("Module unloaded.\n")); }
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_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; }
void mali_platform_device_unregister(void) { MALI_DEBUG_PRINT(4, ("mali_platform_device_unregister() called\n")); mali_platform_deinit(&(exynos4_device_g3d.dev)); }
_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_uninit(struct platform_device* ptr_plt_dev) { mali_platform_deinit(); return 0; }