282 lines · c
1// SPDX-License-Identifier: MIT2/*3 * Copyright (C) 2019 Google, Inc.4 *5 * Authors:6 * Sean Paul <seanpaul@chromium.org>7 */8#include <linux/average.h>9#include <linux/bitops.h>10#include <linux/slab.h>11#include <linux/workqueue.h>12 13#include <drm/drm_atomic.h>14#include <drm/drm_atomic_helper.h>15#include <drm/drm_connector.h>16#include <drm/drm_crtc.h>17#include <drm/drm_device.h>18#include <drm/drm_mode_config.h>19#include <drm/drm_modeset_lock.h>20#include <drm/drm_print.h>21#include <drm/drm_self_refresh_helper.h>22 23/**24 * DOC: overview25 *26 * This helper library provides an easy way for drivers to leverage the atomic27 * framework to implement panel self refresh (SR) support. Drivers are28 * responsible for initializing and cleaning up the SR helpers on load/unload29 * (see &drm_self_refresh_helper_init/&drm_self_refresh_helper_cleanup).30 * The connector is responsible for setting31 * &drm_connector_state.self_refresh_aware to true at runtime if it is SR-aware32 * (meaning it knows how to initiate self refresh on the panel).33 *34 * Once a crtc has enabled SR using &drm_self_refresh_helper_init, the35 * helpers will monitor activity and call back into the driver to enable/disable36 * SR as appropriate. The best way to think about this is that it's a DPMS37 * on/off request with &drm_crtc_state.self_refresh_active set in crtc state38 * that tells you to disable/enable SR on the panel instead of power-cycling it.39 *40 * During SR, drivers may choose to fully disable their crtc/encoder/bridge41 * hardware (in which case no driver changes are necessary), or they can inspect42 * &drm_crtc_state.self_refresh_active if they want to enter low power mode43 * without full disable (in case full disable/enable is too slow).44 *45 * SR will be deactivated if there are any atomic updates affecting the46 * pipe that is in SR mode. If a crtc is driving multiple connectors, all47 * connectors must be SR aware and all will enter/exit SR mode at the same time.48 *49 * If the crtc and connector are SR aware, but the panel connected does not50 * support it (or is otherwise unable to enter SR), the driver should fail51 * atomic_check when &drm_crtc_state.self_refresh_active is true.52 */53 54#define SELF_REFRESH_AVG_SEED_MS 20055 56DECLARE_EWMA(psr_time, 4, 4)57 58struct drm_self_refresh_data {59 struct drm_crtc *crtc;60 struct delayed_work entry_work;61 62 struct mutex avg_mutex;63 struct ewma_psr_time entry_avg_ms;64 struct ewma_psr_time exit_avg_ms;65};66 67static void drm_self_refresh_helper_entry_work(struct work_struct *work)68{69 struct drm_self_refresh_data *sr_data = container_of(70 to_delayed_work(work),71 struct drm_self_refresh_data, entry_work);72 struct drm_crtc *crtc = sr_data->crtc;73 struct drm_device *dev = crtc->dev;74 struct drm_modeset_acquire_ctx ctx;75 struct drm_atomic_state *state;76 struct drm_connector *conn;77 struct drm_connector_state *conn_state;78 struct drm_crtc_state *crtc_state;79 int i, ret = 0;80 81 drm_modeset_acquire_init(&ctx, 0);82 83 state = drm_atomic_state_alloc(dev);84 if (!state) {85 ret = -ENOMEM;86 goto out_drop_locks;87 }88 89retry:90 state->acquire_ctx = &ctx;91 92 crtc_state = drm_atomic_get_crtc_state(state, crtc);93 if (IS_ERR(crtc_state)) {94 ret = PTR_ERR(crtc_state);95 goto out;96 }97 98 if (!crtc_state->enable)99 goto out;100 101 ret = drm_atomic_add_affected_connectors(state, crtc);102 if (ret)103 goto out;104 105 for_each_new_connector_in_state(state, conn, conn_state, i) {106 if (!conn_state->self_refresh_aware)107 goto out;108 }109 110 crtc_state->active = false;111 crtc_state->self_refresh_active = true;112 113 ret = drm_atomic_commit(state);114 if (ret)115 goto out;116 117out:118 if (ret == -EDEADLK) {119 drm_atomic_state_clear(state);120 ret = drm_modeset_backoff(&ctx);121 if (!ret)122 goto retry;123 }124 125 drm_atomic_state_put(state);126 127out_drop_locks:128 drm_modeset_drop_locks(&ctx);129 drm_modeset_acquire_fini(&ctx);130}131 132/**133 * drm_self_refresh_helper_update_avg_times - Updates a crtc's SR time averages134 * @state: the state which has just been applied to hardware135 * @commit_time_ms: the amount of time in ms that this commit took to complete136 * @new_self_refresh_mask: bitmask of crtc's that have self_refresh_active in137 * new state138 *139 * Called after &drm_mode_config_funcs.atomic_commit_tail, this function will140 * update the average entry/exit self refresh times on self refresh transitions.141 * These averages will be used when calculating how long to delay before142 * entering self refresh mode after activity.143 */144void145drm_self_refresh_helper_update_avg_times(struct drm_atomic_state *state,146 unsigned int commit_time_ms,147 unsigned int new_self_refresh_mask)148{149 struct drm_crtc *crtc;150 struct drm_crtc_state *old_crtc_state;151 int i;152 153 for_each_old_crtc_in_state(state, crtc, old_crtc_state, i) {154 bool new_self_refresh_active = new_self_refresh_mask & BIT(i);155 struct drm_self_refresh_data *sr_data = crtc->self_refresh_data;156 struct ewma_psr_time *time;157 158 if (old_crtc_state->self_refresh_active ==159 new_self_refresh_active)160 continue;161 162 if (new_self_refresh_active)163 time = &sr_data->entry_avg_ms;164 else165 time = &sr_data->exit_avg_ms;166 167 mutex_lock(&sr_data->avg_mutex);168 ewma_psr_time_add(time, commit_time_ms);169 mutex_unlock(&sr_data->avg_mutex);170 }171}172EXPORT_SYMBOL(drm_self_refresh_helper_update_avg_times);173 174/**175 * drm_self_refresh_helper_alter_state - Alters the atomic state for SR exit176 * @state: the state currently being checked177 *178 * Called at the end of atomic check. This function checks the state for flags179 * incompatible with self refresh exit and changes them. This is a bit180 * disingenuous since userspace is expecting one thing and we're giving it181 * another. However in order to keep self refresh entirely hidden from182 * userspace, this is required.183 *184 * At the end, we queue up the self refresh entry work so we can enter PSR after185 * the desired delay.186 */187void drm_self_refresh_helper_alter_state(struct drm_atomic_state *state)188{189 struct drm_crtc *crtc;190 struct drm_crtc_state *crtc_state;191 int i;192 193 if (state->async_update || !state->allow_modeset) {194 for_each_old_crtc_in_state(state, crtc, crtc_state, i) {195 if (crtc_state->self_refresh_active) {196 state->async_update = false;197 state->allow_modeset = true;198 break;199 }200 }201 }202 203 for_each_new_crtc_in_state(state, crtc, crtc_state, i) {204 struct drm_self_refresh_data *sr_data;205 unsigned int delay;206 207 /* Don't trigger the entry timer when we're already in SR */208 if (crtc_state->self_refresh_active)209 continue;210 211 sr_data = crtc->self_refresh_data;212 if (!sr_data)213 continue;214 215 mutex_lock(&sr_data->avg_mutex);216 delay = (ewma_psr_time_read(&sr_data->entry_avg_ms) +217 ewma_psr_time_read(&sr_data->exit_avg_ms)) * 2;218 mutex_unlock(&sr_data->avg_mutex);219 220 mod_delayed_work(system_wq, &sr_data->entry_work,221 msecs_to_jiffies(delay));222 }223}224EXPORT_SYMBOL(drm_self_refresh_helper_alter_state);225 226/**227 * drm_self_refresh_helper_init - Initializes self refresh helpers for a crtc228 * @crtc: the crtc which supports self refresh supported displays229 *230 * Returns zero if successful or -errno on failure231 */232int drm_self_refresh_helper_init(struct drm_crtc *crtc)233{234 struct drm_self_refresh_data *sr_data = crtc->self_refresh_data;235 236 /* Helper is already initialized */237 if (WARN_ON(sr_data))238 return -EINVAL;239 240 sr_data = kzalloc(sizeof(*sr_data), GFP_KERNEL);241 if (!sr_data)242 return -ENOMEM;243 244 INIT_DELAYED_WORK(&sr_data->entry_work,245 drm_self_refresh_helper_entry_work);246 sr_data->crtc = crtc;247 mutex_init(&sr_data->avg_mutex);248 ewma_psr_time_init(&sr_data->entry_avg_ms);249 ewma_psr_time_init(&sr_data->exit_avg_ms);250 251 /*252 * Seed the averages so they're non-zero (and sufficiently large253 * for even poorly performing panels). As time goes on, this will be254 * averaged out and the values will trend to their true value.255 */256 ewma_psr_time_add(&sr_data->entry_avg_ms, SELF_REFRESH_AVG_SEED_MS);257 ewma_psr_time_add(&sr_data->exit_avg_ms, SELF_REFRESH_AVG_SEED_MS);258 259 crtc->self_refresh_data = sr_data;260 return 0;261}262EXPORT_SYMBOL(drm_self_refresh_helper_init);263 264/**265 * drm_self_refresh_helper_cleanup - Cleans up self refresh helpers for a crtc266 * @crtc: the crtc to cleanup267 */268void drm_self_refresh_helper_cleanup(struct drm_crtc *crtc)269{270 struct drm_self_refresh_data *sr_data = crtc->self_refresh_data;271 272 /* Helper is already uninitialized */273 if (!sr_data)274 return;275 276 crtc->self_refresh_data = NULL;277 278 cancel_delayed_work_sync(&sr_data->entry_work);279 kfree(sr_data);280}281EXPORT_SYMBOL(drm_self_refresh_helper_cleanup);282