Matt Roper | c103d1c | 2014-04-01 15:22:35 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2014 Intel Corporation |
| 3 | * |
| 4 | * DRM universal plane helper functions |
| 5 | * |
| 6 | * Permission is hereby granted, free of charge, to any person obtaining a |
| 7 | * copy of this software and associated documentation files (the "Software"), |
| 8 | * to deal in the Software without restriction, including without limitation |
| 9 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, |
| 10 | * and/or sell copies of the Software, and to permit persons to whom the |
| 11 | * Software is furnished to do so, subject to the following conditions: |
| 12 | * |
| 13 | * The above copyright notice and this permission notice (including the next |
| 14 | * paragraph) shall be included in all copies or substantial portions of the |
| 15 | * Software. |
| 16 | * |
| 17 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| 18 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| 19 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
| 20 | * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| 21 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| 22 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
| 23 | * SOFTWARE. |
| 24 | */ |
| 25 | |
| 26 | #include <linux/list.h> |
| 27 | #include <drm/drmP.h> |
Matt Roper | 7daf8d5 | 2014-05-29 08:06:52 -0700 | [diff] [blame] | 28 | #include <drm/drm_plane_helper.h> |
Matt Roper | c103d1c | 2014-04-01 15:22:35 -0700 | [diff] [blame] | 29 | #include <drm/drm_rect.h> |
Daniel Vetter | 321ebf0 | 2014-11-04 22:57:27 +0100 | [diff] [blame] | 30 | #include <drm/drm_atomic.h> |
Daniel Vetter | 72fdb40 | 2018-09-05 15:57:11 +0200 | [diff] [blame] | 31 | #include <drm/drm_atomic_uapi.h> |
Daniel Vetter | acf24a3 | 2014-07-29 15:33:05 +0200 | [diff] [blame] | 32 | #include <drm/drm_crtc_helper.h> |
Laurent Pinchart | 9338203 | 2016-11-28 20:51:09 +0200 | [diff] [blame] | 33 | #include <drm/drm_encoder.h> |
Daniel Vetter | 321ebf0 | 2014-11-04 22:57:27 +0100 | [diff] [blame] | 34 | #include <drm/drm_atomic_helper.h> |
Matt Roper | c103d1c | 2014-04-01 15:22:35 -0700 | [diff] [blame] | 35 | |
| 36 | #define SUBPIXEL_MASK 0xffff |
| 37 | |
Daniel Vetter | 3150c7d | 2014-11-06 20:53:29 +0100 | [diff] [blame] | 38 | /** |
| 39 | * DOC: overview |
| 40 | * |
| 41 | * This helper library has two parts. The first part has support to implement |
| 42 | * primary plane support on top of the normal CRTC configuration interface. |
Daniel Vetter | 6806cdf | 2017-01-25 07:26:43 +0100 | [diff] [blame] | 43 | * Since the legacy &drm_mode_config_funcs.set_config interface ties the primary |
| 44 | * plane together with the CRTC state this does not allow userspace to disable |
Daniel Vetter | 6b6fce6 | 2018-10-05 11:47:32 +0200 | [diff] [blame] | 45 | * the primary plane itself. The default primary plane only expose XRBG8888 and |
| 46 | * ARGB8888 as valid pixel formats for the attached framebuffer. |
Daniel Vetter | 3150c7d | 2014-11-06 20:53:29 +0100 | [diff] [blame] | 47 | * |
| 48 | * Drivers are highly recommended to implement proper support for primary |
| 49 | * planes, and newly merged drivers must not rely upon these transitional |
| 50 | * helpers. |
| 51 | * |
| 52 | * The second part also implements transitional helpers which allow drivers to |
| 53 | * gradually switch to the atomic helper infrastructure for plane updates. Once |
| 54 | * that switch is complete drivers shouldn't use these any longer, instead using |
| 55 | * the proper legacy implementations for update and disable plane hooks provided |
| 56 | * by the atomic helpers. |
| 57 | * |
| 58 | * Again drivers are strongly urged to switch to the new interfaces. |
Daniel Vetter | 092d01d | 2015-12-04 09:45:44 +0100 | [diff] [blame] | 59 | * |
| 60 | * The plane helpers share the function table structures with other helpers, |
Daniel Vetter | ea0dd85 | 2016-12-29 21:48:26 +0100 | [diff] [blame] | 61 | * specifically also the atomic helpers. See &struct drm_plane_helper_funcs for |
Daniel Vetter | 092d01d | 2015-12-04 09:45:44 +0100 | [diff] [blame] | 62 | * the details. |
Daniel Vetter | 3150c7d | 2014-11-06 20:53:29 +0100 | [diff] [blame] | 63 | */ |
| 64 | |
Matt Roper | c103d1c | 2014-04-01 15:22:35 -0700 | [diff] [blame] | 65 | /* |
Matt Roper | c103d1c | 2014-04-01 15:22:35 -0700 | [diff] [blame] | 66 | * Returns the connectors currently associated with a CRTC. This function |
| 67 | * should be called twice: once with a NULL connector list to retrieve |
| 68 | * the list size, and once with the properly allocated list to be filled in. |
| 69 | */ |
| 70 | static int get_connectors_for_crtc(struct drm_crtc *crtc, |
| 71 | struct drm_connector **connector_list, |
| 72 | int num_connectors) |
| 73 | { |
| 74 | struct drm_device *dev = crtc->dev; |
| 75 | struct drm_connector *connector; |
Daniel Vetter | c36a325 | 2016-12-15 16:58:43 +0100 | [diff] [blame] | 76 | struct drm_connector_list_iter conn_iter; |
Matt Roper | c103d1c | 2014-04-01 15:22:35 -0700 | [diff] [blame] | 77 | int count = 0; |
| 78 | |
Daniel Vetter | 6e9f798 | 2014-05-29 23:54:47 +0200 | [diff] [blame] | 79 | /* |
| 80 | * Note: Once we change the plane hooks to more fine-grained locking we |
| 81 | * need to grab the connection_mutex here to be able to make these |
| 82 | * checks. |
| 83 | */ |
Rob Clark | 51fd371 | 2013-11-19 12:10:12 -0500 | [diff] [blame] | 84 | WARN_ON(!drm_modeset_is_locked(&dev->mode_config.connection_mutex)); |
Daniel Vetter | 6e9f798 | 2014-05-29 23:54:47 +0200 | [diff] [blame] | 85 | |
Thierry Reding | b982dab | 2017-02-28 15:46:43 +0100 | [diff] [blame] | 86 | drm_connector_list_iter_begin(dev, &conn_iter); |
Daniel Vetter | c36a325 | 2016-12-15 16:58:43 +0100 | [diff] [blame] | 87 | drm_for_each_connector_iter(connector, &conn_iter) { |
Matt Roper | c103d1c | 2014-04-01 15:22:35 -0700 | [diff] [blame] | 88 | if (connector->encoder && connector->encoder->crtc == crtc) { |
| 89 | if (connector_list != NULL && count < num_connectors) |
| 90 | *(connector_list++) = connector; |
| 91 | |
| 92 | count++; |
| 93 | } |
Daniel Vetter | 9a9f5ce | 2015-07-09 23:44:34 +0200 | [diff] [blame] | 94 | } |
Thierry Reding | b982dab | 2017-02-28 15:46:43 +0100 | [diff] [blame] | 95 | drm_connector_list_iter_end(&conn_iter); |
Matt Roper | c103d1c | 2014-04-01 15:22:35 -0700 | [diff] [blame] | 96 | |
| 97 | return count; |
| 98 | } |
| 99 | |
Daniel Vetter | 84c0851 | 2018-10-04 22:24:42 +0200 | [diff] [blame] | 100 | static int drm_plane_helper_check_update(struct drm_plane *plane, |
| 101 | struct drm_crtc *crtc, |
| 102 | struct drm_framebuffer *fb, |
| 103 | struct drm_rect *src, |
| 104 | struct drm_rect *dst, |
| 105 | unsigned int rotation, |
| 106 | int min_scale, |
| 107 | int max_scale, |
| 108 | bool can_position, |
| 109 | bool can_update_disabled, |
| 110 | bool *visible) |
Matt Roper | 7daf8d5 | 2014-05-29 08:06:52 -0700 | [diff] [blame] | 111 | { |
Ville Syrjälä | 10b47ee | 2017-11-01 22:15:58 +0200 | [diff] [blame] | 112 | struct drm_plane_state plane_state = { |
Ville Syrjälä | df86af9 | 2016-08-08 10:55:10 +0300 | [diff] [blame] | 113 | .plane = plane, |
| 114 | .crtc = crtc, |
| 115 | .fb = fb, |
| 116 | .src_x = src->x1, |
| 117 | .src_y = src->y1, |
| 118 | .src_w = drm_rect_width(src), |
| 119 | .src_h = drm_rect_height(src), |
| 120 | .crtc_x = dst->x1, |
| 121 | .crtc_y = dst->y1, |
| 122 | .crtc_w = drm_rect_width(dst), |
| 123 | .crtc_h = drm_rect_height(dst), |
| 124 | .rotation = rotation, |
| 125 | .visible = *visible, |
| 126 | }; |
Ville Syrjälä | 10b47ee | 2017-11-01 22:15:58 +0200 | [diff] [blame] | 127 | struct drm_crtc_state crtc_state = { |
| 128 | .crtc = crtc, |
| 129 | .enable = crtc->enabled, |
Ville Syrjälä | 81af63a | 2018-01-23 19:08:57 +0200 | [diff] [blame] | 130 | .mode = crtc->mode, |
Ville Syrjälä | 10b47ee | 2017-11-01 22:15:58 +0200 | [diff] [blame] | 131 | }; |
Ville Syrjälä | df86af9 | 2016-08-08 10:55:10 +0300 | [diff] [blame] | 132 | int ret; |
Matt Roper | 7daf8d5 | 2014-05-29 08:06:52 -0700 | [diff] [blame] | 133 | |
Ville Syrjälä | a01cb8b | 2017-11-01 22:16:19 +0200 | [diff] [blame] | 134 | ret = drm_atomic_helper_check_plane_state(&plane_state, &crtc_state, |
Ville Syrjälä | 81af63a | 2018-01-23 19:08:57 +0200 | [diff] [blame] | 135 | min_scale, max_scale, |
Ville Syrjälä | a01cb8b | 2017-11-01 22:16:19 +0200 | [diff] [blame] | 136 | can_position, |
| 137 | can_update_disabled); |
Ville Syrjälä | df86af9 | 2016-08-08 10:55:10 +0300 | [diff] [blame] | 138 | if (ret) |
| 139 | return ret; |
Matt Roper | 7432ca5 | 2014-12-11 07:20:57 -0800 | [diff] [blame] | 140 | |
Ville Syrjälä | 10b47ee | 2017-11-01 22:15:58 +0200 | [diff] [blame] | 141 | *src = plane_state.src; |
| 142 | *dst = plane_state.dst; |
| 143 | *visible = plane_state.visible; |
Matt Roper | 7daf8d5 | 2014-05-29 08:06:52 -0700 | [diff] [blame] | 144 | |
| 145 | return 0; |
| 146 | } |
Matt Roper | 7daf8d5 | 2014-05-29 08:06:52 -0700 | [diff] [blame] | 147 | |
Daniel Vetter | 6b6fce6 | 2018-10-05 11:47:32 +0200 | [diff] [blame] | 148 | static int drm_primary_helper_update(struct drm_plane *plane, struct drm_crtc *crtc, |
| 149 | struct drm_framebuffer *fb, |
| 150 | int crtc_x, int crtc_y, |
| 151 | unsigned int crtc_w, unsigned int crtc_h, |
| 152 | uint32_t src_x, uint32_t src_y, |
| 153 | uint32_t src_w, uint32_t src_h, |
| 154 | struct drm_modeset_acquire_ctx *ctx) |
Matt Roper | c103d1c | 2014-04-01 15:22:35 -0700 | [diff] [blame] | 155 | { |
| 156 | struct drm_mode_set set = { |
| 157 | .crtc = crtc, |
| 158 | .fb = fb, |
| 159 | .mode = &crtc->mode, |
| 160 | .x = src_x >> 16, |
| 161 | .y = src_y >> 16, |
| 162 | }; |
Matt Roper | 7daf8d5 | 2014-05-29 08:06:52 -0700 | [diff] [blame] | 163 | struct drm_rect src = { |
| 164 | .x1 = src_x, |
| 165 | .y1 = src_y, |
| 166 | .x2 = src_x + src_w, |
| 167 | .y2 = src_y + src_h, |
| 168 | }; |
Matt Roper | c103d1c | 2014-04-01 15:22:35 -0700 | [diff] [blame] | 169 | struct drm_rect dest = { |
| 170 | .x1 = crtc_x, |
| 171 | .y1 = crtc_y, |
| 172 | .x2 = crtc_x + crtc_w, |
| 173 | .y2 = crtc_y + crtc_h, |
| 174 | }; |
Matt Roper | c103d1c | 2014-04-01 15:22:35 -0700 | [diff] [blame] | 175 | struct drm_connector **connector_list; |
Matt Roper | c103d1c | 2014-04-01 15:22:35 -0700 | [diff] [blame] | 176 | int num_connectors, ret; |
Matt Roper | 7daf8d5 | 2014-05-29 08:06:52 -0700 | [diff] [blame] | 177 | bool visible; |
Matt Roper | c103d1c | 2014-04-01 15:22:35 -0700 | [diff] [blame] | 178 | |
Matt Roper | 7daf8d5 | 2014-05-29 08:06:52 -0700 | [diff] [blame] | 179 | ret = drm_plane_helper_check_update(plane, crtc, fb, |
Ville Syrjälä | 81af63a | 2018-01-23 19:08:57 +0200 | [diff] [blame] | 180 | &src, &dest, |
Robert Foss | c2c446a | 2017-05-19 16:50:17 -0400 | [diff] [blame] | 181 | DRM_MODE_ROTATE_0, |
Matt Roper | 7daf8d5 | 2014-05-29 08:06:52 -0700 | [diff] [blame] | 182 | DRM_PLANE_HELPER_NO_SCALING, |
| 183 | DRM_PLANE_HELPER_NO_SCALING, |
| 184 | false, false, &visible); |
Matt Roper | c103d1c | 2014-04-01 15:22:35 -0700 | [diff] [blame] | 185 | if (ret) |
| 186 | return ret; |
| 187 | |
Matt Roper | 7daf8d5 | 2014-05-29 08:06:52 -0700 | [diff] [blame] | 188 | if (!visible) |
| 189 | /* |
| 190 | * Primary plane isn't visible. Note that unless a driver |
| 191 | * provides their own disable function, this will just |
| 192 | * wind up returning -EINVAL to userspace. |
| 193 | */ |
Daniel Vetter | 1931529 | 2017-03-22 22:50:43 +0100 | [diff] [blame] | 194 | return plane->funcs->disable_plane(plane, ctx); |
Matt Roper | 7daf8d5 | 2014-05-29 08:06:52 -0700 | [diff] [blame] | 195 | |
Matt Roper | c103d1c | 2014-04-01 15:22:35 -0700 | [diff] [blame] | 196 | /* Find current connectors for CRTC */ |
| 197 | num_connectors = get_connectors_for_crtc(crtc, NULL, 0); |
| 198 | BUG_ON(num_connectors == 0); |
Harsha Sharma | 4b947b1c | 2017-10-13 13:07:47 +0530 | [diff] [blame] | 199 | connector_list = kcalloc(num_connectors, sizeof(*connector_list), |
Matt Roper | c103d1c | 2014-04-01 15:22:35 -0700 | [diff] [blame] | 200 | GFP_KERNEL); |
| 201 | if (!connector_list) |
| 202 | return -ENOMEM; |
| 203 | get_connectors_for_crtc(crtc, connector_list, num_connectors); |
| 204 | |
| 205 | set.connectors = connector_list; |
| 206 | set.num_connectors = num_connectors; |
| 207 | |
| 208 | /* |
Daniel Vetter | 0fe27f0 | 2014-04-23 17:34:06 +0200 | [diff] [blame] | 209 | * We call set_config() directly here rather than using |
Matt Roper | c103d1c | 2014-04-01 15:22:35 -0700 | [diff] [blame] | 210 | * drm_mode_set_config_internal. We're reprogramming the same |
| 211 | * connectors that were already in use, so we shouldn't need the extra |
| 212 | * cross-CRTC fb refcounting to accomodate stealing connectors. |
| 213 | * drm_mode_setplane() already handles the basic refcounting for the |
| 214 | * framebuffers involved in this operation. |
| 215 | */ |
Daniel Vetter | a4eff9a | 2017-03-22 22:50:57 +0100 | [diff] [blame] | 216 | ret = crtc->funcs->set_config(&set, ctx); |
Matt Roper | c103d1c | 2014-04-01 15:22:35 -0700 | [diff] [blame] | 217 | |
| 218 | kfree(connector_list); |
| 219 | return ret; |
| 220 | } |
Matt Roper | c103d1c | 2014-04-01 15:22:35 -0700 | [diff] [blame] | 221 | |
Daniel Vetter | 6b6fce6 | 2018-10-05 11:47:32 +0200 | [diff] [blame] | 222 | static int drm_primary_helper_disable(struct drm_plane *plane, |
| 223 | struct drm_modeset_acquire_ctx *ctx) |
Matt Roper | c103d1c | 2014-04-01 15:22:35 -0700 | [diff] [blame] | 224 | { |
Daniel Vetter | b6ccd7b | 2014-04-15 10:02:43 +0200 | [diff] [blame] | 225 | return -EINVAL; |
Matt Roper | c103d1c | 2014-04-01 15:22:35 -0700 | [diff] [blame] | 226 | } |
Matt Roper | c103d1c | 2014-04-01 15:22:35 -0700 | [diff] [blame] | 227 | |
| 228 | /** |
| 229 | * drm_primary_helper_destroy() - Helper for primary plane destruction |
| 230 | * @plane: plane to destroy |
| 231 | * |
| 232 | * Provides a default plane destroy handler for primary planes. This handler |
| 233 | * is called during CRTC destruction. We disable the primary plane, remove |
| 234 | * it from the DRM plane list, and deallocate the plane structure. |
| 235 | */ |
| 236 | void drm_primary_helper_destroy(struct drm_plane *plane) |
| 237 | { |
Matt Roper | c103d1c | 2014-04-01 15:22:35 -0700 | [diff] [blame] | 238 | drm_plane_cleanup(plane); |
| 239 | kfree(plane); |
| 240 | } |
| 241 | EXPORT_SYMBOL(drm_primary_helper_destroy); |
| 242 | |
| 243 | const struct drm_plane_funcs drm_primary_helper_funcs = { |
| 244 | .update_plane = drm_primary_helper_update, |
| 245 | .disable_plane = drm_primary_helper_disable, |
| 246 | .destroy = drm_primary_helper_destroy, |
| 247 | }; |
| 248 | EXPORT_SYMBOL(drm_primary_helper_funcs); |