/* * * (C) COPYRIGHT 2010-2015 ARM Limited. All rights reserved. * * This program is free software and is provided to you under the terms of the * GNU General Public License version 2 as published by the Free Software * Foundation, and any use by you of this program is subject to the terms * of such GNU licence. * * A copy of the licence is included with the program, and can also be obtained * from Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. * */ /** * @file mali_kbase_config.h * Configuration API and Attributes for KBase */ #ifndef _KBASE_CONFIG_H_ #define _KBASE_CONFIG_H_ #include #include #include /** * @addtogroup base_api * @{ */ /** * @addtogroup base_kbase_api * @{ */ /** * @addtogroup kbase_config Configuration API and Attributes * @{ */ #if !MALI_CUSTOMER_RELEASE /* This flag is set for internal builds so we can run tests without credentials. */ #define KBASE_HWCNT_DUMP_BYPASS_ROOT 1 #else #define KBASE_HWCNT_DUMP_BYPASS_ROOT 0 #endif #include /* Forward declaration of struct kbase_device */ struct kbase_device; /** * kbase_platform_funcs_conf - Specifies platform init/term function pointers * * Specifies the functions pointers for platform specific initialization and * termination. By default no functions are required. No additional platform * specific control is necessary. */ struct kbase_platform_funcs_conf { /** * platform_init_func - platform specific init function pointer * @kbdev - kbase_device pointer * * Returns 0 on success, negative error code otherwise. * * Function pointer for platform specific initialization or NULL if no * initialization function is required. At the point this the GPU is * not active and its power and clocks are in unknown (platform specific * state) as kbase doesn't yet have control of power and clocks. * * The platform specific private pointer kbase_device::platform_context * can be accessed (and possibly initialized) in here. */ int (*platform_init_func)(struct kbase_device *kbdev); /** * platform_term_func - platform specific termination function pointer * @kbdev - kbase_device pointer * * Function pointer for platform specific termination or NULL if no * termination function is required. At the point this the GPU will be * idle but still powered and clocked. * * The platform specific private pointer kbase_device::platform_context * can be accessed (and possibly terminated) in here. */ void (*platform_term_func)(struct kbase_device *kbdev); }; /* * @brief Specifies the callbacks for power management * * By default no callbacks will be made and the GPU must not be powered off. */ struct kbase_pm_callback_conf { /** Callback for when the GPU is idle and the power to it can be switched off. * * The system integrator can decide whether to either do nothing, just switch off * the clocks to the GPU, or to completely power down the GPU. * The platform specific private pointer kbase_device::platform_context can be accessed and modified in here. It is the * platform \em callbacks responsiblity to initialize and terminate this pointer if used (see @ref kbase_platform_funcs_conf). */ void (*power_off_callback)(struct kbase_device *kbdev); /** Callback for when the GPU is about to become active and power must be supplied. * * This function must not return until the GPU is powered and clocked sufficiently for register access to * succeed. The return value specifies whether the GPU was powered down since the call to power_off_callback. * If the GPU state has been lost then this function must return 1, otherwise it should return 0. * The platform specific private pointer kbase_device::platform_context can be accessed and modified in here. It is the * platform \em callbacks responsiblity to initialize and terminate this pointer if used (see @ref kbase_platform_funcs_conf). * * The return value of the first call to this function is ignored. * * @return 1 if the GPU state may have been lost, 0 otherwise. */ int (*power_on_callback)(struct kbase_device *kbdev); /** Callback for when the system is requesting a suspend and GPU power * must be switched off. * * Note that if this callback is present, then this may be called * without a preceding call to power_off_callback. Therefore this * callback must be able to take any action that might otherwise happen * in power_off_callback. * * The platform specific private pointer kbase_device::platform_context * can be accessed and modified in here. It is the platform \em * callbacks responsibility to initialize and terminate this pointer if * used (see @ref kbase_platform_funcs_conf). */ void (*power_suspend_callback)(struct kbase_device *kbdev); /** Callback for when the system is resuming from a suspend and GPU * power must be switched on. * * Note that if this callback is present, then this may be called * without a following call to power_on_callback. Therefore this * callback must be able to take any action that might otherwise happen * in power_on_callback. * * The platform specific private pointer kbase_device::platform_context * can be accessed and modified in here. It is the platform \em * callbacks responsibility to initialize and terminate this pointer if * used (see @ref kbase_platform_funcs_conf). */ void (*power_resume_callback)(struct kbase_device *kbdev); /** Callback for handling runtime power management initialization. * * The runtime power management callbacks @ref power_runtime_off_callback and @ref power_runtime_on_callback * will become active from calls made to the OS from within this function. * The runtime calls can be triggered by calls from @ref power_off_callback and @ref power_on_callback. * Note: for linux the kernel must have CONFIG_PM_RUNTIME enabled to use this feature. * * @return 0 on success, else int erro code. */ int (*power_runtime_init_callback)(struct kbase_device *kbdev); /** Callback for handling runtime power management termination. * * The runtime power management callbacks @ref power_runtime_off_callback and @ref power_runtime_on_callback * should no longer be called by the OS on completion of this function. * Note: for linux the kernel must have CONFIG_PM_RUNTIME enabled to use this feature. */ void (*power_runtime_term_callback)(struct kbase_device *kbdev); /** Callback for runtime power-off power management callback * * For linux this callback will be called by the kernel runtime_suspend callback. * Note: for linux the kernel must have CONFIG_PM_RUNTIME enabled to use this feature. * * @return 0 on success, else OS error code. */ void (*power_runtime_off_callback)(struct kbase_device *kbdev); /** Callback for runtime power-on power management callback * * For linux this callback will be called by the kernel runtime_resume callback. * Note: for linux the kernel must have CONFIG_PM_RUNTIME enabled to use this feature. */ int (*power_runtime_on_callback)(struct kbase_device *kbdev); /* * Optional callback for checking if GPU can be suspended when idle * * This callback will be called by the runtime power management core * when the reference count goes to 0 to provide notification that the * GPU now seems idle. * * If this callback finds that the GPU can't be powered off, or handles * suspend by powering off directly or queueing up a power off, a * non-zero value must be returned to prevent the runtime PM core from * also triggering a suspend. * * Returning 0 will cause the runtime PM core to conduct a regular * autosuspend. * * This callback is optional and if not provided regular ausosuspend * will triggered. * * Note: The Linux kernel must have CONFIG_PM_RUNTIME enabled to use * this feature. * * Return 0 if GPU can be suspended, positive value if it can not be * suspeneded by runtime PM, else OS error code */ int (*power_runtime_idle_callback)(struct kbase_device *kbdev); }; /** * kbase_cpuprops_get_default_clock_speed - default for CPU_SPEED_FUNC * @clock_speed - see kbase_cpu_clk_speed_func for details on the parameters * * Returns 0 on success, negative error code otherwise. * * Default implementation of CPU_SPEED_FUNC. This function sets clock_speed * to 100, so will be an underestimate for any real system. */ int kbase_cpuprops_get_default_clock_speed(u32 * const clock_speed); /** * kbase_cpu_clk_speed_func - Type of the function pointer for CPU_SPEED_FUNC * @param clock_speed - pointer to store the current CPU clock speed in MHz * * Returns 0 on success, otherwise negative error code. * * This is mainly used to implement OpenCL's clGetDeviceInfo(). */ typedef int (*kbase_cpu_clk_speed_func) (u32 *clock_speed); /** * kbase_gpu_clk_speed_func - Type of the function pointer for GPU_SPEED_FUNC * @param clock_speed - pointer to store the current GPU clock speed in MHz * * Returns 0 on success, otherwise negative error code. * When an error is returned the caller assumes maximum GPU speed stored in * gpu_freq_khz_max. * * If the system timer is not available then this function is required * for the OpenCL queue profiling to return correct timing information. * */ typedef int (*kbase_gpu_clk_speed_func) (u32 *clock_speed); #ifdef CONFIG_OF struct kbase_platform_config { }; #else /* * @brief Specifies start and end of I/O memory region. */ struct kbase_io_memory_region { u64 start; u64 end; }; /* * @brief Specifies I/O related resources like IRQs and memory region for I/O operations. */ struct kbase_io_resources { u32 job_irq_number; u32 mmu_irq_number; u32 gpu_irq_number; struct kbase_io_memory_region io_memory_region; }; struct kbase_platform_config { const struct kbase_io_resources *io_resources; }; #endif /* CONFIG_OF */ /** * @brief Gets the pointer to platform config. * * @return Pointer to the platform config */ struct kbase_platform_config *kbase_get_platform_config(void); /** * kbasep_platform_device_init: - Platform specific call to initialize hardware * @kbdev: kbase device pointer * * Function calls a platform defined routine if specified in the configuration * attributes. The routine can initialize any hardware and context state that * is required for the GPU block to function. * * Return: 0 if no errors have been found in the config. * Negative error code otherwise. */ int kbasep_platform_device_init(struct kbase_device *kbdev); /** * kbasep_platform_device_term - Platform specific call to terminate hardware * @kbdev: Kbase device pointer * * Function calls a platform defined routine if specified in the configuration * attributes. The routine can destroy any platform specific context state and * shut down any hardware functionality that are outside of the Power Management * callbacks. * */ void kbasep_platform_device_term(struct kbase_device *kbdev); /** * kbase_platform_early_init - Early initialisation of the platform code * * This function will be called when the module is loaded to perform any * early initialisation required by the platform code. Such as reading * platform specific device tree entries for the GPU. * * Return: 0 for success, any other fail causes module initialisation to fail */ int kbase_platform_early_init(void); #ifndef CONFIG_OF #ifdef CONFIG_MALI_PLATFORM_FAKE /** * kbase_platform_fake_register - Register a platform device for the GPU * * This can be used to register a platform device on systems where device tree * is not enabled and the platform initialisation code in the kernel doesn't * create the GPU device. Where possible device tree should be used instead. * * Return: 0 for success, any other fail causes module initialisation to fail */ int kbase_platform_fake_register(void); /** * kbase_platform_fake_unregister - Unregister a fake platform device * * Unregister the platform device created with kbase_platform_fake_register() */ void kbase_platform_fake_unregister(void); #endif #endif /** @} *//* end group kbase_config */ /** @} *//* end group base_kbase_api */ /** @} *//* end group base_api */ #endif /* _KBASE_CONFIG_H_ */