drivers/gpu/drm/drm_self_refresh_helper.c

   1 // SPDX-License-Identifier: MIT
   2 /*
   3  * Copyright (C) 2019 Google, Inc.
   4  *
   5  * Authors:
   6  * Sean Paul <[email protected]>
   7  */
   8 #include <linux/bitops.h>
   9 #include <linux/slab.h>
  10 #include <linux/workqueue.h>
  11
  12 #include <drm/drm_atomic.h>
  13 #include <drm/drm_atomic_helper.h>
  14 #include <drm/drm_connector.h>
  15 #include <drm/drm_crtc.h>
  16 #include <drm/drm_device.h>
  17 #include <drm/drm_mode_config.h>
  18 #include <drm/drm_modeset_lock.h>
  19 #include <drm/drm_print.h>
  20 #include <drm/drm_self_refresh_helper.h>
  21
  22 /**
  23  * DOC: overview
  24  *
  25  * This helper library provides an easy way for drivers to leverage the atomic
  26  * framework to implement panel self refresh (SR) support. Drivers are
  27  * responsible for initializing and cleaning up the SR helpers on load/unload
  28  * (see &drm_self_refresh_helper_init/&drm_self_refresh_helper_cleanup).
  29  * The connector is responsible for setting
  30  * &drm_connector_state.self_refresh_aware to true at runtime if it is SR-aware
  31  * (meaning it knows how to initiate self refresh on the panel).
  32  *
  33  * Once a crtc has enabled SR using &drm_self_refresh_helper_init, the
  34  * helpers will monitor activity and call back into the driver to enable/disable
  35  * SR as appropriate. The best way to think about this is that it's a DPMS
  36  * on/off request with &drm_crtc_state.self_refresh_active set in crtc state
  37  * that tells you to disable/enable SR on the panel instead of power-cycling it.
  38  *
  39  * During SR, drivers may choose to fully disable their crtc/encoder/bridge
  40  * hardware (in which case no driver changes are necessary), or they can inspect
  41  * &drm_crtc_state.self_refresh_active if they want to enter low power mode
  42  * without full disable (in case full disable/enable is too slow).
  43  *
  44  * SR will be deactivated if there are any atomic updates affecting the
  45  * pipe that is in SR mode. If a crtc is driving multiple connectors, all
  46  * connectors must be SR aware and all will enter/exit SR mode at the same time.
  47  *
  48  * If the crtc and connector are SR aware, but the panel connected does not
  49  * support it (or is otherwise unable to enter SR), the driver should fail
  50  * atomic_check when &drm_crtc_state.self_refresh_active is true.
  51  */
  52
  53 struct drm_self_refresh_data {
  54         struct drm_crtc *crtc;
  55         struct delayed_work entry_work;
  56         struct drm_atomic_state *save_state;
  57         unsigned int entry_delay_ms;
  58 };
  59
  60 static void drm_self_refresh_helper_entry_work(struct work_struct *work)
  61 {
  62         struct drm_self_refresh_data *sr_data = container_of(
  63                                 to_delayed_work(work),
  64                                 struct drm_self_refresh_data, entry_work);
  65         struct drm_crtc *crtc = sr_data->crtc;
  66         struct drm_device *dev = crtc->dev;
  67         struct drm_modeset_acquire_ctx ctx;
  68         struct drm_atomic_state *state;
  69         struct drm_connector *conn;
  70         struct drm_connector_state *conn_state;
  71         struct drm_crtc_state *crtc_state;
  72         int i, ret = 0;
  73
  74         drm_modeset_acquire_init(&ctx, 0);
  75
  76         state = drm_atomic_state_alloc(dev);
  77         if (!state) {
  78                 ret = -ENOMEM;
  79                 goto out_drop_locks;
  80         }
  81
  82 retry:
  83         state->acquire_ctx = &ctx;
  84
  85         crtc_state = drm_atomic_get_crtc_state(state, crtc);
  86         if (IS_ERR(crtc_state)) {
  87                 ret = PTR_ERR(crtc_state);
  88                 goto out;
  89         }
  90
  91         if (!crtc_state->enable)
  92                 goto out;
  93
  94         ret = drm_atomic_add_affected_connectors(state, crtc);
  95         if (ret)
  96                 goto out;
  97
  98         for_each_new_connector_in_state(state, conn, conn_state, i) {
  99                 if (!conn_state->self_refresh_aware)
 100                         goto out;
 101         }
 102
 103         crtc_state->active = false;
 104         crtc_state->self_refresh_active = true;
 105
 106         ret = drm_atomic_commit(state);
 107         if (ret)
 108                 goto out;
 109
 110 out:
 111         if (ret == -EDEADLK) {
 112                 drm_atomic_state_clear(state);
 113                 ret = drm_modeset_backoff(&ctx);
 114                 if (!ret)
 115                         goto retry;
 116         }
 117
 118         drm_atomic_state_put(state);
 119
 120 out_drop_locks:
 121         drm_modeset_drop_locks(&ctx);
 122         drm_modeset_acquire_fini(&ctx);
 123 }
 124
 125 /**
 126  * drm_self_refresh_helper_alter_state - Alters the atomic state for SR exit
 127  * @state: the state currently being checked
 128  *
 129  * Called at the end of atomic check. This function checks the state for flags
 130  * incompatible with self refresh exit and changes them. This is a bit
 131  * disingenuous since userspace is expecting one thing and we're giving it
 132  * another. However in order to keep self refresh entirely hidden from
 133  * userspace, this is required.
 134  *
 135  * At the end, we queue up the self refresh entry work so we can enter PSR after
 136  * the desired delay.
 137  */
 138 void drm_self_refresh_helper_alter_state(struct drm_atomic_state *state)
 139 {
 140         struct drm_crtc *crtc;
 141         struct drm_crtc_state *crtc_state;
 142         int i;
 143
 144         if (state->async_update || !state->allow_modeset) {
 145                 for_each_old_crtc_in_state(state, crtc, crtc_state, i) {
 146                         if (crtc_state->self_refresh_active) {
 147                                 state->async_update = false;
 148                                 state->allow_modeset = true;
 149                                 break;
 150                         }
 151                 }
 152         }
 153
 154         for_each_new_crtc_in_state(state, crtc, crtc_state, i) {
 155                 struct drm_self_refresh_data *sr_data;
 156
 157                 /* Don't trigger the entry timer when we're already in SR */
 158                 if (crtc_state->self_refresh_active)
 159                         continue;
 160
 161                 sr_data = crtc->self_refresh_data;
 162                 if (!sr_data)
 163                         continue;
 164
 165                 mod_delayed_work(system_wq, &sr_data->entry_work,
 166                                  msecs_to_jiffies(sr_data->entry_delay_ms));
 167         }
 168 }
 169 EXPORT_SYMBOL(drm_self_refresh_helper_alter_state);
 170
 171 /**
 172  * drm_self_refresh_helper_init - Initializes self refresh helpers for a crtc
 173  * @crtc: the crtc which supports self refresh supported displays
 174  * @entry_delay_ms: amount of inactivity to wait before entering self refresh
 175  *
 176  * Returns zero if successful or -errno on failure
 177  */
 178 int drm_self_refresh_helper_init(struct drm_crtc *crtc,
 179                                  unsigned int entry_delay_ms)
 180 {
 181         struct drm_self_refresh_data *sr_data = crtc->self_refresh_data;
 182
 183         /* Helper is already initialized */
 184         if (WARN_ON(sr_data))
 185                 return -EINVAL;
 186
 187         sr_data = kzalloc(sizeof(*sr_data), GFP_KERNEL);
 188         if (!sr_data)
 189                 return -ENOMEM;
 190
 191         INIT_DELAYED_WORK(&sr_data->entry_work,
 192                           drm_self_refresh_helper_entry_work);
 193         sr_data->entry_delay_ms = entry_delay_ms;
 194         sr_data->crtc = crtc;
 195
 196         crtc->self_refresh_data = sr_data;
 197         return 0;
 198 }
 199 EXPORT_SYMBOL(drm_self_refresh_helper_init);
 200
 201 /**
 202  * drm_self_refresh_helper_cleanup - Cleans up self refresh helpers for a crtc
 203  * @crtc: the crtc to cleanup
 204  */
 205 void drm_self_refresh_helper_cleanup(struct drm_crtc *crtc)
 206 {
 207         struct drm_self_refresh_data *sr_data = crtc->self_refresh_data;
 208
 209         /* Helper is already uninitialized */
 210         if (!sr_data)
 211                 return;
 212
 213         crtc->self_refresh_data = NULL;
 214
 215         cancel_delayed_work_sync(&sr_data->entry_work);
 216         kfree(sr_data);
 217 }
 218 EXPORT_SYMBOL(drm_self_refresh_helper_cleanup);