Eric Anholt | c8b75bc | 2015-03-02 13:01:12 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2015 Broadcom |
| 3 | * |
| 4 | * This program is free software; you can redistribute it and/or modify |
| 5 | * it under the terms of the GNU General Public License version 2 as |
| 6 | * published by the Free Software Foundation. |
| 7 | */ |
| 8 | |
| 9 | /** |
| 10 | * DOC: VC4 KMS |
| 11 | * |
| 12 | * This is the general code for implementing KMS mode setting that |
| 13 | * doesn't clearly associate with any of the other objects (plane, |
| 14 | * crtc, HDMI encoder). |
| 15 | */ |
| 16 | |
Masahiro Yamada | b7e8e25 | 2017-05-18 13:29:38 +0900 | [diff] [blame] | 17 | #include <drm/drm_crtc.h> |
| 18 | #include <drm/drm_atomic.h> |
| 19 | #include <drm/drm_atomic_helper.h> |
| 20 | #include <drm/drm_crtc_helper.h> |
| 21 | #include <drm/drm_plane_helper.h> |
| 22 | #include <drm/drm_fb_cma_helper.h> |
Eric Anholt | c8b75bc | 2015-03-02 13:01:12 -0800 | [diff] [blame] | 23 | #include "vc4_drv.h" |
| 24 | |
Derek Foreman | 48666d5 | 2015-07-02 11:19:54 -0500 | [diff] [blame] | 25 | static void vc4_output_poll_changed(struct drm_device *dev) |
| 26 | { |
| 27 | struct vc4_dev *vc4 = to_vc4_dev(dev); |
| 28 | |
Markus Elfring | 63fe9bb | 2016-07-15 21:15:37 +0200 | [diff] [blame] | 29 | drm_fbdev_cma_hotplug_event(vc4->fbdev); |
Derek Foreman | 48666d5 | 2015-07-02 11:19:54 -0500 | [diff] [blame] | 30 | } |
| 31 | |
Eric Anholt | b501bac | 2015-11-30 12:34:01 -0800 | [diff] [blame] | 32 | static void |
Eric Anholt | cf1b372 | 2017-06-21 11:50:01 -0700 | [diff] [blame] | 33 | vc4_atomic_complete_commit(struct drm_atomic_state *state) |
Eric Anholt | b501bac | 2015-11-30 12:34:01 -0800 | [diff] [blame] | 34 | { |
Eric Anholt | b501bac | 2015-11-30 12:34:01 -0800 | [diff] [blame] | 35 | struct drm_device *dev = state->dev; |
| 36 | struct vc4_dev *vc4 = to_vc4_dev(dev); |
| 37 | |
Boris Brezillon | 34c8ea4 | 2017-06-02 10:32:08 +0200 | [diff] [blame] | 38 | drm_atomic_helper_wait_for_fences(dev, state, false); |
| 39 | |
| 40 | drm_atomic_helper_wait_for_dependencies(state); |
| 41 | |
Eric Anholt | b501bac | 2015-11-30 12:34:01 -0800 | [diff] [blame] | 42 | drm_atomic_helper_commit_modeset_disables(dev, state); |
| 43 | |
Liu Ying | 2b58e98 | 2016-08-29 17:12:03 +0800 | [diff] [blame] | 44 | drm_atomic_helper_commit_planes(dev, state, 0); |
Eric Anholt | b501bac | 2015-11-30 12:34:01 -0800 | [diff] [blame] | 45 | |
| 46 | drm_atomic_helper_commit_modeset_enables(dev, state); |
| 47 | |
Eric Anholt | 6674a904 | 2015-12-30 11:50:22 -0800 | [diff] [blame] | 48 | /* Make sure that drm_atomic_helper_wait_for_vblanks() |
| 49 | * actually waits for vblank. If we're doing a full atomic |
| 50 | * modeset (as opposed to a vc4_update_plane() short circuit), |
| 51 | * then we need to wait for scanout to be done with our |
| 52 | * display lists before we free it and potentially reallocate |
| 53 | * and overwrite the dlist memory with a new modeset. |
| 54 | */ |
| 55 | state->legacy_cursor_update = false; |
| 56 | |
Boris Brezillon | 34c8ea4 | 2017-06-02 10:32:08 +0200 | [diff] [blame] | 57 | drm_atomic_helper_commit_hw_done(state); |
| 58 | |
Eric Anholt | b501bac | 2015-11-30 12:34:01 -0800 | [diff] [blame] | 59 | drm_atomic_helper_wait_for_vblanks(dev, state); |
| 60 | |
| 61 | drm_atomic_helper_cleanup_planes(dev, state); |
| 62 | |
Boris Brezillon | 34c8ea4 | 2017-06-02 10:32:08 +0200 | [diff] [blame] | 63 | drm_atomic_helper_commit_cleanup_done(state); |
| 64 | |
Chris Wilson | 0853695 | 2016-10-14 13:18:18 +0100 | [diff] [blame] | 65 | drm_atomic_state_put(state); |
Eric Anholt | b501bac | 2015-11-30 12:34:01 -0800 | [diff] [blame] | 66 | |
| 67 | up(&vc4->async_modeset); |
Eric Anholt | b501bac | 2015-11-30 12:34:01 -0800 | [diff] [blame] | 68 | } |
| 69 | |
Eric Anholt | cf1b372 | 2017-06-21 11:50:01 -0700 | [diff] [blame] | 70 | static void commit_work(struct work_struct *work) |
Eric Anholt | b501bac | 2015-11-30 12:34:01 -0800 | [diff] [blame] | 71 | { |
Eric Anholt | cf1b372 | 2017-06-21 11:50:01 -0700 | [diff] [blame] | 72 | struct drm_atomic_state *state = container_of(work, |
| 73 | struct drm_atomic_state, |
| 74 | commit_work); |
| 75 | vc4_atomic_complete_commit(state); |
Eric Anholt | b501bac | 2015-11-30 12:34:01 -0800 | [diff] [blame] | 76 | } |
| 77 | |
| 78 | /** |
| 79 | * vc4_atomic_commit - commit validated state object |
| 80 | * @dev: DRM device |
| 81 | * @state: the driver state object |
Maarten Lankhorst | eb63961 | 2016-04-26 16:11:44 +0200 | [diff] [blame] | 82 | * @nonblock: nonblocking commit |
Eric Anholt | b501bac | 2015-11-30 12:34:01 -0800 | [diff] [blame] | 83 | * |
| 84 | * This function commits a with drm_atomic_helper_check() pre-validated state |
| 85 | * object. This can still fail when e.g. the framebuffer reservation fails. For |
| 86 | * now this doesn't implement asynchronous commits. |
| 87 | * |
| 88 | * RETURNS |
| 89 | * Zero for success or -errno. |
| 90 | */ |
| 91 | static int vc4_atomic_commit(struct drm_device *dev, |
| 92 | struct drm_atomic_state *state, |
Maarten Lankhorst | eb63961 | 2016-04-26 16:11:44 +0200 | [diff] [blame] | 93 | bool nonblock) |
Eric Anholt | b501bac | 2015-11-30 12:34:01 -0800 | [diff] [blame] | 94 | { |
| 95 | struct vc4_dev *vc4 = to_vc4_dev(dev); |
| 96 | int ret; |
Eric Anholt | b501bac | 2015-11-30 12:34:01 -0800 | [diff] [blame] | 97 | |
Boris Brezillon | 34c8ea4 | 2017-06-02 10:32:08 +0200 | [diff] [blame] | 98 | ret = drm_atomic_helper_setup_commit(state, nonblock); |
| 99 | if (ret) |
| 100 | return ret; |
Derek Foreman | 26fc78f | 2016-11-24 12:11:55 -0600 | [diff] [blame] | 101 | |
Eric Anholt | cf1b372 | 2017-06-21 11:50:01 -0700 | [diff] [blame] | 102 | INIT_WORK(&state->commit_work, commit_work); |
| 103 | |
Derek Foreman | 26fc78f | 2016-11-24 12:11:55 -0600 | [diff] [blame] | 104 | ret = down_interruptible(&vc4->async_modeset); |
Eric Anholt | cf1b372 | 2017-06-21 11:50:01 -0700 | [diff] [blame] | 105 | if (ret) |
Derek Foreman | 26fc78f | 2016-11-24 12:11:55 -0600 | [diff] [blame] | 106 | return ret; |
Eric Anholt | b501bac | 2015-11-30 12:34:01 -0800 | [diff] [blame] | 107 | |
| 108 | ret = drm_atomic_helper_prepare_planes(dev, state); |
| 109 | if (ret) { |
Eric Anholt | b501bac | 2015-11-30 12:34:01 -0800 | [diff] [blame] | 110 | up(&vc4->async_modeset); |
| 111 | return ret; |
| 112 | } |
| 113 | |
Eric Anholt | 53ad069 | 2017-06-21 11:50:00 -0700 | [diff] [blame] | 114 | if (!nonblock) { |
| 115 | ret = drm_atomic_helper_wait_for_fences(dev, state, true); |
| 116 | if (ret) { |
| 117 | drm_atomic_helper_cleanup_planes(dev, state); |
Eric Anholt | 53ad069 | 2017-06-21 11:50:00 -0700 | [diff] [blame] | 118 | up(&vc4->async_modeset); |
| 119 | return ret; |
| 120 | } |
| 121 | } |
| 122 | |
Eric Anholt | b501bac | 2015-11-30 12:34:01 -0800 | [diff] [blame] | 123 | /* |
| 124 | * This is the point of no return - everything below never fails except |
| 125 | * when the hw goes bonghits. Which means we can commit the new state on |
| 126 | * the software side now. |
| 127 | */ |
| 128 | |
Maarten Lankhorst | d68bc0e | 2017-07-11 16:33:12 +0200 | [diff] [blame] | 129 | BUG_ON(drm_atomic_helper_swap_state(state, false) < 0); |
Eric Anholt | b501bac | 2015-11-30 12:34:01 -0800 | [diff] [blame] | 130 | |
| 131 | /* |
| 132 | * Everything below can be run asynchronously without the need to grab |
| 133 | * any modeset locks at all under one condition: It must be guaranteed |
| 134 | * that the asynchronous work has either been cancelled (if the driver |
| 135 | * supports it, which at least requires that the framebuffers get |
| 136 | * cleaned up with drm_atomic_helper_cleanup_planes()) or completed |
| 137 | * before the new state gets committed on the software side with |
| 138 | * drm_atomic_helper_swap_state(). |
| 139 | * |
| 140 | * This scheme allows new atomic state updates to be prepared and |
| 141 | * checked in parallel to the asynchronous completion of the previous |
| 142 | * update. Which is important since compositors need to figure out the |
| 143 | * composition of the next frame right after having submitted the |
| 144 | * current layout. |
| 145 | */ |
| 146 | |
Chris Wilson | 0853695 | 2016-10-14 13:18:18 +0100 | [diff] [blame] | 147 | drm_atomic_state_get(state); |
Eric Anholt | cf1b372 | 2017-06-21 11:50:01 -0700 | [diff] [blame] | 148 | if (nonblock) |
| 149 | queue_work(system_unbound_wq, &state->commit_work); |
| 150 | else |
| 151 | vc4_atomic_complete_commit(state); |
Eric Anholt | b501bac | 2015-11-30 12:34:01 -0800 | [diff] [blame] | 152 | |
| 153 | return 0; |
| 154 | } |
| 155 | |
Eric Anholt | 8375311 | 2017-06-07 17:13:36 -0700 | [diff] [blame] | 156 | static struct drm_framebuffer *vc4_fb_create(struct drm_device *dev, |
| 157 | struct drm_file *file_priv, |
| 158 | const struct drm_mode_fb_cmd2 *mode_cmd) |
| 159 | { |
| 160 | struct drm_mode_fb_cmd2 mode_cmd_local; |
| 161 | |
| 162 | /* If the user didn't specify a modifier, use the |
| 163 | * vc4_set_tiling_ioctl() state for the BO. |
| 164 | */ |
| 165 | if (!(mode_cmd->flags & DRM_MODE_FB_MODIFIERS)) { |
| 166 | struct drm_gem_object *gem_obj; |
| 167 | struct vc4_bo *bo; |
| 168 | |
| 169 | gem_obj = drm_gem_object_lookup(file_priv, |
| 170 | mode_cmd->handles[0]); |
| 171 | if (!gem_obj) { |
| 172 | DRM_ERROR("Failed to look up GEM BO %d\n", |
| 173 | mode_cmd->handles[0]); |
| 174 | return ERR_PTR(-ENOENT); |
| 175 | } |
| 176 | bo = to_vc4_bo(gem_obj); |
| 177 | |
| 178 | mode_cmd_local = *mode_cmd; |
| 179 | |
| 180 | if (bo->t_format) { |
| 181 | mode_cmd_local.modifier[0] = |
| 182 | DRM_FORMAT_MOD_BROADCOM_VC4_T_TILED; |
| 183 | } else { |
| 184 | mode_cmd_local.modifier[0] = DRM_FORMAT_MOD_NONE; |
| 185 | } |
| 186 | |
Cihangir Akturk | 1d5494e | 2017-08-03 14:58:40 +0300 | [diff] [blame^] | 187 | drm_gem_object_put_unlocked(gem_obj); |
Eric Anholt | 8375311 | 2017-06-07 17:13:36 -0700 | [diff] [blame] | 188 | |
| 189 | mode_cmd = &mode_cmd_local; |
| 190 | } |
| 191 | |
| 192 | return drm_fb_cma_create(dev, file_priv, mode_cmd); |
| 193 | } |
| 194 | |
Eric Anholt | c8b75bc | 2015-03-02 13:01:12 -0800 | [diff] [blame] | 195 | static const struct drm_mode_config_funcs vc4_mode_funcs = { |
Derek Foreman | 48666d5 | 2015-07-02 11:19:54 -0500 | [diff] [blame] | 196 | .output_poll_changed = vc4_output_poll_changed, |
Eric Anholt | c8b75bc | 2015-03-02 13:01:12 -0800 | [diff] [blame] | 197 | .atomic_check = drm_atomic_helper_check, |
Eric Anholt | b501bac | 2015-11-30 12:34:01 -0800 | [diff] [blame] | 198 | .atomic_commit = vc4_atomic_commit, |
Eric Anholt | 8375311 | 2017-06-07 17:13:36 -0700 | [diff] [blame] | 199 | .fb_create = vc4_fb_create, |
Eric Anholt | c8b75bc | 2015-03-02 13:01:12 -0800 | [diff] [blame] | 200 | }; |
| 201 | |
| 202 | int vc4_kms_load(struct drm_device *dev) |
| 203 | { |
Derek Foreman | 48666d5 | 2015-07-02 11:19:54 -0500 | [diff] [blame] | 204 | struct vc4_dev *vc4 = to_vc4_dev(dev); |
Eric Anholt | c8b75bc | 2015-03-02 13:01:12 -0800 | [diff] [blame] | 205 | int ret; |
| 206 | |
Eric Anholt | b501bac | 2015-11-30 12:34:01 -0800 | [diff] [blame] | 207 | sema_init(&vc4->async_modeset, 1); |
| 208 | |
Mario Kleiner | 7d2818f | 2017-06-22 03:28:11 +0200 | [diff] [blame] | 209 | /* Set support for vblank irq fast disable, before drm_vblank_init() */ |
| 210 | dev->vblank_disable_immediate = true; |
| 211 | |
Eric Anholt | c8b75bc | 2015-03-02 13:01:12 -0800 | [diff] [blame] | 212 | ret = drm_vblank_init(dev, dev->mode_config.num_crtc); |
| 213 | if (ret < 0) { |
| 214 | dev_err(dev->dev, "failed to initialize vblank\n"); |
| 215 | return ret; |
| 216 | } |
| 217 | |
| 218 | dev->mode_config.max_width = 2048; |
| 219 | dev->mode_config.max_height = 2048; |
| 220 | dev->mode_config.funcs = &vc4_mode_funcs; |
| 221 | dev->mode_config.preferred_depth = 24; |
Eric Anholt | b501bac | 2015-11-30 12:34:01 -0800 | [diff] [blame] | 222 | dev->mode_config.async_page_flip = true; |
| 223 | |
Eric Anholt | c8b75bc | 2015-03-02 13:01:12 -0800 | [diff] [blame] | 224 | drm_mode_config_reset(dev); |
| 225 | |
Eric Anholt | 1e70bdc | 2017-04-28 15:42:22 -0700 | [diff] [blame] | 226 | if (dev->mode_config.num_connector) { |
| 227 | vc4->fbdev = drm_fbdev_cma_init(dev, 32, |
| 228 | dev->mode_config.num_connector); |
| 229 | if (IS_ERR(vc4->fbdev)) |
| 230 | vc4->fbdev = NULL; |
| 231 | } |
Eric Anholt | c8b75bc | 2015-03-02 13:01:12 -0800 | [diff] [blame] | 232 | |
| 233 | drm_kms_helper_poll_init(dev); |
| 234 | |
| 235 | return 0; |
| 236 | } |