2777 lines · c
1/*2 * Copyright © 1997-2003 by The XFree86 Project, Inc.3 * Copyright © 2007 Dave Airlie4 * Copyright © 2007-2008 Intel Corporation5 * Jesse Barnes <jesse.barnes@intel.com>6 * Copyright 2005-2006 Luc Verhaegen7 * Copyright (c) 2001, Andy Ritger aritger@nvidia.com8 *9 * Permission is hereby granted, free of charge, to any person obtaining a10 * copy of this software and associated documentation files (the "Software"),11 * to deal in the Software without restriction, including without limitation12 * the rights to use, copy, modify, merge, publish, distribute, sublicense,13 * and/or sell copies of the Software, and to permit persons to whom the14 * Software is furnished to do so, subject to the following conditions:15 *16 * The above copyright notice and this permission notice shall be included in17 * all copies or substantial portions of the Software.18 *19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR20 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,21 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL22 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR23 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,24 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR25 * OTHER DEALINGS IN THE SOFTWARE.26 *27 * Except as contained in this notice, the name of the copyright holder(s)28 * and author(s) shall not be used in advertising or otherwise to promote29 * the sale, use or other dealings in this Software without prior written30 * authorization from the copyright holder(s) and author(s).31 */32 33#include <linux/ctype.h>34#include <linux/export.h>35#include <linux/fb.h> /* for KHZ2PICOS() */36#include <linux/list.h>37#include <linux/list_sort.h>38#include <linux/of.h>39 40#include <video/of_display_timing.h>41#include <video/of_videomode.h>42#include <video/videomode.h>43 44#include <drm/drm_crtc.h>45#include <drm/drm_device.h>46#include <drm/drm_edid.h>47#include <drm/drm_modes.h>48#include <drm/drm_print.h>49 50#include "drm_crtc_internal.h"51 52/**53 * drm_mode_debug_printmodeline - print a mode to dmesg54 * @mode: mode to print55 *56 * Describe @mode using DRM_DEBUG.57 */58void drm_mode_debug_printmodeline(const struct drm_display_mode *mode)59{60 DRM_DEBUG_KMS("Modeline " DRM_MODE_FMT "\n", DRM_MODE_ARG(mode));61}62EXPORT_SYMBOL(drm_mode_debug_printmodeline);63 64/**65 * drm_mode_create - create a new display mode66 * @dev: DRM device67 *68 * Create a new, cleared drm_display_mode with kzalloc, allocate an ID for it69 * and return it.70 *71 * Returns:72 * Pointer to new mode on success, NULL on error.73 */74struct drm_display_mode *drm_mode_create(struct drm_device *dev)75{76 struct drm_display_mode *nmode;77 78 nmode = kzalloc(sizeof(struct drm_display_mode), GFP_KERNEL);79 if (!nmode)80 return NULL;81 82 return nmode;83}84EXPORT_SYMBOL(drm_mode_create);85 86/**87 * drm_mode_destroy - remove a mode88 * @dev: DRM device89 * @mode: mode to remove90 *91 * Release @mode's unique ID, then free it @mode structure itself using kfree.92 */93void drm_mode_destroy(struct drm_device *dev, struct drm_display_mode *mode)94{95 if (!mode)96 return;97 98 kfree(mode);99}100EXPORT_SYMBOL(drm_mode_destroy);101 102/**103 * drm_mode_probed_add - add a mode to a connector's probed_mode list104 * @connector: connector the new mode105 * @mode: mode data106 *107 * Add @mode to @connector's probed_mode list for later use. This list should108 * then in a second step get filtered and all the modes actually supported by109 * the hardware moved to the @connector's modes list.110 */111void drm_mode_probed_add(struct drm_connector *connector,112 struct drm_display_mode *mode)113{114 WARN_ON(!mutex_is_locked(&connector->dev->mode_config.mutex));115 116 list_add_tail(&mode->head, &connector->probed_modes);117}118EXPORT_SYMBOL(drm_mode_probed_add);119 120enum drm_mode_analog {121 DRM_MODE_ANALOG_NTSC, /* 525 lines, 60Hz */122 DRM_MODE_ANALOG_PAL, /* 625 lines, 50Hz */123};124 125/*126 * The timings come from:127 * - https://web.archive.org/web/20220406232708/http://www.kolumbus.fi/pami1/video/pal_ntsc.html128 * - https://web.archive.org/web/20220406124914/http://martin.hinner.info/vga/pal.html129 * - https://web.archive.org/web/20220609202433/http://www.batsocks.co.uk/readme/video_timing.htm130 */131#define NTSC_LINE_DURATION_NS 63556U132#define NTSC_LINES_NUMBER 525133 134#define NTSC_HBLK_DURATION_TYP_NS 10900U135#define NTSC_HBLK_DURATION_MIN_NS (NTSC_HBLK_DURATION_TYP_NS - 200)136#define NTSC_HBLK_DURATION_MAX_NS (NTSC_HBLK_DURATION_TYP_NS + 200)137 138#define NTSC_HACT_DURATION_TYP_NS (NTSC_LINE_DURATION_NS - NTSC_HBLK_DURATION_TYP_NS)139#define NTSC_HACT_DURATION_MIN_NS (NTSC_LINE_DURATION_NS - NTSC_HBLK_DURATION_MAX_NS)140#define NTSC_HACT_DURATION_MAX_NS (NTSC_LINE_DURATION_NS - NTSC_HBLK_DURATION_MIN_NS)141 142#define NTSC_HFP_DURATION_TYP_NS 1500143#define NTSC_HFP_DURATION_MIN_NS 1270144#define NTSC_HFP_DURATION_MAX_NS 2220145 146#define NTSC_HSLEN_DURATION_TYP_NS 4700147#define NTSC_HSLEN_DURATION_MIN_NS (NTSC_HSLEN_DURATION_TYP_NS - 100)148#define NTSC_HSLEN_DURATION_MAX_NS (NTSC_HSLEN_DURATION_TYP_NS + 100)149 150#define NTSC_HBP_DURATION_TYP_NS 4700151 152/*153 * I couldn't find the actual tolerance for the back porch, so let's154 * just reuse the sync length ones.155 */156#define NTSC_HBP_DURATION_MIN_NS (NTSC_HBP_DURATION_TYP_NS - 100)157#define NTSC_HBP_DURATION_MAX_NS (NTSC_HBP_DURATION_TYP_NS + 100)158 159#define PAL_LINE_DURATION_NS 64000U160#define PAL_LINES_NUMBER 625161 162#define PAL_HACT_DURATION_TYP_NS 51950U163#define PAL_HACT_DURATION_MIN_NS (PAL_HACT_DURATION_TYP_NS - 100)164#define PAL_HACT_DURATION_MAX_NS (PAL_HACT_DURATION_TYP_NS + 400)165 166#define PAL_HBLK_DURATION_TYP_NS (PAL_LINE_DURATION_NS - PAL_HACT_DURATION_TYP_NS)167#define PAL_HBLK_DURATION_MIN_NS (PAL_LINE_DURATION_NS - PAL_HACT_DURATION_MAX_NS)168#define PAL_HBLK_DURATION_MAX_NS (PAL_LINE_DURATION_NS - PAL_HACT_DURATION_MIN_NS)169 170#define PAL_HFP_DURATION_TYP_NS 1650171#define PAL_HFP_DURATION_MIN_NS (PAL_HFP_DURATION_TYP_NS - 100)172#define PAL_HFP_DURATION_MAX_NS (PAL_HFP_DURATION_TYP_NS + 400)173 174#define PAL_HSLEN_DURATION_TYP_NS 4700175#define PAL_HSLEN_DURATION_MIN_NS (PAL_HSLEN_DURATION_TYP_NS - 200)176#define PAL_HSLEN_DURATION_MAX_NS (PAL_HSLEN_DURATION_TYP_NS + 200)177 178#define PAL_HBP_DURATION_TYP_NS 5700179#define PAL_HBP_DURATION_MIN_NS (PAL_HBP_DURATION_TYP_NS - 200)180#define PAL_HBP_DURATION_MAX_NS (PAL_HBP_DURATION_TYP_NS + 200)181 182struct analog_param_field {183 unsigned int even, odd;184};185 186#define PARAM_FIELD(_odd, _even) \187 { .even = _even, .odd = _odd }188 189struct analog_param_range {190 unsigned int min, typ, max;191};192 193#define PARAM_RANGE(_min, _typ, _max) \194 { .min = _min, .typ = _typ, .max = _max }195 196struct analog_parameters {197 unsigned int num_lines;198 unsigned int line_duration_ns;199 200 struct analog_param_range hact_ns;201 struct analog_param_range hfp_ns;202 struct analog_param_range hslen_ns;203 struct analog_param_range hbp_ns;204 struct analog_param_range hblk_ns;205 206 unsigned int bt601_hfp;207 208 struct analog_param_field vfp_lines;209 struct analog_param_field vslen_lines;210 struct analog_param_field vbp_lines;211};212 213#define TV_MODE_PARAMETER(_mode, _lines, _line_dur, _hact, _hfp, \214 _hslen, _hbp, _hblk, _bt601_hfp, _vfp, \215 _vslen, _vbp) \216 [_mode] = { \217 .num_lines = _lines, \218 .line_duration_ns = _line_dur, \219 .hact_ns = _hact, \220 .hfp_ns = _hfp, \221 .hslen_ns = _hslen, \222 .hbp_ns = _hbp, \223 .hblk_ns = _hblk, \224 .bt601_hfp = _bt601_hfp, \225 .vfp_lines = _vfp, \226 .vslen_lines = _vslen, \227 .vbp_lines = _vbp, \228 }229 230static const struct analog_parameters tv_modes_parameters[] = {231 TV_MODE_PARAMETER(DRM_MODE_ANALOG_NTSC,232 NTSC_LINES_NUMBER,233 NTSC_LINE_DURATION_NS,234 PARAM_RANGE(NTSC_HACT_DURATION_MIN_NS,235 NTSC_HACT_DURATION_TYP_NS,236 NTSC_HACT_DURATION_MAX_NS),237 PARAM_RANGE(NTSC_HFP_DURATION_MIN_NS,238 NTSC_HFP_DURATION_TYP_NS,239 NTSC_HFP_DURATION_MAX_NS),240 PARAM_RANGE(NTSC_HSLEN_DURATION_MIN_NS,241 NTSC_HSLEN_DURATION_TYP_NS,242 NTSC_HSLEN_DURATION_MAX_NS),243 PARAM_RANGE(NTSC_HBP_DURATION_MIN_NS,244 NTSC_HBP_DURATION_TYP_NS,245 NTSC_HBP_DURATION_MAX_NS),246 PARAM_RANGE(NTSC_HBLK_DURATION_MIN_NS,247 NTSC_HBLK_DURATION_TYP_NS,248 NTSC_HBLK_DURATION_MAX_NS),249 16,250 PARAM_FIELD(3, 3),251 PARAM_FIELD(3, 3),252 PARAM_FIELD(16, 17)),253 TV_MODE_PARAMETER(DRM_MODE_ANALOG_PAL,254 PAL_LINES_NUMBER,255 PAL_LINE_DURATION_NS,256 PARAM_RANGE(PAL_HACT_DURATION_MIN_NS,257 PAL_HACT_DURATION_TYP_NS,258 PAL_HACT_DURATION_MAX_NS),259 PARAM_RANGE(PAL_HFP_DURATION_MIN_NS,260 PAL_HFP_DURATION_TYP_NS,261 PAL_HFP_DURATION_MAX_NS),262 PARAM_RANGE(PAL_HSLEN_DURATION_MIN_NS,263 PAL_HSLEN_DURATION_TYP_NS,264 PAL_HSLEN_DURATION_MAX_NS),265 PARAM_RANGE(PAL_HBP_DURATION_MIN_NS,266 PAL_HBP_DURATION_TYP_NS,267 PAL_HBP_DURATION_MAX_NS),268 PARAM_RANGE(PAL_HBLK_DURATION_MIN_NS,269 PAL_HBLK_DURATION_TYP_NS,270 PAL_HBLK_DURATION_MAX_NS),271 12,272 273 /*274 * The front porch is actually 6 short sync275 * pulses for the even field, and 5 for the276 * odd field. Each sync takes half a life so277 * the odd field front porch is shorter by278 * half a line.279 *280 * In progressive, we're supposed to use 6281 * pulses, so we're fine there282 */283 PARAM_FIELD(3, 2),284 285 /*286 * The vsync length is 5 long sync pulses,287 * each field taking half a line. We're288 * shorter for both fields by half a line.289 *290 * In progressive, we're supposed to use 5291 * pulses, so we're off by half292 * a line.293 *294 * In interlace, we're now off by half a line295 * for the even field and one line for the odd296 * field.297 */298 PARAM_FIELD(3, 3),299 300 /*301 * The back porch starts with post-equalizing302 * pulses, consisting in 5 short sync pulses303 * for the even field, 4 for the odd field. In304 * progressive, it's 5 short syncs.305 *306 * In progressive, we thus have 2.5 lines,307 * plus the 0.5 line we were missing308 * previously, so we should use 3 lines.309 *310 * In interlace, the even field is in the311 * exact same case than progressive. For the312 * odd field, we should be using 2 lines but313 * we're one line short, so we'll make up for314 * it here by using 3.315 *316 * The entire blanking area is supposed to317 * take 25 lines, so we also need to account318 * for the rest of the blanking area that319 * can't be in either the front porch or sync320 * period.321 */322 PARAM_FIELD(19, 20)),323};324 325static int fill_analog_mode(struct drm_device *dev,326 struct drm_display_mode *mode,327 const struct analog_parameters *params,328 unsigned long pixel_clock_hz,329 unsigned int hactive,330 unsigned int vactive,331 bool interlace)332{333 unsigned long pixel_duration_ns = NSEC_PER_SEC / pixel_clock_hz;334 unsigned int htotal, vtotal;335 unsigned int max_hact, hact_duration_ns;336 unsigned int hblk, hblk_duration_ns;337 unsigned int hfp, hfp_duration_ns;338 unsigned int hslen, hslen_duration_ns;339 unsigned int hbp, hbp_duration_ns;340 unsigned int porches, porches_duration_ns;341 unsigned int vfp, vfp_min;342 unsigned int vbp, vbp_min;343 unsigned int vslen;344 bool bt601 = false;345 int porches_rem;346 u64 result;347 348 drm_dbg_kms(dev,349 "Generating a %ux%u%c, %u-line mode with a %lu kHz clock\n",350 hactive, vactive,351 interlace ? 'i' : 'p',352 params->num_lines,353 pixel_clock_hz / 1000);354 355 max_hact = params->hact_ns.max / pixel_duration_ns;356 if (pixel_clock_hz == 13500000 && hactive > max_hact && hactive <= 720) {357 drm_dbg_kms(dev, "Trying to generate a BT.601 mode. Disabling checks.\n");358 bt601 = true;359 }360 361 /*362 * Our pixel duration is going to be round down by the division,363 * so rounding up is probably going to introduce even more364 * deviation.365 */366 result = (u64)params->line_duration_ns * pixel_clock_hz;367 do_div(result, NSEC_PER_SEC);368 htotal = result;369 370 drm_dbg_kms(dev, "Total Horizontal Number of Pixels: %u\n", htotal);371 372 hact_duration_ns = hactive * pixel_duration_ns;373 if (!bt601 &&374 (hact_duration_ns < params->hact_ns.min ||375 hact_duration_ns > params->hact_ns.max)) {376 drm_err(dev, "Invalid horizontal active area duration: %uns (min: %u, max %u)\n",377 hact_duration_ns, params->hact_ns.min, params->hact_ns.max);378 return -EINVAL;379 }380 381 hblk = htotal - hactive;382 drm_dbg_kms(dev, "Horizontal Blanking Period: %u\n", hblk);383 384 hblk_duration_ns = hblk * pixel_duration_ns;385 if (!bt601 &&386 (hblk_duration_ns < params->hblk_ns.min ||387 hblk_duration_ns > params->hblk_ns.max)) {388 drm_err(dev, "Invalid horizontal blanking duration: %uns (min: %u, max %u)\n",389 hblk_duration_ns, params->hblk_ns.min, params->hblk_ns.max);390 return -EINVAL;391 }392 393 hslen = DIV_ROUND_UP(params->hslen_ns.typ, pixel_duration_ns);394 drm_dbg_kms(dev, "Horizontal Sync Period: %u\n", hslen);395 396 hslen_duration_ns = hslen * pixel_duration_ns;397 if (!bt601 &&398 (hslen_duration_ns < params->hslen_ns.min ||399 hslen_duration_ns > params->hslen_ns.max)) {400 drm_err(dev, "Invalid horizontal sync duration: %uns (min: %u, max %u)\n",401 hslen_duration_ns, params->hslen_ns.min, params->hslen_ns.max);402 return -EINVAL;403 }404 405 porches = hblk - hslen;406 drm_dbg_kms(dev, "Remaining horizontal pixels for both porches: %u\n", porches);407 408 porches_duration_ns = porches * pixel_duration_ns;409 if (!bt601 &&410 (porches_duration_ns > (params->hfp_ns.max + params->hbp_ns.max) ||411 porches_duration_ns < (params->hfp_ns.min + params->hbp_ns.min))) {412 drm_err(dev, "Invalid horizontal porches duration: %uns\n",413 porches_duration_ns);414 return -EINVAL;415 }416 417 if (bt601) {418 hfp = params->bt601_hfp;419 } else {420 unsigned int hfp_min = DIV_ROUND_UP(params->hfp_ns.min,421 pixel_duration_ns);422 unsigned int hbp_min = DIV_ROUND_UP(params->hbp_ns.min,423 pixel_duration_ns);424 int porches_rem = porches - hfp_min - hbp_min;425 426 hfp = hfp_min + DIV_ROUND_UP(porches_rem, 2);427 }428 429 drm_dbg_kms(dev, "Horizontal Front Porch: %u\n", hfp);430 431 hfp_duration_ns = hfp * pixel_duration_ns;432 if (!bt601 &&433 (hfp_duration_ns < params->hfp_ns.min ||434 hfp_duration_ns > params->hfp_ns.max)) {435 drm_err(dev, "Invalid horizontal front porch duration: %uns (min: %u, max %u)\n",436 hfp_duration_ns, params->hfp_ns.min, params->hfp_ns.max);437 return -EINVAL;438 }439 440 hbp = porches - hfp;441 drm_dbg_kms(dev, "Horizontal Back Porch: %u\n", hbp);442 443 hbp_duration_ns = hbp * pixel_duration_ns;444 if (!bt601 &&445 (hbp_duration_ns < params->hbp_ns.min ||446 hbp_duration_ns > params->hbp_ns.max)) {447 drm_err(dev, "Invalid horizontal back porch duration: %uns (min: %u, max %u)\n",448 hbp_duration_ns, params->hbp_ns.min, params->hbp_ns.max);449 return -EINVAL;450 }451 452 if (htotal != (hactive + hfp + hslen + hbp))453 return -EINVAL;454 455 mode->clock = pixel_clock_hz / 1000;456 mode->hdisplay = hactive;457 mode->hsync_start = mode->hdisplay + hfp;458 mode->hsync_end = mode->hsync_start + hslen;459 mode->htotal = mode->hsync_end + hbp;460 461 if (interlace) {462 vfp_min = params->vfp_lines.even + params->vfp_lines.odd;463 vbp_min = params->vbp_lines.even + params->vbp_lines.odd;464 vslen = params->vslen_lines.even + params->vslen_lines.odd;465 } else {466 /*467 * By convention, NTSC (aka 525/60) systems start with468 * the even field, but PAL (aka 625/50) systems start469 * with the odd one.470 *471 * PAL systems also have asymmetric timings between the472 * even and odd field, while NTSC is symmetric.473 *474 * Moreover, if we want to create a progressive mode for475 * PAL, we need to use the odd field timings.476 *477 * Since odd == even for NTSC, we can just use the odd478 * one all the time to simplify the code a bit.479 */480 vfp_min = params->vfp_lines.odd;481 vbp_min = params->vbp_lines.odd;482 vslen = params->vslen_lines.odd;483 }484 485 drm_dbg_kms(dev, "Vertical Sync Period: %u\n", vslen);486 487 porches = params->num_lines - vactive - vslen;488 drm_dbg_kms(dev, "Remaining vertical pixels for both porches: %u\n", porches);489 490 porches_rem = porches - vfp_min - vbp_min;491 vfp = vfp_min + (porches_rem / 2);492 drm_dbg_kms(dev, "Vertical Front Porch: %u\n", vfp);493 494 vbp = porches - vfp;495 drm_dbg_kms(dev, "Vertical Back Porch: %u\n", vbp);496 497 vtotal = vactive + vfp + vslen + vbp;498 if (params->num_lines != vtotal) {499 drm_err(dev, "Invalid vertical total: %upx (expected %upx)\n",500 vtotal, params->num_lines);501 return -EINVAL;502 }503 504 mode->vdisplay = vactive;505 mode->vsync_start = mode->vdisplay + vfp;506 mode->vsync_end = mode->vsync_start + vslen;507 mode->vtotal = mode->vsync_end + vbp;508 509 if (mode->vtotal != params->num_lines)510 return -EINVAL;511 512 mode->type = DRM_MODE_TYPE_DRIVER;513 mode->flags = DRM_MODE_FLAG_NVSYNC | DRM_MODE_FLAG_NHSYNC;514 if (interlace)515 mode->flags |= DRM_MODE_FLAG_INTERLACE;516 517 drm_mode_set_name(mode);518 519 drm_dbg_kms(dev, "Generated mode " DRM_MODE_FMT "\n", DRM_MODE_ARG(mode));520 521 return 0;522}523 524/**525 * drm_analog_tv_mode - create a display mode for an analog TV526 * @dev: drm device527 * @tv_mode: TV Mode standard to create a mode for. See DRM_MODE_TV_MODE_*.528 * @pixel_clock_hz: Pixel Clock Frequency, in Hertz529 * @hdisplay: hdisplay size530 * @vdisplay: vdisplay size531 * @interlace: whether to compute an interlaced mode532 *533 * This function creates a struct drm_display_mode instance suited for534 * an analog TV output, for one of the usual analog TV modes. Where535 * this is DRM_MODE_TV_MODE_MONOCHROME, a 625-line mode will be created.536 *537 * Note that @hdisplay is larger than the usual constraints for the PAL538 * and NTSC timings, and we'll choose to ignore most timings constraints539 * to reach those resolutions.540 *541 * Returns:542 * A pointer to the mode, allocated with drm_mode_create(). Returns NULL543 * on error.544 */545struct drm_display_mode *drm_analog_tv_mode(struct drm_device *dev,546 enum drm_connector_tv_mode tv_mode,547 unsigned long pixel_clock_hz,548 unsigned int hdisplay,549 unsigned int vdisplay,550 bool interlace)551{552 struct drm_display_mode *mode;553 enum drm_mode_analog analog;554 int ret;555 556 switch (tv_mode) {557 case DRM_MODE_TV_MODE_NTSC:558 fallthrough;559 case DRM_MODE_TV_MODE_NTSC_443:560 fallthrough;561 case DRM_MODE_TV_MODE_NTSC_J:562 fallthrough;563 case DRM_MODE_TV_MODE_PAL_M:564 analog = DRM_MODE_ANALOG_NTSC;565 break;566 567 case DRM_MODE_TV_MODE_PAL:568 fallthrough;569 case DRM_MODE_TV_MODE_PAL_N:570 fallthrough;571 case DRM_MODE_TV_MODE_SECAM:572 fallthrough;573 case DRM_MODE_TV_MODE_MONOCHROME:574 analog = DRM_MODE_ANALOG_PAL;575 break;576 577 default:578 return NULL;579 }580 581 mode = drm_mode_create(dev);582 if (!mode)583 return NULL;584 585 ret = fill_analog_mode(dev, mode,586 &tv_modes_parameters[analog],587 pixel_clock_hz, hdisplay, vdisplay, interlace);588 if (ret)589 goto err_free_mode;590 591 return mode;592 593err_free_mode:594 drm_mode_destroy(dev, mode);595 return NULL;596}597EXPORT_SYMBOL(drm_analog_tv_mode);598 599/**600 * drm_cvt_mode -create a modeline based on the CVT algorithm601 * @dev: drm device602 * @hdisplay: hdisplay size603 * @vdisplay: vdisplay size604 * @vrefresh: vrefresh rate605 * @reduced: whether to use reduced blanking606 * @interlaced: whether to compute an interlaced mode607 * @margins: whether to add margins (borders)608 *609 * This function is called to generate the modeline based on CVT algorithm610 * according to the hdisplay, vdisplay, vrefresh.611 * It is based from the VESA(TM) Coordinated Video Timing Generator by612 * Graham Loveridge April 9, 2003 available at613 * http://www.elo.utfsm.cl/~elo212/docs/CVTd6r1.xls614 *615 * And it is copied from xf86CVTmode in xserver/hw/xfree86/modes/xf86cvt.c.616 * What I have done is to translate it by using integer calculation.617 *618 * Returns:619 * The modeline based on the CVT algorithm stored in a drm_display_mode object.620 * The display mode object is allocated with drm_mode_create(). Returns NULL621 * when no mode could be allocated.622 */623struct drm_display_mode *drm_cvt_mode(struct drm_device *dev, int hdisplay,624 int vdisplay, int vrefresh,625 bool reduced, bool interlaced, bool margins)626{627#define HV_FACTOR 1000628 /* 1) top/bottom margin size (% of height) - default: 1.8, */629#define CVT_MARGIN_PERCENTAGE 18630 /* 2) character cell horizontal granularity (pixels) - default 8 */631#define CVT_H_GRANULARITY 8632 /* 3) Minimum vertical porch (lines) - default 3 */633#define CVT_MIN_V_PORCH 3634 /* 4) Minimum number of vertical back porch lines - default 6 */635#define CVT_MIN_V_BPORCH 6636 /* Pixel Clock step (kHz) */637#define CVT_CLOCK_STEP 250638 struct drm_display_mode *drm_mode;639 unsigned int vfieldrate, hperiod;640 int hdisplay_rnd, hmargin, vdisplay_rnd, vmargin, vsync;641 int interlace;642 u64 tmp;643 644 if (!hdisplay || !vdisplay)645 return NULL;646 647 /* allocate the drm_display_mode structure. If failure, we will648 * return directly649 */650 drm_mode = drm_mode_create(dev);651 if (!drm_mode)652 return NULL;653 654 /* the CVT default refresh rate is 60Hz */655 if (!vrefresh)656 vrefresh = 60;657 658 /* the required field fresh rate */659 if (interlaced)660 vfieldrate = vrefresh * 2;661 else662 vfieldrate = vrefresh;663 664 /* horizontal pixels */665 hdisplay_rnd = hdisplay - (hdisplay % CVT_H_GRANULARITY);666 667 /* determine the left&right borders */668 hmargin = 0;669 if (margins) {670 hmargin = hdisplay_rnd * CVT_MARGIN_PERCENTAGE / 1000;671 hmargin -= hmargin % CVT_H_GRANULARITY;672 }673 /* find the total active pixels */674 drm_mode->hdisplay = hdisplay_rnd + 2 * hmargin;675 676 /* find the number of lines per field */677 if (interlaced)678 vdisplay_rnd = vdisplay / 2;679 else680 vdisplay_rnd = vdisplay;681 682 /* find the top & bottom borders */683 vmargin = 0;684 if (margins)685 vmargin = vdisplay_rnd * CVT_MARGIN_PERCENTAGE / 1000;686 687 drm_mode->vdisplay = vdisplay + 2 * vmargin;688 689 /* Interlaced */690 if (interlaced)691 interlace = 1;692 else693 interlace = 0;694 695 /* Determine VSync Width from aspect ratio */696 if (!(vdisplay % 3) && ((vdisplay * 4 / 3) == hdisplay))697 vsync = 4;698 else if (!(vdisplay % 9) && ((vdisplay * 16 / 9) == hdisplay))699 vsync = 5;700 else if (!(vdisplay % 10) && ((vdisplay * 16 / 10) == hdisplay))701 vsync = 6;702 else if (!(vdisplay % 4) && ((vdisplay * 5 / 4) == hdisplay))703 vsync = 7;704 else if (!(vdisplay % 9) && ((vdisplay * 15 / 9) == hdisplay))705 vsync = 7;706 else /* custom */707 vsync = 10;708 709 if (!reduced) {710 /* simplify the GTF calculation */711 /* 4) Minimum time of vertical sync + back porch interval (µs)712 * default 550.0713 */714 int tmp1, tmp2;715#define CVT_MIN_VSYNC_BP 550716 /* 3) Nominal HSync width (% of line period) - default 8 */717#define CVT_HSYNC_PERCENTAGE 8718 unsigned int hblank_percentage;719 int vsyncandback_porch, __maybe_unused vback_porch, hblank;720 721 /* estimated the horizontal period */722 tmp1 = HV_FACTOR * 1000000 -723 CVT_MIN_VSYNC_BP * HV_FACTOR * vfieldrate;724 tmp2 = (vdisplay_rnd + 2 * vmargin + CVT_MIN_V_PORCH) * 2 +725 interlace;726 hperiod = tmp1 * 2 / (tmp2 * vfieldrate);727 728 tmp1 = CVT_MIN_VSYNC_BP * HV_FACTOR / hperiod + 1;729 /* 9. Find number of lines in sync + backporch */730 if (tmp1 < (vsync + CVT_MIN_V_PORCH))731 vsyncandback_porch = vsync + CVT_MIN_V_PORCH;732 else733 vsyncandback_porch = tmp1;734 /* 10. Find number of lines in back porch */735 vback_porch = vsyncandback_porch - vsync;736 drm_mode->vtotal = vdisplay_rnd + 2 * vmargin +737 vsyncandback_porch + CVT_MIN_V_PORCH;738 /* 5) Definition of Horizontal blanking time limitation */739 /* Gradient (%/kHz) - default 600 */740#define CVT_M_FACTOR 600741 /* Offset (%) - default 40 */742#define CVT_C_FACTOR 40743 /* Blanking time scaling factor - default 128 */744#define CVT_K_FACTOR 128745 /* Scaling factor weighting - default 20 */746#define CVT_J_FACTOR 20747#define CVT_M_PRIME (CVT_M_FACTOR * CVT_K_FACTOR / 256)748#define CVT_C_PRIME ((CVT_C_FACTOR - CVT_J_FACTOR) * CVT_K_FACTOR / 256 + \749 CVT_J_FACTOR)750 /* 12. Find ideal blanking duty cycle from formula */751 hblank_percentage = CVT_C_PRIME * HV_FACTOR - CVT_M_PRIME *752 hperiod / 1000;753 /* 13. Blanking time */754 if (hblank_percentage < 20 * HV_FACTOR)755 hblank_percentage = 20 * HV_FACTOR;756 hblank = drm_mode->hdisplay * hblank_percentage /757 (100 * HV_FACTOR - hblank_percentage);758 hblank -= hblank % (2 * CVT_H_GRANULARITY);759 /* 14. find the total pixels per line */760 drm_mode->htotal = drm_mode->hdisplay + hblank;761 drm_mode->hsync_end = drm_mode->hdisplay + hblank / 2;762 drm_mode->hsync_start = drm_mode->hsync_end -763 (drm_mode->htotal * CVT_HSYNC_PERCENTAGE) / 100;764 drm_mode->hsync_start += CVT_H_GRANULARITY -765 drm_mode->hsync_start % CVT_H_GRANULARITY;766 /* fill the Vsync values */767 drm_mode->vsync_start = drm_mode->vdisplay + CVT_MIN_V_PORCH;768 drm_mode->vsync_end = drm_mode->vsync_start + vsync;769 } else {770 /* Reduced blanking */771 /* Minimum vertical blanking interval time (µs)- default 460 */772#define CVT_RB_MIN_VBLANK 460773 /* Fixed number of clocks for horizontal sync */774#define CVT_RB_H_SYNC 32775 /* Fixed number of clocks for horizontal blanking */776#define CVT_RB_H_BLANK 160777 /* Fixed number of lines for vertical front porch - default 3*/778#define CVT_RB_VFPORCH 3779 int vbilines;780 int tmp1, tmp2;781 /* 8. Estimate Horizontal period. */782 tmp1 = HV_FACTOR * 1000000 -783 CVT_RB_MIN_VBLANK * HV_FACTOR * vfieldrate;784 tmp2 = vdisplay_rnd + 2 * vmargin;785 hperiod = tmp1 / (tmp2 * vfieldrate);786 /* 9. Find number of lines in vertical blanking */787 vbilines = CVT_RB_MIN_VBLANK * HV_FACTOR / hperiod + 1;788 /* 10. Check if vertical blanking is sufficient */789 if (vbilines < (CVT_RB_VFPORCH + vsync + CVT_MIN_V_BPORCH))790 vbilines = CVT_RB_VFPORCH + vsync + CVT_MIN_V_BPORCH;791 /* 11. Find total number of lines in vertical field */792 drm_mode->vtotal = vdisplay_rnd + 2 * vmargin + vbilines;793 /* 12. Find total number of pixels in a line */794 drm_mode->htotal = drm_mode->hdisplay + CVT_RB_H_BLANK;795 /* Fill in HSync values */796 drm_mode->hsync_end = drm_mode->hdisplay + CVT_RB_H_BLANK / 2;797 drm_mode->hsync_start = drm_mode->hsync_end - CVT_RB_H_SYNC;798 /* Fill in VSync values */799 drm_mode->vsync_start = drm_mode->vdisplay + CVT_RB_VFPORCH;800 drm_mode->vsync_end = drm_mode->vsync_start + vsync;801 }802 /* 15/13. Find pixel clock frequency (kHz for xf86) */803 tmp = drm_mode->htotal; /* perform intermediate calcs in u64 */804 tmp *= HV_FACTOR * 1000;805 do_div(tmp, hperiod);806 tmp -= drm_mode->clock % CVT_CLOCK_STEP;807 drm_mode->clock = tmp;808 /* 18/16. Find actual vertical frame frequency */809 /* ignore - just set the mode flag for interlaced */810 if (interlaced) {811 drm_mode->vtotal *= 2;812 drm_mode->flags |= DRM_MODE_FLAG_INTERLACE;813 }814 /* Fill the mode line name */815 drm_mode_set_name(drm_mode);816 if (reduced)817 drm_mode->flags |= (DRM_MODE_FLAG_PHSYNC |818 DRM_MODE_FLAG_NVSYNC);819 else820 drm_mode->flags |= (DRM_MODE_FLAG_PVSYNC |821 DRM_MODE_FLAG_NHSYNC);822 823 return drm_mode;824}825EXPORT_SYMBOL(drm_cvt_mode);826 827/**828 * drm_gtf_mode_complex - create the modeline based on the full GTF algorithm829 * @dev: drm device830 * @hdisplay: hdisplay size831 * @vdisplay: vdisplay size832 * @vrefresh: vrefresh rate.833 * @interlaced: whether to compute an interlaced mode834 * @margins: desired margin (borders) size835 * @GTF_M: extended GTF formula parameters836 * @GTF_2C: extended GTF formula parameters837 * @GTF_K: extended GTF formula parameters838 * @GTF_2J: extended GTF formula parameters839 *840 * GTF feature blocks specify C and J in multiples of 0.5, so we pass them841 * in here multiplied by two. For a C of 40, pass in 80.842 *843 * Returns:844 * The modeline based on the full GTF algorithm stored in a drm_display_mode object.845 * The display mode object is allocated with drm_mode_create(). Returns NULL846 * when no mode could be allocated.847 */848struct drm_display_mode *849drm_gtf_mode_complex(struct drm_device *dev, int hdisplay, int vdisplay,850 int vrefresh, bool interlaced, int margins,851 int GTF_M, int GTF_2C, int GTF_K, int GTF_2J)852{ /* 1) top/bottom margin size (% of height) - default: 1.8, */853#define GTF_MARGIN_PERCENTAGE 18854 /* 2) character cell horizontal granularity (pixels) - default 8 */855#define GTF_CELL_GRAN 8856 /* 3) Minimum vertical porch (lines) - default 3 */857#define GTF_MIN_V_PORCH 1858 /* width of vsync in lines */859#define V_SYNC_RQD 3860 /* width of hsync as % of total line */861#define H_SYNC_PERCENT 8862 /* min time of vsync + back porch (microsec) */863#define MIN_VSYNC_PLUS_BP 550864 /* C' and M' are part of the Blanking Duty Cycle computation */865#define GTF_C_PRIME ((((GTF_2C - GTF_2J) * GTF_K / 256) + GTF_2J) / 2)866#define GTF_M_PRIME (GTF_K * GTF_M / 256)867 struct drm_display_mode *drm_mode;868 unsigned int hdisplay_rnd, vdisplay_rnd, vfieldrate_rqd;869 int top_margin, bottom_margin;870 int interlace;871 unsigned int hfreq_est;872 int vsync_plus_bp, __maybe_unused vback_porch;873 unsigned int vtotal_lines, __maybe_unused vfieldrate_est;874 unsigned int __maybe_unused hperiod;875 unsigned int vfield_rate, __maybe_unused vframe_rate;876 int left_margin, right_margin;877 unsigned int total_active_pixels, ideal_duty_cycle;878 unsigned int hblank, total_pixels, pixel_freq;879 int hsync, hfront_porch, vodd_front_porch_lines;880 unsigned int tmp1, tmp2;881 882 if (!hdisplay || !vdisplay)883 return NULL;884 885 drm_mode = drm_mode_create(dev);886 if (!drm_mode)887 return NULL;888 889 /* 1. In order to give correct results, the number of horizontal890 * pixels requested is first processed to ensure that it is divisible891 * by the character size, by rounding it to the nearest character892 * cell boundary:893 */894 hdisplay_rnd = (hdisplay + GTF_CELL_GRAN / 2) / GTF_CELL_GRAN;895 hdisplay_rnd = hdisplay_rnd * GTF_CELL_GRAN;896 897 /* 2. If interlace is requested, the number of vertical lines assumed898 * by the calculation must be halved, as the computation calculates899 * the number of vertical lines per field.900 */901 if (interlaced)902 vdisplay_rnd = vdisplay / 2;903 else904 vdisplay_rnd = vdisplay;905 906 /* 3. Find the frame rate required: */907 if (interlaced)908 vfieldrate_rqd = vrefresh * 2;909 else910 vfieldrate_rqd = vrefresh;911 912 /* 4. Find number of lines in Top margin: */913 top_margin = 0;914 if (margins)915 top_margin = (vdisplay_rnd * GTF_MARGIN_PERCENTAGE + 500) /916 1000;917 /* 5. Find number of lines in bottom margin: */918 bottom_margin = top_margin;919 920 /* 6. If interlace is required, then set variable interlace: */921 if (interlaced)922 interlace = 1;923 else924 interlace = 0;925 926 /* 7. Estimate the Horizontal frequency */927 {928 tmp1 = (1000000 - MIN_VSYNC_PLUS_BP * vfieldrate_rqd) / 500;929 tmp2 = (vdisplay_rnd + 2 * top_margin + GTF_MIN_V_PORCH) *930 2 + interlace;931 hfreq_est = (tmp2 * 1000 * vfieldrate_rqd) / tmp1;932 }933 934 /* 8. Find the number of lines in V sync + back porch */935 /* [V SYNC+BP] = RINT(([MIN VSYNC+BP] * hfreq_est / 1000000)) */936 vsync_plus_bp = MIN_VSYNC_PLUS_BP * hfreq_est / 1000;937 vsync_plus_bp = (vsync_plus_bp + 500) / 1000;938 /* 9. Find the number of lines in V back porch alone: */939 vback_porch = vsync_plus_bp - V_SYNC_RQD;940 /* 10. Find the total number of lines in Vertical field period: */941 vtotal_lines = vdisplay_rnd + top_margin + bottom_margin +942 vsync_plus_bp + GTF_MIN_V_PORCH;943 /* 11. Estimate the Vertical field frequency: */944 vfieldrate_est = hfreq_est / vtotal_lines;945 /* 12. Find the actual horizontal period: */946 hperiod = 1000000 / (vfieldrate_rqd * vtotal_lines);947 948 /* 13. Find the actual Vertical field frequency: */949 vfield_rate = hfreq_est / vtotal_lines;950 /* 14. Find the Vertical frame frequency: */951 if (interlaced)952 vframe_rate = vfield_rate / 2;953 else954 vframe_rate = vfield_rate;955 /* 15. Find number of pixels in left margin: */956 if (margins)957 left_margin = (hdisplay_rnd * GTF_MARGIN_PERCENTAGE + 500) /958 1000;959 else960 left_margin = 0;961 962 /* 16.Find number of pixels in right margin: */963 right_margin = left_margin;964 /* 17.Find total number of active pixels in image and left and right */965 total_active_pixels = hdisplay_rnd + left_margin + right_margin;966 /* 18.Find the ideal blanking duty cycle from blanking duty cycle */967 ideal_duty_cycle = GTF_C_PRIME * 1000 -968 (GTF_M_PRIME * 1000000 / hfreq_est);969 /* 19.Find the number of pixels in the blanking time to the nearest970 * double character cell: */971 hblank = total_active_pixels * ideal_duty_cycle /972 (100000 - ideal_duty_cycle);973 hblank = (hblank + GTF_CELL_GRAN) / (2 * GTF_CELL_GRAN);974 hblank = hblank * 2 * GTF_CELL_GRAN;975 /* 20.Find total number of pixels: */976 total_pixels = total_active_pixels + hblank;977 /* 21.Find pixel clock frequency: */978 pixel_freq = total_pixels * hfreq_est / 1000;979 /* Stage 1 computations are now complete; I should really pass980 * the results to another function and do the Stage 2 computations,981 * but I only need a few more values so I'll just append the982 * computations here for now */983 /* 17. Find the number of pixels in the horizontal sync period: */984 hsync = H_SYNC_PERCENT * total_pixels / 100;985 hsync = (hsync + GTF_CELL_GRAN / 2) / GTF_CELL_GRAN;986 hsync = hsync * GTF_CELL_GRAN;987 /* 18. Find the number of pixels in horizontal front porch period */988 hfront_porch = hblank / 2 - hsync;989 /* 36. Find the number of lines in the odd front porch period: */990 vodd_front_porch_lines = GTF_MIN_V_PORCH ;991 992 /* finally, pack the results in the mode struct */993 drm_mode->hdisplay = hdisplay_rnd;994 drm_mode->hsync_start = hdisplay_rnd + hfront_porch;995 drm_mode->hsync_end = drm_mode->hsync_start + hsync;996 drm_mode->htotal = total_pixels;997 drm_mode->vdisplay = vdisplay_rnd;998 drm_mode->vsync_start = vdisplay_rnd + vodd_front_porch_lines;999 drm_mode->vsync_end = drm_mode->vsync_start + V_SYNC_RQD;1000 drm_mode->vtotal = vtotal_lines;1001 1002 drm_mode->clock = pixel_freq;1003 1004 if (interlaced) {1005 drm_mode->vtotal *= 2;1006 drm_mode->flags |= DRM_MODE_FLAG_INTERLACE;1007 }1008 1009 drm_mode_set_name(drm_mode);1010 if (GTF_M == 600 && GTF_2C == 80 && GTF_K == 128 && GTF_2J == 40)1011 drm_mode->flags = DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC;1012 else1013 drm_mode->flags = DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_NVSYNC;1014 1015 return drm_mode;1016}1017EXPORT_SYMBOL(drm_gtf_mode_complex);1018 1019/**1020 * drm_gtf_mode - create the modeline based on the GTF algorithm1021 * @dev: drm device1022 * @hdisplay: hdisplay size1023 * @vdisplay: vdisplay size1024 * @vrefresh: vrefresh rate.1025 * @interlaced: whether to compute an interlaced mode1026 * @margins: desired margin (borders) size1027 *1028 * return the modeline based on GTF algorithm1029 *1030 * This function is to create the modeline based on the GTF algorithm.1031 * Generalized Timing Formula is derived from:1032 *1033 * GTF Spreadsheet by Andy Morrish (1/5/97)1034 * available at https://www.vesa.org1035 *1036 * And it is copied from the file of xserver/hw/xfree86/modes/xf86gtf.c.1037 * What I have done is to translate it by using integer calculation.1038 * I also refer to the function of fb_get_mode in the file of1039 * drivers/video/fbmon.c1040 *1041 * Standard GTF parameters::1042 *1043 * M = 6001044 * C = 401045 * K = 1281046 * J = 201047 *1048 * Returns:1049 * The modeline based on the GTF algorithm stored in a drm_display_mode object.1050 * The display mode object is allocated with drm_mode_create(). Returns NULL1051 * when no mode could be allocated.1052 */1053struct drm_display_mode *1054drm_gtf_mode(struct drm_device *dev, int hdisplay, int vdisplay, int vrefresh,1055 bool interlaced, int margins)1056{1057 return drm_gtf_mode_complex(dev, hdisplay, vdisplay, vrefresh,1058 interlaced, margins,1059 600, 40 * 2, 128, 20 * 2);1060}1061EXPORT_SYMBOL(drm_gtf_mode);1062 1063#ifdef CONFIG_VIDEOMODE_HELPERS1064/**1065 * drm_display_mode_from_videomode - fill in @dmode using @vm,1066 * @vm: videomode structure to use as source1067 * @dmode: drm_display_mode structure to use as destination1068 *1069 * Fills out @dmode using the display mode specified in @vm.1070 */1071void drm_display_mode_from_videomode(const struct videomode *vm,1072 struct drm_display_mode *dmode)1073{1074 dmode->hdisplay = vm->hactive;1075 dmode->hsync_start = dmode->hdisplay + vm->hfront_porch;1076 dmode->hsync_end = dmode->hsync_start + vm->hsync_len;1077 dmode->htotal = dmode->hsync_end + vm->hback_porch;1078 1079 dmode->vdisplay = vm->vactive;1080 dmode->vsync_start = dmode->vdisplay + vm->vfront_porch;1081 dmode->vsync_end = dmode->vsync_start + vm->vsync_len;1082 dmode->vtotal = dmode->vsync_end + vm->vback_porch;1083 1084 dmode->clock = vm->pixelclock / 1000;1085 1086 dmode->flags = 0;1087 if (vm->flags & DISPLAY_FLAGS_HSYNC_HIGH)1088 dmode->flags |= DRM_MODE_FLAG_PHSYNC;1089 else if (vm->flags & DISPLAY_FLAGS_HSYNC_LOW)1090 dmode->flags |= DRM_MODE_FLAG_NHSYNC;1091 if (vm->flags & DISPLAY_FLAGS_VSYNC_HIGH)1092 dmode->flags |= DRM_MODE_FLAG_PVSYNC;1093 else if (vm->flags & DISPLAY_FLAGS_VSYNC_LOW)1094 dmode->flags |= DRM_MODE_FLAG_NVSYNC;1095 if (vm->flags & DISPLAY_FLAGS_INTERLACED)1096 dmode->flags |= DRM_MODE_FLAG_INTERLACE;1097 if (vm->flags & DISPLAY_FLAGS_DOUBLESCAN)1098 dmode->flags |= DRM_MODE_FLAG_DBLSCAN;1099 if (vm->flags & DISPLAY_FLAGS_DOUBLECLK)1100 dmode->flags |= DRM_MODE_FLAG_DBLCLK;1101 drm_mode_set_name(dmode);1102}1103EXPORT_SYMBOL_GPL(drm_display_mode_from_videomode);1104 1105/**1106 * drm_display_mode_to_videomode - fill in @vm using @dmode,1107 * @dmode: drm_display_mode structure to use as source1108 * @vm: videomode structure to use as destination1109 *1110 * Fills out @vm using the display mode specified in @dmode.1111 */1112void drm_display_mode_to_videomode(const struct drm_display_mode *dmode,1113 struct videomode *vm)1114{1115 vm->hactive = dmode->hdisplay;1116 vm->hfront_porch = dmode->hsync_start - dmode->hdisplay;1117 vm->hsync_len = dmode->hsync_end - dmode->hsync_start;1118 vm->hback_porch = dmode->htotal - dmode->hsync_end;1119 1120 vm->vactive = dmode->vdisplay;1121 vm->vfront_porch = dmode->vsync_start - dmode->vdisplay;1122 vm->vsync_len = dmode->vsync_end - dmode->vsync_start;1123 vm->vback_porch = dmode->vtotal - dmode->vsync_end;1124 1125 vm->pixelclock = dmode->clock * 1000;1126 1127 vm->flags = 0;1128 if (dmode->flags & DRM_MODE_FLAG_PHSYNC)1129 vm->flags |= DISPLAY_FLAGS_HSYNC_HIGH;1130 else if (dmode->flags & DRM_MODE_FLAG_NHSYNC)1131 vm->flags |= DISPLAY_FLAGS_HSYNC_LOW;1132 if (dmode->flags & DRM_MODE_FLAG_PVSYNC)1133 vm->flags |= DISPLAY_FLAGS_VSYNC_HIGH;1134 else if (dmode->flags & DRM_MODE_FLAG_NVSYNC)1135 vm->flags |= DISPLAY_FLAGS_VSYNC_LOW;1136 if (dmode->flags & DRM_MODE_FLAG_INTERLACE)1137 vm->flags |= DISPLAY_FLAGS_INTERLACED;1138 if (dmode->flags & DRM_MODE_FLAG_DBLSCAN)1139 vm->flags |= DISPLAY_FLAGS_DOUBLESCAN;1140 if (dmode->flags & DRM_MODE_FLAG_DBLCLK)1141 vm->flags |= DISPLAY_FLAGS_DOUBLECLK;1142}1143EXPORT_SYMBOL_GPL(drm_display_mode_to_videomode);1144 1145/**1146 * drm_bus_flags_from_videomode - extract information about pixelclk and1147 * DE polarity from videomode and store it in a separate variable1148 * @vm: videomode structure to use1149 * @bus_flags: information about pixelclk, sync and DE polarity will be stored1150 * here1151 *1152 * Sets DRM_BUS_FLAG_DE_(LOW|HIGH), DRM_BUS_FLAG_PIXDATA_DRIVE_(POS|NEG)EDGE1153 * and DISPLAY_FLAGS_SYNC_(POS|NEG)EDGE in @bus_flags according to DISPLAY_FLAGS1154 * found in @vm1155 */1156void drm_bus_flags_from_videomode(const struct videomode *vm, u32 *bus_flags)1157{1158 *bus_flags = 0;1159 if (vm->flags & DISPLAY_FLAGS_PIXDATA_POSEDGE)1160 *bus_flags |= DRM_BUS_FLAG_PIXDATA_DRIVE_POSEDGE;1161 if (vm->flags & DISPLAY_FLAGS_PIXDATA_NEGEDGE)1162 *bus_flags |= DRM_BUS_FLAG_PIXDATA_DRIVE_NEGEDGE;1163 1164 if (vm->flags & DISPLAY_FLAGS_SYNC_POSEDGE)1165 *bus_flags |= DRM_BUS_FLAG_SYNC_DRIVE_POSEDGE;1166 if (vm->flags & DISPLAY_FLAGS_SYNC_NEGEDGE)1167 *bus_flags |= DRM_BUS_FLAG_SYNC_DRIVE_NEGEDGE;1168 1169 if (vm->flags & DISPLAY_FLAGS_DE_LOW)1170 *bus_flags |= DRM_BUS_FLAG_DE_LOW;1171 if (vm->flags & DISPLAY_FLAGS_DE_HIGH)1172 *bus_flags |= DRM_BUS_FLAG_DE_HIGH;1173}1174EXPORT_SYMBOL_GPL(drm_bus_flags_from_videomode);1175 1176#ifdef CONFIG_OF1177/**1178 * of_get_drm_display_mode - get a drm_display_mode from devicetree1179 * @np: device_node with the timing specification1180 * @dmode: will be set to the return value1181 * @bus_flags: information about pixelclk, sync and DE polarity1182 * @index: index into the list of display timings in devicetree1183 *1184 * This function is expensive and should only be used, if only one mode is to be1185 * read from DT. To get multiple modes start with of_get_display_timings and1186 * work with that instead.1187 *1188 * Returns:1189 * 0 on success, a negative errno code when no of videomode node was found.1190 */1191int of_get_drm_display_mode(struct device_node *np,1192 struct drm_display_mode *dmode, u32 *bus_flags,1193 int index)1194{1195 struct videomode vm;1196 int ret;1197 1198 ret = of_get_videomode(np, &vm, index);1199 if (ret)1200 return ret;1201 1202 drm_display_mode_from_videomode(&vm, dmode);1203 if (bus_flags)1204 drm_bus_flags_from_videomode(&vm, bus_flags);1205 1206 pr_debug("%pOF: got %dx%d display mode: " DRM_MODE_FMT "\n",1207 np, vm.hactive, vm.vactive, DRM_MODE_ARG(dmode));1208 1209 return 0;1210}1211EXPORT_SYMBOL_GPL(of_get_drm_display_mode);1212 1213/**1214 * of_get_drm_panel_display_mode - get a panel-timing drm_display_mode from devicetree1215 * @np: device_node with the panel-timing specification1216 * @dmode: will be set to the return value1217 * @bus_flags: information about pixelclk, sync and DE polarity1218 *1219 * The mandatory Device Tree properties width-mm and height-mm1220 * are read and set on the display mode.1221 *1222 * Returns:1223 * Zero on success, negative error code on failure.1224 */1225int of_get_drm_panel_display_mode(struct device_node *np,1226 struct drm_display_mode *dmode, u32 *bus_flags)1227{1228 u32 width_mm = 0, height_mm = 0;1229 struct display_timing timing;1230 struct videomode vm;1231 int ret;1232 1233 ret = of_get_display_timing(np, "panel-timing", &timing);1234 if (ret)1235 return ret;1236 1237 videomode_from_timing(&timing, &vm);1238 1239 memset(dmode, 0, sizeof(*dmode));1240 drm_display_mode_from_videomode(&vm, dmode);1241 if (bus_flags)1242 drm_bus_flags_from_videomode(&vm, bus_flags);1243 1244 ret = of_property_read_u32(np, "width-mm", &width_mm);1245 if (ret)1246 return ret;1247 1248 ret = of_property_read_u32(np, "height-mm", &height_mm);1249 if (ret)1250 return ret;1251 1252 dmode->width_mm = width_mm;1253 dmode->height_mm = height_mm;1254 1255 pr_debug(DRM_MODE_FMT "\n", DRM_MODE_ARG(dmode));1256 1257 return 0;1258}1259EXPORT_SYMBOL_GPL(of_get_drm_panel_display_mode);1260#endif /* CONFIG_OF */1261#endif /* CONFIG_VIDEOMODE_HELPERS */1262 1263/**1264 * drm_mode_set_name - set the name on a mode1265 * @mode: name will be set in this mode1266 *1267 * Set the name of @mode to a standard format which is <hdisplay>x<vdisplay>1268 * with an optional 'i' suffix for interlaced modes.1269 */1270void drm_mode_set_name(struct drm_display_mode *mode)1271{1272 bool interlaced = !!(mode->flags & DRM_MODE_FLAG_INTERLACE);1273 1274 snprintf(mode->name, DRM_DISPLAY_MODE_LEN, "%dx%d%s",1275 mode->hdisplay, mode->vdisplay,1276 interlaced ? "i" : "");1277}1278EXPORT_SYMBOL(drm_mode_set_name);1279 1280/**1281 * drm_mode_vrefresh - get the vrefresh of a mode1282 * @mode: mode1283 *1284 * Returns:1285 * @modes's vrefresh rate in Hz, rounded to the nearest integer. Calculates the1286 * value first if it is not yet set.1287 */1288int drm_mode_vrefresh(const struct drm_display_mode *mode)1289{1290 unsigned int num, den;1291 1292 if (mode->htotal == 0 || mode->vtotal == 0)1293 return 0;1294 1295 num = mode->clock;1296 den = mode->htotal * mode->vtotal;1297 1298 if (mode->flags & DRM_MODE_FLAG_INTERLACE)1299 num *= 2;1300 if (mode->flags & DRM_MODE_FLAG_DBLSCAN)1301 den *= 2;1302 if (mode->vscan > 1)1303 den *= mode->vscan;1304 1305 return DIV_ROUND_CLOSEST_ULL(mul_u32_u32(num, 1000), den);1306}1307EXPORT_SYMBOL(drm_mode_vrefresh);1308 1309/**1310 * drm_mode_get_hv_timing - Fetches hdisplay/vdisplay for given mode1311 * @mode: mode to query1312 * @hdisplay: hdisplay value to fill in1313 * @vdisplay: vdisplay value to fill in1314 *1315 * The vdisplay value will be doubled if the specified mode is a stereo mode of1316 * the appropriate layout.1317 */1318void drm_mode_get_hv_timing(const struct drm_display_mode *mode,1319 int *hdisplay, int *vdisplay)1320{1321 struct drm_display_mode adjusted;1322 1323 drm_mode_init(&adjusted, mode);1324 1325 drm_mode_set_crtcinfo(&adjusted, CRTC_STEREO_DOUBLE_ONLY);1326 *hdisplay = adjusted.crtc_hdisplay;1327 *vdisplay = adjusted.crtc_vdisplay;1328}1329EXPORT_SYMBOL(drm_mode_get_hv_timing);1330 1331/**1332 * drm_mode_set_crtcinfo - set CRTC modesetting timing parameters1333 * @p: mode1334 * @adjust_flags: a combination of adjustment flags1335 *1336 * Setup the CRTC modesetting timing parameters for @p, adjusting if necessary.1337 *1338 * - The CRTC_INTERLACE_HALVE_V flag can be used to halve vertical timings of1339 * interlaced modes.1340 * - The CRTC_STEREO_DOUBLE flag can be used to compute the timings for1341 * buffers containing two eyes (only adjust the timings when needed, eg. for1342 * "frame packing" or "side by side full").1343 * - The CRTC_NO_DBLSCAN and CRTC_NO_VSCAN flags request that adjustment *not*1344 * be performed for doublescan and vscan > 1 modes respectively.1345 */1346void drm_mode_set_crtcinfo(struct drm_display_mode *p, int adjust_flags)1347{1348 if (!p)1349 return;1350 1351 p->crtc_clock = p->clock;1352 p->crtc_hdisplay = p->hdisplay;1353 p->crtc_hsync_start = p->hsync_start;1354 p->crtc_hsync_end = p->hsync_end;1355 p->crtc_htotal = p->htotal;1356 p->crtc_hskew = p->hskew;1357 p->crtc_vdisplay = p->vdisplay;1358 p->crtc_vsync_start = p->vsync_start;1359 p->crtc_vsync_end = p->vsync_end;1360 p->crtc_vtotal = p->vtotal;1361 1362 if (p->flags & DRM_MODE_FLAG_INTERLACE) {1363 if (adjust_flags & CRTC_INTERLACE_HALVE_V) {1364 p->crtc_vdisplay /= 2;1365 p->crtc_vsync_start /= 2;1366 p->crtc_vsync_end /= 2;1367 p->crtc_vtotal /= 2;1368 }1369 }1370 1371 if (!(adjust_flags & CRTC_NO_DBLSCAN)) {1372 if (p->flags & DRM_MODE_FLAG_DBLSCAN) {1373 p->crtc_vdisplay *= 2;1374 p->crtc_vsync_start *= 2;1375 p->crtc_vsync_end *= 2;1376 p->crtc_vtotal *= 2;1377 }1378 }1379 1380 if (!(adjust_flags & CRTC_NO_VSCAN)) {1381 if (p->vscan > 1) {1382 p->crtc_vdisplay *= p->vscan;1383 p->crtc_vsync_start *= p->vscan;1384 p->crtc_vsync_end *= p->vscan;1385 p->crtc_vtotal *= p->vscan;1386 }1387 }1388 1389 if (adjust_flags & CRTC_STEREO_DOUBLE) {1390 unsigned int layout = p->flags & DRM_MODE_FLAG_3D_MASK;1391 1392 switch (layout) {1393 case DRM_MODE_FLAG_3D_FRAME_PACKING:1394 p->crtc_clock *= 2;1395 p->crtc_vdisplay += p->crtc_vtotal;1396 p->crtc_vsync_start += p->crtc_vtotal;1397 p->crtc_vsync_end += p->crtc_vtotal;1398 p->crtc_vtotal += p->crtc_vtotal;1399 break;1400 }1401 }1402 1403 p->crtc_vblank_start = min(p->crtc_vsync_start, p->crtc_vdisplay);1404 p->crtc_vblank_end = max(p->crtc_vsync_end, p->crtc_vtotal);1405 p->crtc_hblank_start = min(p->crtc_hsync_start, p->crtc_hdisplay);1406 p->crtc_hblank_end = max(p->crtc_hsync_end, p->crtc_htotal);1407}1408EXPORT_SYMBOL(drm_mode_set_crtcinfo);1409 1410/**1411 * drm_mode_copy - copy the mode1412 * @dst: mode to overwrite1413 * @src: mode to copy1414 *1415 * Copy an existing mode into another mode, preserving the1416 * list head of the destination mode.1417 */1418void drm_mode_copy(struct drm_display_mode *dst, const struct drm_display_mode *src)1419{1420 struct list_head head = dst->head;1421 1422 *dst = *src;1423 dst->head = head;1424}1425EXPORT_SYMBOL(drm_mode_copy);1426 1427/**1428 * drm_mode_init - initialize the mode from another mode1429 * @dst: mode to overwrite1430 * @src: mode to copy1431 *1432 * Copy an existing mode into another mode, zeroing the1433 * list head of the destination mode. Typically used1434 * to guarantee the list head is not left with stack1435 * garbage in on-stack modes.1436 */1437void drm_mode_init(struct drm_display_mode *dst, const struct drm_display_mode *src)1438{1439 memset(dst, 0, sizeof(*dst));1440 drm_mode_copy(dst, src);1441}1442EXPORT_SYMBOL(drm_mode_init);1443 1444/**1445 * drm_mode_duplicate - allocate and duplicate an existing mode1446 * @dev: drm_device to allocate the duplicated mode for1447 * @mode: mode to duplicate1448 *1449 * Just allocate a new mode, copy the existing mode into it, and return1450 * a pointer to it. Used to create new instances of established modes.1451 *1452 * Returns:1453 * Pointer to duplicated mode on success, NULL on error.1454 */1455struct drm_display_mode *drm_mode_duplicate(struct drm_device *dev,1456 const struct drm_display_mode *mode)1457{1458 struct drm_display_mode *nmode;1459 1460 nmode = drm_mode_create(dev);1461 if (!nmode)1462 return NULL;1463 1464 drm_mode_copy(nmode, mode);1465 1466 return nmode;1467}1468EXPORT_SYMBOL(drm_mode_duplicate);1469 1470static bool drm_mode_match_timings(const struct drm_display_mode *mode1,1471 const struct drm_display_mode *mode2)1472{1473 return mode1->hdisplay == mode2->hdisplay &&1474 mode1->hsync_start == mode2->hsync_start &&1475 mode1->hsync_end == mode2->hsync_end &&1476 mode1->htotal == mode2->htotal &&1477 mode1->hskew == mode2->hskew &&1478 mode1->vdisplay == mode2->vdisplay &&1479 mode1->vsync_start == mode2->vsync_start &&1480 mode1->vsync_end == mode2->vsync_end &&1481 mode1->vtotal == mode2->vtotal &&1482 mode1->vscan == mode2->vscan;1483}1484 1485static bool drm_mode_match_clock(const struct drm_display_mode *mode1,1486 const struct drm_display_mode *mode2)1487{1488 /*1489 * do clock check convert to PICOS1490 * so fb modes get matched the same1491 */1492 if (mode1->clock && mode2->clock)1493 return KHZ2PICOS(mode1->clock) == KHZ2PICOS(mode2->clock);1494 else1495 return mode1->clock == mode2->clock;1496}1497 1498static bool drm_mode_match_flags(const struct drm_display_mode *mode1,1499 const struct drm_display_mode *mode2)1500{1501 return (mode1->flags & ~DRM_MODE_FLAG_3D_MASK) ==1502 (mode2->flags & ~DRM_MODE_FLAG_3D_MASK);1503}1504 1505static bool drm_mode_match_3d_flags(const struct drm_display_mode *mode1,1506 const struct drm_display_mode *mode2)1507{1508 return (mode1->flags & DRM_MODE_FLAG_3D_MASK) ==1509 (mode2->flags & DRM_MODE_FLAG_3D_MASK);1510}1511 1512static bool drm_mode_match_aspect_ratio(const struct drm_display_mode *mode1,1513 const struct drm_display_mode *mode2)1514{1515 return mode1->picture_aspect_ratio == mode2->picture_aspect_ratio;1516}1517 1518/**1519 * drm_mode_match - test modes for (partial) equality1520 * @mode1: first mode1521 * @mode2: second mode1522 * @match_flags: which parts need to match (DRM_MODE_MATCH_*)1523 *1524 * Check to see if @mode1 and @mode2 are equivalent.1525 *1526 * Returns:1527 * True if the modes are (partially) equal, false otherwise.1528 */1529bool drm_mode_match(const struct drm_display_mode *mode1,1530 const struct drm_display_mode *mode2,1531 unsigned int match_flags)1532{1533 if (!mode1 && !mode2)1534 return true;1535 1536 if (!mode1 || !mode2)1537 return false;1538 1539 if (match_flags & DRM_MODE_MATCH_TIMINGS &&1540 !drm_mode_match_timings(mode1, mode2))1541 return false;1542 1543 if (match_flags & DRM_MODE_MATCH_CLOCK &&1544 !drm_mode_match_clock(mode1, mode2))1545 return false;1546 1547 if (match_flags & DRM_MODE_MATCH_FLAGS &&1548 !drm_mode_match_flags(mode1, mode2))1549 return false;1550 1551 if (match_flags & DRM_MODE_MATCH_3D_FLAGS &&1552 !drm_mode_match_3d_flags(mode1, mode2))1553 return false;1554 1555 if (match_flags & DRM_MODE_MATCH_ASPECT_RATIO &&1556 !drm_mode_match_aspect_ratio(mode1, mode2))1557 return false;1558 1559 return true;1560}1561EXPORT_SYMBOL(drm_mode_match);1562 1563/**1564 * drm_mode_equal - test modes for equality1565 * @mode1: first mode1566 * @mode2: second mode1567 *1568 * Check to see if @mode1 and @mode2 are equivalent.1569 *1570 * Returns:1571 * True if the modes are equal, false otherwise.1572 */1573bool drm_mode_equal(const struct drm_display_mode *mode1,1574 const struct drm_display_mode *mode2)1575{1576 return drm_mode_match(mode1, mode2,1577 DRM_MODE_MATCH_TIMINGS |1578 DRM_MODE_MATCH_CLOCK |1579 DRM_MODE_MATCH_FLAGS |1580 DRM_MODE_MATCH_3D_FLAGS|1581 DRM_MODE_MATCH_ASPECT_RATIO);1582}1583EXPORT_SYMBOL(drm_mode_equal);1584 1585/**1586 * drm_mode_equal_no_clocks - test modes for equality1587 * @mode1: first mode1588 * @mode2: second mode1589 *1590 * Check to see if @mode1 and @mode2 are equivalent, but1591 * don't check the pixel clocks.1592 *1593 * Returns:1594 * True if the modes are equal, false otherwise.1595 */1596bool drm_mode_equal_no_clocks(const struct drm_display_mode *mode1,1597 const struct drm_display_mode *mode2)1598{1599 return drm_mode_match(mode1, mode2,1600 DRM_MODE_MATCH_TIMINGS |1601 DRM_MODE_MATCH_FLAGS |1602 DRM_MODE_MATCH_3D_FLAGS);1603}1604EXPORT_SYMBOL(drm_mode_equal_no_clocks);1605 1606/**1607 * drm_mode_equal_no_clocks_no_stereo - test modes for equality1608 * @mode1: first mode1609 * @mode2: second mode1610 *1611 * Check to see if @mode1 and @mode2 are equivalent, but1612 * don't check the pixel clocks nor the stereo layout.1613 *1614 * Returns:1615 * True if the modes are equal, false otherwise.1616 */1617bool drm_mode_equal_no_clocks_no_stereo(const struct drm_display_mode *mode1,1618 const struct drm_display_mode *mode2)1619{1620 return drm_mode_match(mode1, mode2,1621 DRM_MODE_MATCH_TIMINGS |1622 DRM_MODE_MATCH_FLAGS);1623}1624EXPORT_SYMBOL(drm_mode_equal_no_clocks_no_stereo);1625 1626static enum drm_mode_status1627drm_mode_validate_basic(const struct drm_display_mode *mode)1628{1629 if (mode->type & ~DRM_MODE_TYPE_ALL)1630 return MODE_BAD;1631 1632 if (mode->flags & ~DRM_MODE_FLAG_ALL)1633 return MODE_BAD;1634 1635 if ((mode->flags & DRM_MODE_FLAG_3D_MASK) > DRM_MODE_FLAG_3D_MAX)1636 return MODE_BAD;1637 1638 if (mode->clock == 0)1639 return MODE_CLOCK_LOW;1640 1641 if (mode->hdisplay == 0 ||1642 mode->hsync_start < mode->hdisplay ||1643 mode->hsync_end < mode->hsync_start ||1644 mode->htotal < mode->hsync_end)1645 return MODE_H_ILLEGAL;1646 1647 if (mode->vdisplay == 0 ||1648 mode->vsync_start < mode->vdisplay ||1649 mode->vsync_end < mode->vsync_start ||1650 mode->vtotal < mode->vsync_end)1651 return MODE_V_ILLEGAL;1652 1653 return MODE_OK;1654}1655 1656/**1657 * drm_mode_validate_driver - make sure the mode is somewhat sane1658 * @dev: drm device1659 * @mode: mode to check1660 *1661 * First do basic validation on the mode, and then allow the driver1662 * to check for device/driver specific limitations via the optional1663 * &drm_mode_config_helper_funcs.mode_valid hook.1664 *1665 * Returns:1666 * The mode status1667 */1668enum drm_mode_status1669drm_mode_validate_driver(struct drm_device *dev,1670 const struct drm_display_mode *mode)1671{1672 enum drm_mode_status status;1673 1674 status = drm_mode_validate_basic(mode);1675 if (status != MODE_OK)1676 return status;1677 1678 if (dev->mode_config.funcs->mode_valid)1679 return dev->mode_config.funcs->mode_valid(dev, mode);1680 else1681 return MODE_OK;1682}1683EXPORT_SYMBOL(drm_mode_validate_driver);1684 1685/**1686 * drm_mode_validate_size - make sure modes adhere to size constraints1687 * @mode: mode to check1688 * @maxX: maximum width1689 * @maxY: maximum height1690 *1691 * This function is a helper which can be used to validate modes against size1692 * limitations of the DRM device/connector. If a mode is too big its status1693 * member is updated with the appropriate validation failure code. The list1694 * itself is not changed.1695 *1696 * Returns:1697 * The mode status1698 */1699enum drm_mode_status1700drm_mode_validate_size(const struct drm_display_mode *mode,1701 int maxX, int maxY)1702{1703 if (maxX > 0 && mode->hdisplay > maxX)1704 return MODE_VIRTUAL_X;1705 1706 if (maxY > 0 && mode->vdisplay > maxY)1707 return MODE_VIRTUAL_Y;1708 1709 return MODE_OK;1710}1711EXPORT_SYMBOL(drm_mode_validate_size);1712 1713/**1714 * drm_mode_validate_ycbcr420 - add 'ycbcr420-only' modes only when allowed1715 * @mode: mode to check1716 * @connector: drm connector under action1717 *1718 * This function is a helper which can be used to filter out any YCBCR4201719 * only mode, when the source doesn't support it.1720 *1721 * Returns:1722 * The mode status1723 */1724enum drm_mode_status1725drm_mode_validate_ycbcr420(const struct drm_display_mode *mode,1726 struct drm_connector *connector)1727{1728 if (!connector->ycbcr_420_allowed &&1729 drm_mode_is_420_only(&connector->display_info, mode))1730 return MODE_NO_420;1731 1732 return MODE_OK;1733}1734EXPORT_SYMBOL(drm_mode_validate_ycbcr420);1735 1736#define MODE_STATUS(status) [MODE_ ## status + 3] = #status1737 1738static const char * const drm_mode_status_names[] = {1739 MODE_STATUS(OK),1740 MODE_STATUS(HSYNC),1741 MODE_STATUS(VSYNC),1742 MODE_STATUS(H_ILLEGAL),1743 MODE_STATUS(V_ILLEGAL),1744 MODE_STATUS(BAD_WIDTH),1745 MODE_STATUS(NOMODE),1746 MODE_STATUS(NO_INTERLACE),1747 MODE_STATUS(NO_DBLESCAN),1748 MODE_STATUS(NO_VSCAN),1749 MODE_STATUS(MEM),1750 MODE_STATUS(VIRTUAL_X),1751 MODE_STATUS(VIRTUAL_Y),1752 MODE_STATUS(MEM_VIRT),1753 MODE_STATUS(NOCLOCK),1754 MODE_STATUS(CLOCK_HIGH),1755 MODE_STATUS(CLOCK_LOW),1756 MODE_STATUS(CLOCK_RANGE),1757 MODE_STATUS(BAD_HVALUE),1758 MODE_STATUS(BAD_VVALUE),1759 MODE_STATUS(BAD_VSCAN),1760 MODE_STATUS(HSYNC_NARROW),1761 MODE_STATUS(HSYNC_WIDE),1762 MODE_STATUS(HBLANK_NARROW),1763 MODE_STATUS(HBLANK_WIDE),1764 MODE_STATUS(VSYNC_NARROW),1765 MODE_STATUS(VSYNC_WIDE),1766 MODE_STATUS(VBLANK_NARROW),1767 MODE_STATUS(VBLANK_WIDE),1768 MODE_STATUS(PANEL),1769 MODE_STATUS(INTERLACE_WIDTH),1770 MODE_STATUS(ONE_WIDTH),1771 MODE_STATUS(ONE_HEIGHT),1772 MODE_STATUS(ONE_SIZE),1773 MODE_STATUS(NO_REDUCED),1774 MODE_STATUS(NO_STEREO),1775 MODE_STATUS(NO_420),1776 MODE_STATUS(STALE),1777 MODE_STATUS(BAD),1778 MODE_STATUS(ERROR),1779};1780 1781#undef MODE_STATUS1782 1783const char *drm_get_mode_status_name(enum drm_mode_status status)1784{1785 int index = status + 3;1786 1787 if (WARN_ON(index < 0 || index >= ARRAY_SIZE(drm_mode_status_names)))1788 return "";1789 1790 return drm_mode_status_names[index];1791}1792 1793/**1794 * drm_mode_prune_invalid - remove invalid modes from mode list1795 * @dev: DRM device1796 * @mode_list: list of modes to check1797 * @verbose: be verbose about it1798 *1799 * This helper function can be used to prune a display mode list after1800 * validation has been completed. All modes whose status is not MODE_OK will be1801 * removed from the list, and if @verbose the status code and mode name is also1802 * printed to dmesg.1803 */1804void drm_mode_prune_invalid(struct drm_device *dev,1805 struct list_head *mode_list, bool verbose)1806{1807 struct drm_display_mode *mode, *t;1808 1809 list_for_each_entry_safe(mode, t, mode_list, head) {1810 if (mode->status != MODE_OK) {1811 list_del(&mode->head);1812 if (mode->type & DRM_MODE_TYPE_USERDEF) {1813 drm_warn(dev, "User-defined mode not supported: "1814 DRM_MODE_FMT "\n", DRM_MODE_ARG(mode));1815 }1816 if (verbose) {1817 drm_dbg_kms(dev, "Rejected mode: " DRM_MODE_FMT " (%s)\n",1818 DRM_MODE_ARG(mode), drm_get_mode_status_name(mode->status));1819 }1820 drm_mode_destroy(dev, mode);1821 }1822 }1823}1824EXPORT_SYMBOL(drm_mode_prune_invalid);1825 1826/**1827 * drm_mode_compare - compare modes for favorability1828 * @priv: unused1829 * @lh_a: list_head for first mode1830 * @lh_b: list_head for second mode1831 *1832 * Compare two modes, given by @lh_a and @lh_b, returning a value indicating1833 * which is better.1834 *1835 * Returns:1836 * Negative if @lh_a is better than @lh_b, zero if they're equivalent, or1837 * positive if @lh_b is better than @lh_a.1838 */1839static int drm_mode_compare(void *priv, const struct list_head *lh_a,1840 const struct list_head *lh_b)1841{1842 struct drm_display_mode *a = list_entry(lh_a, struct drm_display_mode, head);1843 struct drm_display_mode *b = list_entry(lh_b, struct drm_display_mode, head);1844 int diff;1845 1846 diff = ((b->type & DRM_MODE_TYPE_PREFERRED) != 0) -1847 ((a->type & DRM_MODE_TYPE_PREFERRED) != 0);1848 if (diff)1849 return diff;1850 diff = b->hdisplay * b->vdisplay - a->hdisplay * a->vdisplay;1851 if (diff)1852 return diff;1853 1854 diff = drm_mode_vrefresh(b) - drm_mode_vrefresh(a);1855 if (diff)1856 return diff;1857 1858 diff = b->clock - a->clock;1859 return diff;1860}1861 1862/**1863 * drm_mode_sort - sort mode list1864 * @mode_list: list of drm_display_mode structures to sort1865 *1866 * Sort @mode_list by favorability, moving good modes to the head of the list.1867 */1868void drm_mode_sort(struct list_head *mode_list)1869{1870 list_sort(NULL, mode_list, drm_mode_compare);1871}1872EXPORT_SYMBOL(drm_mode_sort);1873 1874/**1875 * drm_connector_list_update - update the mode list for the connector1876 * @connector: the connector to update1877 *1878 * This moves the modes from the @connector probed_modes list1879 * to the actual mode list. It compares the probed mode against the current1880 * list and only adds different/new modes.1881 *1882 * This is just a helper functions doesn't validate any modes itself and also1883 * doesn't prune any invalid modes. Callers need to do that themselves.1884 */1885void drm_connector_list_update(struct drm_connector *connector)1886{1887 struct drm_display_mode *pmode, *pt;1888 1889 WARN_ON(!mutex_is_locked(&connector->dev->mode_config.mutex));1890 1891 list_for_each_entry_safe(pmode, pt, &connector->probed_modes, head) {1892 struct drm_display_mode *mode;1893 bool found_it = false;1894 1895 /* go through current modes checking for the new probed mode */1896 list_for_each_entry(mode, &connector->modes, head) {1897 if (!drm_mode_equal(pmode, mode))1898 continue;1899 1900 found_it = true;1901 1902 /*1903 * If the old matching mode is stale (ie. left over1904 * from a previous probe) just replace it outright.1905 * Otherwise just merge the type bits between all1906 * equal probed modes.1907 *1908 * If two probed modes are considered equal, pick the1909 * actual timings from the one that's marked as1910 * preferred (in case the match isn't 100%). If1911 * multiple or zero preferred modes are present, favor1912 * the mode added to the probed_modes list first.1913 */1914 if (mode->status == MODE_STALE) {1915 drm_mode_copy(mode, pmode);1916 } else if ((mode->type & DRM_MODE_TYPE_PREFERRED) == 0 &&1917 (pmode->type & DRM_MODE_TYPE_PREFERRED) != 0) {1918 pmode->type |= mode->type;1919 drm_mode_copy(mode, pmode);1920 } else {1921 mode->type |= pmode->type;1922 }1923 1924 list_del(&pmode->head);1925 drm_mode_destroy(connector->dev, pmode);1926 break;1927 }1928 1929 if (!found_it) {1930 list_move_tail(&pmode->head, &connector->modes);1931 }1932 }1933}1934EXPORT_SYMBOL(drm_connector_list_update);1935 1936static int drm_mode_parse_cmdline_bpp(const char *str, char **end_ptr,1937 struct drm_cmdline_mode *mode)1938{1939 unsigned int bpp;1940 1941 if (str[0] != '-')1942 return -EINVAL;1943 1944 str++;1945 bpp = simple_strtol(str, end_ptr, 10);1946 if (*end_ptr == str)1947 return -EINVAL;1948 1949 mode->bpp = bpp;1950 mode->bpp_specified = true;1951 1952 return 0;1953}1954 1955static int drm_mode_parse_cmdline_refresh(const char *str, char **end_ptr,1956 struct drm_cmdline_mode *mode)1957{1958 unsigned int refresh;1959 1960 if (str[0] != '@')1961 return -EINVAL;1962 1963 str++;1964 refresh = simple_strtol(str, end_ptr, 10);1965 if (*end_ptr == str)1966 return -EINVAL;1967 1968 mode->refresh = refresh;1969 mode->refresh_specified = true;1970 1971 return 0;1972}1973 1974static int drm_mode_parse_cmdline_extra(const char *str, int length,1975 bool freestanding,1976 const struct drm_connector *connector,1977 struct drm_cmdline_mode *mode)1978{1979 int i;1980 1981 for (i = 0; i < length; i++) {1982 switch (str[i]) {1983 case 'i':1984 if (freestanding)1985 return -EINVAL;1986 1987 mode->interlace = true;1988 break;1989 case 'm':1990 if (freestanding)1991 return -EINVAL;1992 1993 mode->margins = true;1994 break;1995 case 'D':1996 if (mode->force != DRM_FORCE_UNSPECIFIED)1997 return -EINVAL;1998 1999 if ((connector->connector_type != DRM_MODE_CONNECTOR_DVII) &&2000 (connector->connector_type != DRM_MODE_CONNECTOR_HDMIB))2001 mode->force = DRM_FORCE_ON;2002 else2003 mode->force = DRM_FORCE_ON_DIGITAL;2004 break;2005 case 'd':2006 if (mode->force != DRM_FORCE_UNSPECIFIED)2007 return -EINVAL;2008 2009 mode->force = DRM_FORCE_OFF;2010 break;2011 case 'e':2012 if (mode->force != DRM_FORCE_UNSPECIFIED)2013 return -EINVAL;2014 2015 mode->force = DRM_FORCE_ON;2016 break;2017 default:2018 return -EINVAL;2019 }2020 }2021 2022 return 0;2023}2024 2025static int drm_mode_parse_cmdline_res_mode(const char *str, unsigned int length,2026 bool extras,2027 const struct drm_connector *connector,2028 struct drm_cmdline_mode *mode)2029{2030 const char *str_start = str;2031 bool rb = false, cvt = false;2032 int xres = 0, yres = 0;2033 int remaining, i;2034 char *end_ptr;2035 2036 xres = simple_strtol(str, &end_ptr, 10);2037 if (end_ptr == str)2038 return -EINVAL;2039 2040 if (end_ptr[0] != 'x')2041 return -EINVAL;2042 end_ptr++;2043 2044 str = end_ptr;2045 yres = simple_strtol(str, &end_ptr, 10);2046 if (end_ptr == str)2047 return -EINVAL;2048 2049 remaining = length - (end_ptr - str_start);2050 if (remaining < 0)2051 return -EINVAL;2052 2053 for (i = 0; i < remaining; i++) {2054 switch (end_ptr[i]) {2055 case 'M':2056 cvt = true;2057 break;2058 case 'R':2059 rb = true;2060 break;2061 default:2062 /*2063 * Try to pass that to our extras parsing2064 * function to handle the case where the2065 * extras are directly after the resolution2066 */2067 if (extras) {2068 int ret = drm_mode_parse_cmdline_extra(end_ptr + i,2069 1,2070 false,2071 connector,2072 mode);2073 if (ret)2074 return ret;2075 } else {2076 return -EINVAL;2077 }2078 }2079 }2080 2081 mode->xres = xres;2082 mode->yres = yres;2083 mode->cvt = cvt;2084 mode->rb = rb;2085 2086 return 0;2087}2088 2089static int drm_mode_parse_cmdline_int(const char *delim, unsigned int *int_ret)2090{2091 const char *value;2092 char *endp;2093 2094 /*2095 * delim must point to the '=', otherwise it is a syntax error and2096 * if delim points to the terminating zero, then delim + 1 will point2097 * past the end of the string.2098 */2099 if (*delim != '=')2100 return -EINVAL;2101 2102 value = delim + 1;2103 *int_ret = simple_strtol(value, &endp, 10);2104 2105 /* Make sure we have parsed something */2106 if (endp == value)2107 return -EINVAL;2108 2109 return 0;2110}2111 2112static int drm_mode_parse_panel_orientation(const char *delim,2113 struct drm_cmdline_mode *mode)2114{2115 const char *value;2116 2117 if (*delim != '=')2118 return -EINVAL;2119 2120 value = delim + 1;2121 delim = strchr(value, ',');2122 if (!delim)2123 delim = value + strlen(value);2124 2125 if (!strncmp(value, "normal", delim - value))2126 mode->panel_orientation = DRM_MODE_PANEL_ORIENTATION_NORMAL;2127 else if (!strncmp(value, "upside_down", delim - value))2128 mode->panel_orientation = DRM_MODE_PANEL_ORIENTATION_BOTTOM_UP;2129 else if (!strncmp(value, "left_side_up", delim - value))2130 mode->panel_orientation = DRM_MODE_PANEL_ORIENTATION_LEFT_UP;2131 else if (!strncmp(value, "right_side_up", delim - value))2132 mode->panel_orientation = DRM_MODE_PANEL_ORIENTATION_RIGHT_UP;2133 else2134 return -EINVAL;2135 2136 return 0;2137}2138 2139static int drm_mode_parse_tv_mode(const char *delim,2140 struct drm_cmdline_mode *mode)2141{2142 const char *value;2143 int ret;2144 2145 if (*delim != '=')2146 return -EINVAL;2147 2148 value = delim + 1;2149 delim = strchr(value, ',');2150 if (!delim)2151 delim = value + strlen(value);2152 2153 ret = drm_get_tv_mode_from_name(value, delim - value);2154 if (ret < 0)2155 return ret;2156 2157 mode->tv_mode_specified = true;2158 mode->tv_mode = ret;2159 2160 return 0;2161}2162 2163static int drm_mode_parse_cmdline_options(const char *str,2164 bool freestanding,2165 const struct drm_connector *connector,2166 struct drm_cmdline_mode *mode)2167{2168 unsigned int deg, margin, rotation = 0;2169 const char *delim, *option, *sep;2170 2171 option = str;2172 do {2173 delim = strchr(option, '=');2174 if (!delim) {2175 delim = strchr(option, ',');2176 2177 if (!delim)2178 delim = option + strlen(option);2179 }2180 2181 if (!strncmp(option, "rotate", delim - option)) {2182 if (drm_mode_parse_cmdline_int(delim, °))2183 return -EINVAL;2184 2185 switch (deg) {2186 case 0:2187 rotation |= DRM_MODE_ROTATE_0;2188 break;2189 2190 case 90:2191 rotation |= DRM_MODE_ROTATE_90;2192 break;2193 2194 case 180:2195 rotation |= DRM_MODE_ROTATE_180;2196 break;2197 2198 case 270:2199 rotation |= DRM_MODE_ROTATE_270;2200 break;2201 2202 default:2203 return -EINVAL;2204 }2205 } else if (!strncmp(option, "reflect_x", delim - option)) {2206 rotation |= DRM_MODE_REFLECT_X;2207 } else if (!strncmp(option, "reflect_y", delim - option)) {2208 rotation |= DRM_MODE_REFLECT_Y;2209 } else if (!strncmp(option, "margin_right", delim - option)) {2210 if (drm_mode_parse_cmdline_int(delim, &margin))2211 return -EINVAL;2212 2213 mode->tv_margins.right = margin;2214 } else if (!strncmp(option, "margin_left", delim - option)) {2215 if (drm_mode_parse_cmdline_int(delim, &margin))2216 return -EINVAL;2217 2218 mode->tv_margins.left = margin;2219 } else if (!strncmp(option, "margin_top", delim - option)) {2220 if (drm_mode_parse_cmdline_int(delim, &margin))2221 return -EINVAL;2222 2223 mode->tv_margins.top = margin;2224 } else if (!strncmp(option, "margin_bottom", delim - option)) {2225 if (drm_mode_parse_cmdline_int(delim, &margin))2226 return -EINVAL;2227 2228 mode->tv_margins.bottom = margin;2229 } else if (!strncmp(option, "panel_orientation", delim - option)) {2230 if (drm_mode_parse_panel_orientation(delim, mode))2231 return -EINVAL;2232 } else if (!strncmp(option, "tv_mode", delim - option)) {2233 if (drm_mode_parse_tv_mode(delim, mode))2234 return -EINVAL;2235 } else {2236 return -EINVAL;2237 }2238 sep = strchr(delim, ',');2239 option = sep + 1;2240 } while (sep);2241 2242 if (rotation && freestanding)2243 return -EINVAL;2244 2245 if (!(rotation & DRM_MODE_ROTATE_MASK))2246 rotation |= DRM_MODE_ROTATE_0;2247 2248 /* Make sure there is exactly one rotation defined */2249 if (!is_power_of_2(rotation & DRM_MODE_ROTATE_MASK))2250 return -EINVAL;2251 2252 mode->rotation_reflection = rotation;2253 2254 return 0;2255}2256 2257struct drm_named_mode {2258 const char *name;2259 unsigned int pixel_clock_khz;2260 unsigned int xres;2261 unsigned int yres;2262 unsigned int flags;2263 unsigned int tv_mode;2264};2265 2266#define NAMED_MODE(_name, _pclk, _x, _y, _flags, _mode) \2267 { \2268 .name = _name, \2269 .pixel_clock_khz = _pclk, \2270 .xres = _x, \2271 .yres = _y, \2272 .flags = _flags, \2273 .tv_mode = _mode, \2274 }2275 2276static const struct drm_named_mode drm_named_modes[] = {2277 NAMED_MODE("NTSC", 13500, 720, 480, DRM_MODE_FLAG_INTERLACE, DRM_MODE_TV_MODE_NTSC),2278 NAMED_MODE("NTSC-J", 13500, 720, 480, DRM_MODE_FLAG_INTERLACE, DRM_MODE_TV_MODE_NTSC_J),2279 NAMED_MODE("PAL", 13500, 720, 576, DRM_MODE_FLAG_INTERLACE, DRM_MODE_TV_MODE_PAL),2280 NAMED_MODE("PAL-M", 13500, 720, 480, DRM_MODE_FLAG_INTERLACE, DRM_MODE_TV_MODE_PAL_M),2281};2282 2283static int drm_mode_parse_cmdline_named_mode(const char *name,2284 unsigned int name_end,2285 struct drm_cmdline_mode *cmdline_mode)2286{2287 unsigned int i;2288 2289 if (!name_end)2290 return 0;2291 2292 /* If the name starts with a digit, it's not a named mode */2293 if (isdigit(name[0]))2294 return 0;2295 2296 /*2297 * If there's an equal sign in the name, the command-line2298 * contains only an option and no mode.2299 */2300 if (strnchr(name, name_end, '='))2301 return 0;2302 2303 /* The connection status extras can be set without a mode. */2304 if (name_end == 1 &&2305 (name[0] == 'd' || name[0] == 'D' || name[0] == 'e'))2306 return 0;2307 2308 /*2309 * We're sure we're a named mode at this point, iterate over the2310 * list of modes we're aware of.2311 */2312 for (i = 0; i < ARRAY_SIZE(drm_named_modes); i++) {2313 const struct drm_named_mode *mode = &drm_named_modes[i];2314 int ret;2315 2316 ret = str_has_prefix(name, mode->name);2317 if (ret != name_end)2318 continue;2319 2320 strscpy(cmdline_mode->name, mode->name, sizeof(cmdline_mode->name));2321 cmdline_mode->pixel_clock = mode->pixel_clock_khz;2322 cmdline_mode->xres = mode->xres;2323 cmdline_mode->yres = mode->yres;2324 cmdline_mode->interlace = !!(mode->flags & DRM_MODE_FLAG_INTERLACE);2325 cmdline_mode->tv_mode = mode->tv_mode;2326 cmdline_mode->tv_mode_specified = true;2327 cmdline_mode->specified = true;2328 2329 return 1;2330 }2331 2332 return -EINVAL;2333}2334 2335/**2336 * drm_mode_parse_command_line_for_connector - parse command line modeline for connector2337 * @mode_option: optional per connector mode option2338 * @connector: connector to parse modeline for2339 * @mode: preallocated drm_cmdline_mode structure to fill out2340 *2341 * This parses @mode_option command line modeline for modes and options to2342 * configure the connector.2343 *2344 * This uses the same parameters as the fb modedb.c, except for an extra2345 * force-enable, force-enable-digital and force-disable bit at the end::2346 *2347 * <xres>x<yres>[M][R][-<bpp>][@<refresh>][i][m][eDd]2348 *2349 * Additionals options can be provided following the mode, using a comma to2350 * separate each option. Valid options can be found in2351 * Documentation/fb/modedb.rst.2352 *2353 * The intermediate drm_cmdline_mode structure is required to store additional2354 * options from the command line modline like the force-enable/disable flag.2355 *2356 * Returns:2357 * True if a valid modeline has been parsed, false otherwise.2358 */2359bool drm_mode_parse_command_line_for_connector(const char *mode_option,2360 const struct drm_connector *connector,2361 struct drm_cmdline_mode *mode)2362{2363 const char *name;2364 bool freestanding = false, parse_extras = false;2365 unsigned int bpp_off = 0, refresh_off = 0, options_off = 0;2366 unsigned int mode_end = 0;2367 const char *bpp_ptr = NULL, *refresh_ptr = NULL, *extra_ptr = NULL;2368 const char *options_ptr = NULL;2369 char *bpp_end_ptr = NULL, *refresh_end_ptr = NULL;2370 int len, ret;2371 2372 memset(mode, 0, sizeof(*mode));2373 mode->panel_orientation = DRM_MODE_PANEL_ORIENTATION_UNKNOWN;2374 2375 if (!mode_option)2376 return false;2377 2378 name = mode_option;2379 2380 /* Locate the start of named options */2381 options_ptr = strchr(name, ',');2382 if (options_ptr)2383 options_off = options_ptr - name;2384 else2385 options_off = strlen(name);2386 2387 /* Try to locate the bpp and refresh specifiers, if any */2388 bpp_ptr = strnchr(name, options_off, '-');2389 while (bpp_ptr && !isdigit(bpp_ptr[1]))2390 bpp_ptr = strnchr(bpp_ptr + 1, options_off, '-');2391 if (bpp_ptr)2392 bpp_off = bpp_ptr - name;2393 2394 refresh_ptr = strnchr(name, options_off, '@');2395 if (refresh_ptr)2396 refresh_off = refresh_ptr - name;2397 2398 /* Locate the end of the name / resolution, and parse it */2399 if (bpp_ptr) {2400 mode_end = bpp_off;2401 } else if (refresh_ptr) {2402 mode_end = refresh_off;2403 } else if (options_ptr) {2404 mode_end = options_off;2405 parse_extras = true;2406 } else {2407 mode_end = strlen(name);2408 parse_extras = true;2409 }2410 2411 if (!mode_end)2412 return false;2413 2414 ret = drm_mode_parse_cmdline_named_mode(name, mode_end, mode);2415 if (ret < 0)2416 return false;2417 2418 /*2419 * Having a mode that starts by a letter (and thus is named) and2420 * an at-sign (used to specify a refresh rate) is disallowed.2421 */2422 if (ret && refresh_ptr)2423 return false;2424 2425 /* No named mode? Check for a normal mode argument, e.g. 1024x768 */2426 if (!mode->specified && isdigit(name[0])) {2427 ret = drm_mode_parse_cmdline_res_mode(name, mode_end,2428 parse_extras,2429 connector,2430 mode);2431 if (ret)2432 return false;2433 2434 mode->specified = true;2435 }2436 2437 /* No mode? Check for freestanding extras and/or options */2438 if (!mode->specified) {2439 unsigned int len = strlen(mode_option);2440 2441 if (bpp_ptr || refresh_ptr)2442 return false; /* syntax error */2443 2444 if (len == 1 || (len >= 2 && mode_option[1] == ','))2445 extra_ptr = mode_option;2446 else2447 options_ptr = mode_option - 1;2448 2449 freestanding = true;2450 }2451 2452 if (bpp_ptr) {2453 ret = drm_mode_parse_cmdline_bpp(bpp_ptr, &bpp_end_ptr, mode);2454 if (ret)2455 return false;2456 2457 mode->bpp_specified = true;2458 }2459 2460 if (refresh_ptr) {2461 ret = drm_mode_parse_cmdline_refresh(refresh_ptr,2462 &refresh_end_ptr, mode);2463 if (ret)2464 return false;2465 2466 mode->refresh_specified = true;2467 }2468 2469 /*2470 * Locate the end of the bpp / refresh, and parse the extras2471 * if relevant2472 */2473 if (bpp_ptr && refresh_ptr)2474 extra_ptr = max(bpp_end_ptr, refresh_end_ptr);2475 else if (bpp_ptr)2476 extra_ptr = bpp_end_ptr;2477 else if (refresh_ptr)2478 extra_ptr = refresh_end_ptr;2479 2480 if (extra_ptr) {2481 if (options_ptr)2482 len = options_ptr - extra_ptr;2483 else2484 len = strlen(extra_ptr);2485 2486 ret = drm_mode_parse_cmdline_extra(extra_ptr, len, freestanding,2487 connector, mode);2488 if (ret)2489 return false;2490 }2491 2492 if (options_ptr) {2493 ret = drm_mode_parse_cmdline_options(options_ptr + 1,2494 freestanding,2495 connector, mode);2496 if (ret)2497 return false;2498 }2499 2500 return true;2501}2502EXPORT_SYMBOL(drm_mode_parse_command_line_for_connector);2503 2504static struct drm_display_mode *drm_named_mode(struct drm_device *dev,2505 struct drm_cmdline_mode *cmd)2506{2507 unsigned int i;2508 2509 for (i = 0; i < ARRAY_SIZE(drm_named_modes); i++) {2510 const struct drm_named_mode *named_mode = &drm_named_modes[i];2511 2512 if (strcmp(cmd->name, named_mode->name))2513 continue;2514 2515 if (!cmd->tv_mode_specified)2516 continue;2517 2518 return drm_analog_tv_mode(dev,2519 named_mode->tv_mode,2520 named_mode->pixel_clock_khz * 1000,2521 named_mode->xres,2522 named_mode->yres,2523 named_mode->flags & DRM_MODE_FLAG_INTERLACE);2524 }2525 2526 return NULL;2527}2528 2529/**2530 * drm_mode_create_from_cmdline_mode - convert a command line modeline into a DRM display mode2531 * @dev: DRM device to create the new mode for2532 * @cmd: input command line modeline2533 *2534 * Returns:2535 * Pointer to converted mode on success, NULL on error.2536 */2537struct drm_display_mode *2538drm_mode_create_from_cmdline_mode(struct drm_device *dev,2539 struct drm_cmdline_mode *cmd)2540{2541 struct drm_display_mode *mode;2542 2543 if (cmd->xres == 0 || cmd->yres == 0)2544 return NULL;2545 2546 if (strlen(cmd->name))2547 mode = drm_named_mode(dev, cmd);2548 else if (cmd->cvt)2549 mode = drm_cvt_mode(dev,2550 cmd->xres, cmd->yres,2551 cmd->refresh_specified ? cmd->refresh : 60,2552 cmd->rb, cmd->interlace,2553 cmd->margins);2554 else2555 mode = drm_gtf_mode(dev,2556 cmd->xres, cmd->yres,2557 cmd->refresh_specified ? cmd->refresh : 60,2558 cmd->interlace,2559 cmd->margins);2560 if (!mode)2561 return NULL;2562 2563 mode->type |= DRM_MODE_TYPE_USERDEF;2564 /* fix up 1368x768: GFT/CVT can't express 1366 width due to alignment */2565 if (cmd->xres == 1366)2566 drm_mode_fixup_1366x768(mode);2567 drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V);2568 return mode;2569}2570EXPORT_SYMBOL(drm_mode_create_from_cmdline_mode);2571 2572/**2573 * drm_mode_convert_to_umode - convert a drm_display_mode into a modeinfo2574 * @out: drm_mode_modeinfo struct to return to the user2575 * @in: drm_display_mode to use2576 *2577 * Convert a drm_display_mode into a drm_mode_modeinfo structure to return to2578 * the user.2579 */2580void drm_mode_convert_to_umode(struct drm_mode_modeinfo *out,2581 const struct drm_display_mode *in)2582{2583 out->clock = in->clock;2584 out->hdisplay = in->hdisplay;2585 out->hsync_start = in->hsync_start;2586 out->hsync_end = in->hsync_end;2587 out->htotal = in->htotal;2588 out->hskew = in->hskew;2589 out->vdisplay = in->vdisplay;2590 out->vsync_start = in->vsync_start;2591 out->vsync_end = in->vsync_end;2592 out->vtotal = in->vtotal;2593 out->vscan = in->vscan;2594 out->vrefresh = drm_mode_vrefresh(in);2595 out->flags = in->flags;2596 out->type = in->type;2597 2598 switch (in->picture_aspect_ratio) {2599 case HDMI_PICTURE_ASPECT_4_3:2600 out->flags |= DRM_MODE_FLAG_PIC_AR_4_3;2601 break;2602 case HDMI_PICTURE_ASPECT_16_9:2603 out->flags |= DRM_MODE_FLAG_PIC_AR_16_9;2604 break;2605 case HDMI_PICTURE_ASPECT_64_27:2606 out->flags |= DRM_MODE_FLAG_PIC_AR_64_27;2607 break;2608 case HDMI_PICTURE_ASPECT_256_135:2609 out->flags |= DRM_MODE_FLAG_PIC_AR_256_135;2610 break;2611 default:2612 WARN(1, "Invalid aspect ratio (0%x) on mode\n",2613 in->picture_aspect_ratio);2614 fallthrough;2615 case HDMI_PICTURE_ASPECT_NONE:2616 out->flags |= DRM_MODE_FLAG_PIC_AR_NONE;2617 break;2618 }2619 2620 strscpy_pad(out->name, in->name, sizeof(out->name));2621}2622 2623/**2624 * drm_mode_convert_umode - convert a modeinfo into a drm_display_mode2625 * @dev: drm device2626 * @out: drm_display_mode to return to the user2627 * @in: drm_mode_modeinfo to use2628 *2629 * Convert a drm_mode_modeinfo into a drm_display_mode structure to return to2630 * the caller.2631 *2632 * Returns:2633 * Zero on success, negative errno on failure.2634 */2635int drm_mode_convert_umode(struct drm_device *dev,2636 struct drm_display_mode *out,2637 const struct drm_mode_modeinfo *in)2638{2639 if (in->clock > INT_MAX || in->vrefresh > INT_MAX)2640 return -ERANGE;2641 2642 out->clock = in->clock;2643 out->hdisplay = in->hdisplay;2644 out->hsync_start = in->hsync_start;2645 out->hsync_end = in->hsync_end;2646 out->htotal = in->htotal;2647 out->hskew = in->hskew;2648 out->vdisplay = in->vdisplay;2649 out->vsync_start = in->vsync_start;2650 out->vsync_end = in->vsync_end;2651 out->vtotal = in->vtotal;2652 out->vscan = in->vscan;2653 out->flags = in->flags;2654 /*2655 * Old xf86-video-vmware (possibly others too) used to2656 * leave 'type' uninitialized. Just ignore any bits we2657 * don't like. It's a just hint after all, and more2658 * useful for the kernel->userspace direction anyway.2659 */2660 out->type = in->type & DRM_MODE_TYPE_ALL;2661 strscpy_pad(out->name, in->name, sizeof(out->name));2662 2663 /* Clearing picture aspect ratio bits from out flags,2664 * as the aspect-ratio information is not stored in2665 * flags for kernel-mode, but in picture_aspect_ratio.2666 */2667 out->flags &= ~DRM_MODE_FLAG_PIC_AR_MASK;2668 2669 switch (in->flags & DRM_MODE_FLAG_PIC_AR_MASK) {2670 case DRM_MODE_FLAG_PIC_AR_4_3:2671 out->picture_aspect_ratio = HDMI_PICTURE_ASPECT_4_3;2672 break;2673 case DRM_MODE_FLAG_PIC_AR_16_9:2674 out->picture_aspect_ratio = HDMI_PICTURE_ASPECT_16_9;2675 break;2676 case DRM_MODE_FLAG_PIC_AR_64_27:2677 out->picture_aspect_ratio = HDMI_PICTURE_ASPECT_64_27;2678 break;2679 case DRM_MODE_FLAG_PIC_AR_256_135:2680 out->picture_aspect_ratio = HDMI_PICTURE_ASPECT_256_135;2681 break;2682 case DRM_MODE_FLAG_PIC_AR_NONE:2683 out->picture_aspect_ratio = HDMI_PICTURE_ASPECT_NONE;2684 break;2685 default:2686 return -EINVAL;2687 }2688 2689 out->status = drm_mode_validate_driver(dev, out);2690 if (out->status != MODE_OK)2691 return -EINVAL;2692 2693 drm_mode_set_crtcinfo(out, CRTC_INTERLACE_HALVE_V);2694 2695 return 0;2696}2697 2698/**2699 * drm_mode_is_420_only - if a given videomode can be only supported in YCBCR4202700 * output format2701 *2702 * @display: display under action2703 * @mode: video mode to be tested.2704 *2705 * Returns:2706 * true if the mode can be supported in YCBCR420 format2707 * false if not.2708 */2709bool drm_mode_is_420_only(const struct drm_display_info *display,2710 const struct drm_display_mode *mode)2711{2712 u8 vic = drm_match_cea_mode(mode);2713 2714 return test_bit(vic, display->hdmi.y420_vdb_modes);2715}2716EXPORT_SYMBOL(drm_mode_is_420_only);2717 2718/**2719 * drm_mode_is_420_also - if a given videomode can be supported in YCBCR4202720 * output format also (along with RGB/YCBCR444/422)2721 *2722 * @display: display under action.2723 * @mode: video mode to be tested.2724 *2725 * Returns:2726 * true if the mode can be support YCBCR420 format2727 * false if not.2728 */2729bool drm_mode_is_420_also(const struct drm_display_info *display,2730 const struct drm_display_mode *mode)2731{2732 u8 vic = drm_match_cea_mode(mode);2733 2734 return test_bit(vic, display->hdmi.y420_cmdb_modes);2735}2736EXPORT_SYMBOL(drm_mode_is_420_also);2737/**2738 * drm_mode_is_420 - if a given videomode can be supported in YCBCR4202739 * output format2740 *2741 * @display: display under action.2742 * @mode: video mode to be tested.2743 *2744 * Returns:2745 * true if the mode can be supported in YCBCR420 format2746 * false if not.2747 */2748bool drm_mode_is_420(const struct drm_display_info *display,2749 const struct drm_display_mode *mode)2750{2751 return drm_mode_is_420_only(display, mode) ||2752 drm_mode_is_420_also(display, mode);2753}2754EXPORT_SYMBOL(drm_mode_is_420);2755 2756/**2757 * drm_set_preferred_mode - Sets the preferred mode of a connector2758 * @connector: connector whose mode list should be processed2759 * @hpref: horizontal resolution of preferred mode2760 * @vpref: vertical resolution of preferred mode2761 *2762 * Marks a mode as preferred if it matches the resolution specified by @hpref2763 * and @vpref.2764 */2765void drm_set_preferred_mode(struct drm_connector *connector,2766 int hpref, int vpref)2767{2768 struct drm_display_mode *mode;2769 2770 list_for_each_entry(mode, &connector->probed_modes, head) {2771 if (mode->hdisplay == hpref &&2772 mode->vdisplay == vpref)2773 mode->type |= DRM_MODE_TYPE_PREFERRED;2774 }2775}2776EXPORT_SYMBOL(drm_set_preferred_mode);2777