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> 28 #include <drm/drm_rect.h> 29 30 #define SUBPIXEL_MASK 0xffff 31 32 /* 33 * This is the minimal list of formats that seem to be safe for modeset use 34 * with all current DRM drivers. Most hardware can actually support more 35 * formats than this and drivers may specify a more accurate list when 36 * creating the primary plane. However drivers that still call 37 * drm_plane_init() will use this minimal format list as the default. 38 */ 39 const static uint32_t safe_modeset_formats[] = { 40 DRM_FORMAT_XRGB8888, 41 DRM_FORMAT_ARGB8888, 42 }; 43 44 /* 45 * Returns the connectors currently associated with a CRTC. This function 46 * should be called twice: once with a NULL connector list to retrieve 47 * the list size, and once with the properly allocated list to be filled in. 48 */ 49 static int get_connectors_for_crtc(struct drm_crtc *crtc, 50 struct drm_connector **connector_list, 51 int num_connectors) 52 { 53 struct drm_device *dev = crtc->dev; 54 struct drm_connector *connector; 55 int count = 0; 56 57 list_for_each_entry(connector, &dev->mode_config.connector_list, head) 58 if (connector->encoder && connector->encoder->crtc == crtc) { 59 if (connector_list != NULL && count < num_connectors) 60 *(connector_list++) = connector; 61 62 count++; 63 } 64 65 return count; 66 } 67 68 /** 69 * drm_primary_helper_update() - Helper for primary plane update 70 * @plane: plane object to update 71 * @crtc: owning CRTC of owning plane 72 * @fb: framebuffer to flip onto plane 73 * @crtc_x: x offset of primary plane on crtc 74 * @crtc_y: y offset of primary plane on crtc 75 * @crtc_w: width of primary plane rectangle on crtc 76 * @crtc_h: height of primary plane rectangle on crtc 77 * @src_x: x offset of @fb for panning 78 * @src_y: y offset of @fb for panning 79 * @src_w: width of source rectangle in @fb 80 * @src_h: height of source rectangle in @fb 81 * 82 * Provides a default plane update handler for primary planes. This is handler 83 * is called in response to a userspace SetPlane operation on the plane with a 84 * non-NULL framebuffer. We call the driver's modeset handler to update the 85 * framebuffer. 86 * 87 * SetPlane() on a primary plane of a disabled CRTC is not supported, and will 88 * return an error. 89 * 90 * Note that we make some assumptions about hardware limitations that may not be 91 * true for all hardware -- 92 * 1) Primary plane cannot be repositioned. 93 * 2) Primary plane cannot be scaled. 94 * 3) Primary plane must cover the entire CRTC. 95 * 4) Subpixel positioning is not supported. 96 * Drivers for hardware that don't have these restrictions can provide their 97 * own implementation rather than using this helper. 98 * 99 * RETURNS: 100 * Zero on success, error code on failure 101 */ 102 int drm_primary_helper_update(struct drm_plane *plane, struct drm_crtc *crtc, 103 struct drm_framebuffer *fb, 104 int crtc_x, int crtc_y, 105 unsigned int crtc_w, unsigned int crtc_h, 106 uint32_t src_x, uint32_t src_y, 107 uint32_t src_w, uint32_t src_h) 108 { 109 struct drm_mode_set set = { 110 .crtc = crtc, 111 .fb = fb, 112 .mode = &crtc->mode, 113 .x = src_x >> 16, 114 .y = src_y >> 16, 115 }; 116 struct drm_rect dest = { 117 .x1 = crtc_x, 118 .y1 = crtc_y, 119 .x2 = crtc_x + crtc_w, 120 .y2 = crtc_y + crtc_h, 121 }; 122 struct drm_rect clip = { 123 .x2 = crtc->mode.hdisplay, 124 .y2 = crtc->mode.vdisplay, 125 }; 126 struct drm_connector **connector_list; 127 struct drm_framebuffer *tmpfb; 128 int num_connectors, ret; 129 130 if (!crtc->enabled) { 131 DRM_DEBUG_KMS("Cannot update primary plane of a disabled CRTC.\n"); 132 return -EINVAL; 133 } 134 135 /* Disallow subpixel positioning */ 136 if ((src_x | src_y | src_w | src_h) & SUBPIXEL_MASK) { 137 DRM_DEBUG_KMS("Primary plane does not support subpixel positioning\n"); 138 return -EINVAL; 139 } 140 141 /* Primary planes are locked to their owning CRTC */ 142 if (plane->possible_crtcs != drm_crtc_mask(crtc)) { 143 DRM_DEBUG_KMS("Cannot change primary plane CRTC\n"); 144 return -EINVAL; 145 } 146 147 /* Disallow scaling */ 148 if (crtc_w != src_w || crtc_h != src_h) { 149 DRM_DEBUG_KMS("Can't scale primary plane\n"); 150 return -EINVAL; 151 } 152 153 /* Make sure primary plane covers entire CRTC */ 154 drm_rect_intersect(&dest, &clip); 155 if (dest.x1 != 0 || dest.y1 != 0 || 156 dest.x2 != crtc->mode.hdisplay || dest.y2 != crtc->mode.vdisplay) { 157 DRM_DEBUG_KMS("Primary plane must cover entire CRTC\n"); 158 return -EINVAL; 159 } 160 161 /* Framebuffer must be big enough to cover entire plane */ 162 ret = drm_crtc_check_viewport(crtc, crtc_x, crtc_y, &crtc->mode, fb); 163 if (ret) 164 return ret; 165 166 /* Find current connectors for CRTC */ 167 num_connectors = get_connectors_for_crtc(crtc, NULL, 0); 168 BUG_ON(num_connectors == 0); 169 connector_list = kzalloc(num_connectors * sizeof(*connector_list), 170 GFP_KERNEL); 171 if (!connector_list) 172 return -ENOMEM; 173 get_connectors_for_crtc(crtc, connector_list, num_connectors); 174 175 set.connectors = connector_list; 176 set.num_connectors = num_connectors; 177 178 /* 179 * set_config() adjusts crtc->primary->fb; however the DRM setplane 180 * code that called us expects to handle the framebuffer update and 181 * reference counting; save and restore the current fb before 182 * calling it. 183 * 184 * N.B., we call set_config() directly here rather than using 185 * drm_mode_set_config_internal. We're reprogramming the same 186 * connectors that were already in use, so we shouldn't need the extra 187 * cross-CRTC fb refcounting to accomodate stealing connectors. 188 * drm_mode_setplane() already handles the basic refcounting for the 189 * framebuffers involved in this operation. 190 */ 191 tmpfb = plane->fb; 192 ret = crtc->funcs->set_config(&set); 193 plane->fb = tmpfb; 194 195 kfree(connector_list); 196 return ret; 197 } 198 EXPORT_SYMBOL(drm_primary_helper_update); 199 200 /** 201 * drm_primary_helper_disable() - Helper for primary plane disable 202 * @plane: plane to disable 203 * 204 * Provides a default plane disable handler for primary planes. This is handler 205 * is called in response to a userspace SetPlane operation on the plane with a 206 * NULL framebuffer parameter. We call the driver's modeset handler with a NULL 207 * framebuffer to disable the CRTC if no other planes are currently enabled. 208 * If other planes are still enabled on the same CRTC, we return -EBUSY. 209 * 210 * Note that some hardware may be able to disable the primary plane without 211 * disabling the whole CRTC. Drivers for such hardware should provide their 212 * own disable handler that disables just the primary plane (and they'll likely 213 * need to provide their own update handler as well to properly re-enable a 214 * disabled primary plane). 215 * 216 * RETURNS: 217 * Zero on success, error code on failure 218 */ 219 int drm_primary_helper_disable(struct drm_plane *plane) 220 { 221 struct drm_plane *p; 222 struct drm_mode_set set = { 223 .crtc = plane->crtc, 224 .fb = NULL, 225 }; 226 227 if (plane->crtc == NULL || plane->fb == NULL) 228 /* Already disabled */ 229 return 0; 230 231 list_for_each_entry(p, &plane->dev->mode_config.plane_list, head) 232 if (p != plane && p->fb) { 233 DRM_DEBUG_KMS("Cannot disable primary plane while other planes are still active on CRTC.\n"); 234 return -EBUSY; 235 } 236 237 /* 238 * N.B. We call set_config() directly here rather than 239 * drm_mode_set_config_internal() since drm_mode_setplane() already 240 * handles the basic refcounting and we don't need the special 241 * cross-CRTC refcounting (no chance of stealing connectors from 242 * other CRTC's with this update). 243 */ 244 return plane->crtc->funcs->set_config(&set); 245 } 246 EXPORT_SYMBOL(drm_primary_helper_disable); 247 248 /** 249 * drm_primary_helper_destroy() - Helper for primary plane destruction 250 * @plane: plane to destroy 251 * 252 * Provides a default plane destroy handler for primary planes. This handler 253 * is called during CRTC destruction. We disable the primary plane, remove 254 * it from the DRM plane list, and deallocate the plane structure. 255 */ 256 void drm_primary_helper_destroy(struct drm_plane *plane) 257 { 258 plane->funcs->disable_plane(plane); 259 drm_plane_cleanup(plane); 260 kfree(plane); 261 } 262 EXPORT_SYMBOL(drm_primary_helper_destroy); 263 264 const struct drm_plane_funcs drm_primary_helper_funcs = { 265 .update_plane = drm_primary_helper_update, 266 .disable_plane = drm_primary_helper_disable, 267 .destroy = drm_primary_helper_destroy, 268 }; 269 EXPORT_SYMBOL(drm_primary_helper_funcs); 270 271 /** 272 * drm_primary_helper_create_plane() - Create a generic primary plane 273 * @dev: drm device 274 * @formats: pixel formats supported, or NULL for a default safe list 275 * @num_formats: size of @formats; ignored if @formats is NULL 276 * 277 * Allocates and initializes a primary plane that can be used with the primary 278 * plane helpers. Drivers that wish to use driver-specific plane structures or 279 * provide custom handler functions may perform their own allocation and 280 * initialization rather than calling this function. 281 */ 282 struct drm_plane *drm_primary_helper_create_plane(struct drm_device *dev, 283 const uint32_t *formats, 284 int num_formats) 285 { 286 struct drm_plane *primary; 287 int ret; 288 289 primary = kzalloc(sizeof(*primary), GFP_KERNEL); 290 if (primary == NULL) { 291 DRM_DEBUG_KMS("Failed to allocate primary plane\n"); 292 return NULL; 293 } 294 295 if (formats == NULL) { 296 formats = safe_modeset_formats; 297 num_formats = ARRAY_SIZE(safe_modeset_formats); 298 } 299 300 /* possible_crtc's will be filled in later by crtc_init */ 301 ret = drm_plane_init(dev, primary, 0, &drm_primary_helper_funcs, 302 formats, num_formats, 303 DRM_PLANE_TYPE_PRIMARY); 304 if (ret) { 305 kfree(primary); 306 primary = NULL; 307 } 308 309 return primary; 310 } 311 EXPORT_SYMBOL(drm_primary_helper_create_plane); 312 313 /** 314 * drm_crtc_init - Legacy CRTC initialization function 315 * @dev: DRM device 316 * @crtc: CRTC object to init 317 * @funcs: callbacks for the new CRTC 318 * 319 * Initialize a CRTC object with a default helper-provided primary plane and no 320 * cursor plane. 321 * 322 * Returns: 323 * Zero on success, error code on failure. 324 */ 325 int drm_crtc_init(struct drm_device *dev, struct drm_crtc *crtc, 326 const struct drm_crtc_funcs *funcs) 327 { 328 struct drm_plane *primary; 329 330 primary = drm_primary_helper_create_plane(dev, NULL, 0); 331 return drm_crtc_init_with_planes(dev, crtc, primary, NULL, funcs); 332 } 333 EXPORT_SYMBOL(drm_crtc_init); 334