/* * * (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_pm.h * Power management API definitions */ #ifndef _KBASE_PM_H_ #define _KBASE_PM_H_ #include "mali_kbase_hwaccess_pm.h" #define PM_ENABLE_IRQS 0x01 #define PM_HW_ISSUES_DETECT 0x02 /** Initialize the power management framework. * * Must be called before any other power management function * * @param kbdev The kbase device structure for the device (must be a valid pointer) * * @return 0 if the power management framework was successfully initialized. */ int kbase_pm_init(struct kbase_device *kbdev); /** Power up GPU after all modules have been initialized and interrupt handlers installed. * * @param kbdev The kbase device structure for the device (must be a valid pointer) * * @param flags Flags to pass on to kbase_pm_init_hw * * @return 0 if powerup was successful. */ int kbase_pm_powerup(struct kbase_device *kbdev, unsigned int flags); /** * Halt the power management framework. * Should ensure that no new interrupts are generated, * but allow any currently running interrupt handlers to complete successfully. * The GPU is forced off by the time this function returns, regardless of * whether or not the active power policy asks for the GPU to be powered off. * * @param kbdev The kbase device structure for the device (must be a valid pointer) */ void kbase_pm_halt(struct kbase_device *kbdev); /** Terminate the power management framework. * * No power management functions may be called after this * (except @ref kbase_pm_init) * * @param kbdev The kbase device structure for the device (must be a valid pointer) */ void kbase_pm_term(struct kbase_device *kbdev); /** Increment the count of active contexts. * * This function should be called when a context is about to submit a job. It informs the active power policy that the * GPU is going to be in use shortly and the policy is expected to start turning on the GPU. * * This function will block until the GPU is available. * * This function ASSERTS if a suspend is occuring/has occurred whilst this is * in use. Use kbase_pm_contect_active_unless_suspending() instead. * * @note a Suspend is only visible to Kernel threads; user-space threads in a * syscall cannot witness a suspend, because they are frozen before the suspend * begins. * * @param kbdev The kbase device structure for the device (must be a valid pointer) */ void kbase_pm_context_active(struct kbase_device *kbdev); /** Handler codes for doing kbase_pm_context_active_handle_suspend() */ enum kbase_pm_suspend_handler { /** A suspend is not expected/not possible - this is the same as * kbase_pm_context_active() */ KBASE_PM_SUSPEND_HANDLER_NOT_POSSIBLE, /** If we're suspending, fail and don't increase the active count */ KBASE_PM_SUSPEND_HANDLER_DONT_INCREASE, /** If we're suspending, succeed and allow the active count to increase iff * it didn't go from 0->1 (i.e., we didn't re-activate the GPU). * * This should only be used when there is a bounded time on the activation * (e.g. guarantee it's going to be idled very soon after) */ KBASE_PM_SUSPEND_HANDLER_DONT_REACTIVATE }; /** Suspend 'safe' variant of kbase_pm_context_active() * * If a suspend is in progress, this allows for various different ways of * handling the suspend. Refer to @ref enum kbase_pm_suspend_handler for details. * * We returns a status code indicating whether we're allowed to keep the GPU * active during the suspend, depending on the handler code. If the status code * indicates a failure, the caller must abort whatever operation it was * attempting, and potentially queue it up for after the OS has resumed. * * @param kbdev The kbase device structure for the device (must be a valid pointer) * @param suspend_handler The handler code for how to handle a suspend that might occur * @return zero Indicates success * @return non-zero Indicates failure due to the system being suspending/suspended. */ int kbase_pm_context_active_handle_suspend(struct kbase_device *kbdev, enum kbase_pm_suspend_handler suspend_handler); /** Decrement the reference count of active contexts. * * This function should be called when a context becomes idle. After this call the GPU may be turned off by the power * policy so the calling code should ensure that it does not access the GPU's registers. * * @param kbdev The kbase device structure for the device (must be a valid pointer) */ void kbase_pm_context_idle(struct kbase_device *kbdev); /** * Suspend the GPU and prevent any further register accesses to it from Kernel * threads. * * This is called in response to an OS suspend event, and calls into the various * kbase components to complete the suspend. * * @note the mechanisms used here rely on all user-space threads being frozen * by the OS before we suspend. Otherwise, an IOCTL could occur that powers up * the GPU e.g. via atom submission. * * @param kbdev The kbase device structure for the device (must be a valid pointer) */ void kbase_pm_suspend(struct kbase_device *kbdev); /** * Resume the GPU, allow register accesses to it, and resume running atoms on * the GPU. * * This is called in response to an OS resume event, and calls into the various * kbase components to complete the resume. * * @param kbdev The kbase device structure for the device (must be a valid pointer) */ void kbase_pm_resume(struct kbase_device *kbdev); /** * kbase_pm_vsync_callback - vsync callback * * @buffer_updated: 1 if a new frame was displayed, 0 otherwise * @data: Pointer to the kbase device as returned by kbase_find_device() * * Callback function used to notify the power management code that a vsync has * occurred on the display. */ void kbase_pm_vsync_callback(int buffer_updated, void *data); #endif /* _KBASE_PM_H_ */