/*
|
*
|
* (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.
|
*
|
*/
|
|
|
|
/*
|
* Power policy API definitions
|
*/
|
|
#ifndef _KBASE_PM_POLICY_H_
|
#define _KBASE_PM_POLICY_H_
|
|
/**
|
* kbase_pm_policy_init - Initialize power policy framework
|
*
|
* @kbdev: The kbase device structure for the device (must be a valid pointer)
|
*
|
* Must be called before calling any other policy function
|
*
|
* Return: 0 if the power policy framework was successfully
|
* initialized, -errno otherwise.
|
*/
|
int kbase_pm_policy_init(struct kbase_device *kbdev);
|
|
/**
|
* kbase_pm_policy_term - Terminate power policy framework
|
*
|
* @kbdev: The kbase device structure for the device (must be a valid pointer)
|
*/
|
void kbase_pm_policy_term(struct kbase_device *kbdev);
|
|
/**
|
* kbase_pm_update_active - Update the active power state of the GPU
|
*
|
* @kbdev: The kbase device structure for the device (must be a valid pointer)
|
*
|
* Calls into the current power policy
|
*/
|
void kbase_pm_update_active(struct kbase_device *kbdev);
|
|
/**
|
* kbase_pm_update_cores - Update the desired core state of the GPU
|
*
|
* @kbdev: The kbase device structure for the device (must be a valid pointer)
|
*
|
* Calls into the current power policy
|
*/
|
void kbase_pm_update_cores(struct kbase_device *kbdev);
|
|
|
enum kbase_pm_cores_ready {
|
KBASE_CORES_NOT_READY = 0,
|
KBASE_NEW_AFFINITY = 1,
|
KBASE_CORES_READY = 2
|
};
|
|
|
/**
|
* kbase_pm_request_cores_sync - Synchronous variant of kbase_pm_request_cores()
|
*
|
* @kbdev: The kbase device structure for the device
|
* @tiler_required: true if the tiler is required, false otherwise
|
* @shader_cores: A bitmask of shader cores which are necessary for the job
|
*
|
* When this function returns, the @shader_cores will be in the READY state.
|
*
|
* This is safe variant of kbase_pm_check_transitions_sync(): it handles the
|
* work of ensuring the requested cores will remain powered until a matching
|
* call to kbase_pm_unrequest_cores()/kbase_pm_release_cores() (as appropriate)
|
* is made.
|
*/
|
void kbase_pm_request_cores_sync(struct kbase_device *kbdev,
|
bool tiler_required, u64 shader_cores);
|
|
/**
|
* kbase_pm_request_cores - Mark one or more cores as being required
|
* for jobs to be submitted
|
*
|
* @kbdev: The kbase device structure for the device
|
* @tiler_required: true if the tiler is required, false otherwise
|
* @shader_cores: A bitmask of shader cores which are necessary for the job
|
*
|
* This function is called by the job scheduler to mark one or more cores as
|
* being required to submit jobs that are ready to run.
|
*
|
* The cores requested are reference counted and a subsequent call to
|
* kbase_pm_register_inuse_cores() or kbase_pm_unrequest_cores() should be
|
* made to dereference the cores as being 'needed'.
|
*
|
* The active power policy will meet or exceed the requirements of the
|
* requested cores in the system. Any core transitions needed will be begun
|
* immediately, but they might not complete/the cores might not be available
|
* until a Power Management IRQ.
|
*
|
* Return: 0 if the cores were successfully requested, or -errno otherwise.
|
*/
|
void kbase_pm_request_cores(struct kbase_device *kbdev,
|
bool tiler_required, u64 shader_cores);
|
|
/**
|
* kbase_pm_unrequest_cores - Unmark one or more cores as being required for
|
* jobs to be submitted.
|
*
|
* @kbdev: The kbase device structure for the device
|
* @tiler_required: true if the tiler is required, false otherwise
|
* @shader_cores: A bitmask of shader cores (as given to
|
* kbase_pm_request_cores() )
|
*
|
* This function undoes the effect of kbase_pm_request_cores(). It should be
|
* used when a job is not going to be submitted to the hardware (e.g. the job is
|
* cancelled before it is enqueued).
|
*
|
* The active power policy will meet or exceed the requirements of the
|
* requested cores in the system. Any core transitions needed will be begun
|
* immediately, but they might not complete until a Power Management IRQ.
|
*
|
* The policy may use this as an indication that it can power down cores.
|
*/
|
void kbase_pm_unrequest_cores(struct kbase_device *kbdev,
|
bool tiler_required, u64 shader_cores);
|
|
/**
|
* kbase_pm_register_inuse_cores - Register a set of cores as in use by a job
|
*
|
* @kbdev: The kbase device structure for the device
|
* @tiler_required: true if the tiler is required, false otherwise
|
* @shader_cores: A bitmask of shader cores (as given to
|
* kbase_pm_request_cores() )
|
*
|
* This function should be called after kbase_pm_request_cores() when the job
|
* is about to be submitted to the hardware. It will check that the necessary
|
* cores are available and if so update the 'needed' and 'inuse' bitmasks to
|
* reflect that the job is now committed to being run.
|
*
|
* If the necessary cores are not currently available then the function will
|
* return %KBASE_CORES_NOT_READY and have no effect.
|
*
|
* Return: %KBASE_CORES_NOT_READY if the cores are not immediately ready,
|
*
|
* %KBASE_NEW_AFFINITY if the affinity requested is not allowed,
|
*
|
* %KBASE_CORES_READY if the cores requested are already available
|
*/
|
enum kbase_pm_cores_ready kbase_pm_register_inuse_cores(
|
struct kbase_device *kbdev,
|
bool tiler_required,
|
u64 shader_cores);
|
|
/**
|
* kbase_pm_release_cores - Release cores after a job has run
|
*
|
* @kbdev: The kbase device structure for the device
|
* @tiler_required: true if the tiler is required, false otherwise
|
* @shader_cores: A bitmask of shader cores (as given to
|
* kbase_pm_register_inuse_cores() )
|
*
|
* This function should be called when a job has finished running on the
|
* hardware. A call to kbase_pm_register_inuse_cores() must have previously
|
* occurred. The reference counts of the specified cores will be decremented
|
* which may cause the bitmask of 'inuse' cores to be reduced. The power policy
|
* may then turn off any cores which are no longer 'inuse'.
|
*/
|
void kbase_pm_release_cores(struct kbase_device *kbdev,
|
bool tiler_required, u64 shader_cores);
|
|
/**
|
* kbase_pm_request_l2_caches - Request l2 caches
|
*
|
* @kbdev: The kbase device structure for the device (must be a valid pointer)
|
*
|
* Request the use of l2 caches for all core groups, power up, wait and prevent
|
* the power manager from powering down the l2 caches.
|
*
|
* This tells the power management that the caches should be powered up, and
|
* they should remain powered, irrespective of the usage of shader cores. This
|
* does not return until the l2 caches are powered up.
|
*
|
* The caller must call kbase_pm_release_l2_caches() when they are finished
|
* to allow normal power management of the l2 caches to resume.
|
*
|
* This should only be used when power management is active.
|
*/
|
void kbase_pm_request_l2_caches(struct kbase_device *kbdev);
|
|
/**
|
* kbase_pm_request_l2_caches_l2_is_on - Request l2 caches but don't power on
|
*
|
* @kbdev: The kbase device structure for the device (must be a valid pointer)
|
*
|
* Increment the count of l2 users but do not attempt to power on the l2
|
*
|
* It is the callers responsibility to ensure that the l2 is already powered up
|
* and to eventually call kbase_pm_release_l2_caches()
|
*/
|
void kbase_pm_request_l2_caches_l2_is_on(struct kbase_device *kbdev);
|
|
/**
|
* kbase_pm_request_l2_caches - Release l2 caches
|
*
|
* @kbdev: The kbase device structure for the device (must be a valid pointer)
|
*
|
* Release the use of l2 caches for all core groups and allow the power manager
|
* to power them down when necessary.
|
*
|
* This tells the power management that the caches can be powered down if
|
* necessary, with respect to the usage of shader cores.
|
*
|
* The caller must have called kbase_pm_request_l2_caches() prior to a call
|
* to this.
|
*
|
* This should only be used when power management is active.
|
*/
|
void kbase_pm_release_l2_caches(struct kbase_device *kbdev);
|
|
#endif /* _KBASE_PM_POLICY_H_ */
|
