1 /* 2 * Copyright (c) 2006-2009 Red Hat Inc. 3 * Copyright (c) 2006-2008 Intel Corporation 4 * Copyright (c) 2007 Dave Airlie <airlied@linux.ie> 5 * 6 * DRM framebuffer helper functions 7 * 8 * Permission to use, copy, modify, distribute, and sell this software and its 9 * documentation for any purpose is hereby granted without fee, provided that 10 * the above copyright notice appear in all copies and that both that copyright 11 * notice and this permission notice appear in supporting documentation, and 12 * that the name of the copyright holders not be used in advertising or 13 * publicity pertaining to distribution of the software without specific, 14 * written prior permission. The copyright holders make no representations 15 * about the suitability of this software for any purpose. It is provided "as 16 * is" without express or implied warranty. 17 * 18 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, 19 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO 20 * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR 21 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, 22 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER 23 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 24 * OF THIS SOFTWARE. 25 * 26 * Authors: 27 * Dave Airlie <airlied@linux.ie> 28 * Jesse Barnes <jesse.barnes@intel.com> 29 */ 30 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 31 32 #include <linux/console.h> 33 #include <linux/kernel.h> 34 #include <linux/sysrq.h> 35 #include <linux/slab.h> 36 #include <linux/module.h> 37 #include <drm/drmP.h> 38 #include <drm/drm_crtc.h> 39 #include <drm/drm_fb_helper.h> 40 #include <drm/drm_crtc_helper.h> 41 #include <drm/drm_atomic.h> 42 #include <drm/drm_atomic_helper.h> 43 44 #include "drm_crtc_internal.h" 45 #include "drm_crtc_helper_internal.h" 46 47 static bool drm_fbdev_emulation = true; 48 module_param_named(fbdev_emulation, drm_fbdev_emulation, bool, 0600); 49 MODULE_PARM_DESC(fbdev_emulation, 50 "Enable legacy fbdev emulation [default=true]"); 51 52 static int drm_fbdev_overalloc = CONFIG_DRM_FBDEV_OVERALLOC; 53 module_param(drm_fbdev_overalloc, int, 0444); 54 MODULE_PARM_DESC(drm_fbdev_overalloc, 55 "Overallocation of the fbdev buffer (%) [default=" 56 __MODULE_STRING(CONFIG_DRM_FBDEV_OVERALLOC) "]"); 57 58 static LIST_HEAD(kernel_fb_helper_list); 59 static DEFINE_MUTEX(kernel_fb_helper_lock); 60 61 /** 62 * DOC: fbdev helpers 63 * 64 * The fb helper functions are useful to provide an fbdev on top of a drm kernel 65 * mode setting driver. They can be used mostly independently from the crtc 66 * helper functions used by many drivers to implement the kernel mode setting 67 * interfaces. 68 * 69 * Setup fbdev emulation by calling drm_fb_helper_fbdev_setup() and tear it 70 * down by calling drm_fb_helper_fbdev_teardown(). 71 * 72 * Drivers that need to handle connector hotplugging (e.g. dp mst) can't use 73 * the setup helper and will need to do the whole four-step setup process with 74 * drm_fb_helper_prepare(), drm_fb_helper_init(), 75 * drm_fb_helper_single_add_all_connectors(), enable hotplugging and 76 * drm_fb_helper_initial_config() to avoid a possible race window. 77 * 78 * At runtime drivers should restore the fbdev console by using 79 * drm_fb_helper_lastclose() as their &drm_driver.lastclose callback. 80 * They should also notify the fb helper code from updates to the output 81 * configuration by using drm_fb_helper_output_poll_changed() as their 82 * &drm_mode_config_funcs.output_poll_changed callback. 83 * 84 * For suspend/resume consider using drm_mode_config_helper_suspend() and 85 * drm_mode_config_helper_resume() which takes care of fbdev as well. 86 * 87 * All other functions exported by the fb helper library can be used to 88 * implement the fbdev driver interface by the driver. 89 * 90 * It is possible, though perhaps somewhat tricky, to implement race-free 91 * hotplug detection using the fbdev helpers. The drm_fb_helper_prepare() 92 * helper must be called first to initialize the minimum required to make 93 * hotplug detection work. Drivers also need to make sure to properly set up 94 * the &drm_mode_config.funcs member. After calling drm_kms_helper_poll_init() 95 * it is safe to enable interrupts and start processing hotplug events. At the 96 * same time, drivers should initialize all modeset objects such as CRTCs, 97 * encoders and connectors. To finish up the fbdev helper initialization, the 98 * drm_fb_helper_init() function is called. To probe for all attached displays 99 * and set up an initial configuration using the detected hardware, drivers 100 * should call drm_fb_helper_single_add_all_connectors() followed by 101 * drm_fb_helper_initial_config(). 102 * 103 * If &drm_framebuffer_funcs.dirty is set, the 104 * drm_fb_helper_{cfb,sys}_{write,fillrect,copyarea,imageblit} functions will 105 * accumulate changes and schedule &drm_fb_helper.dirty_work to run right 106 * away. This worker then calls the dirty() function ensuring that it will 107 * always run in process context since the fb_*() function could be running in 108 * atomic context. If drm_fb_helper_deferred_io() is used as the deferred_io 109 * callback it will also schedule dirty_work with the damage collected from the 110 * mmap page writes. Drivers can use drm_fb_helper_defio_init() to setup 111 * deferred I/O (coupled with drm_fb_helper_fbdev_teardown()). 112 */ 113 114 #define drm_fb_helper_for_each_connector(fbh, i__) \ 115 for (({ lockdep_assert_held(&(fbh)->lock); }), \ 116 i__ = 0; i__ < (fbh)->connector_count; i__++) 117 118 static int __drm_fb_helper_add_one_connector(struct drm_fb_helper *fb_helper, 119 struct drm_connector *connector) 120 { 121 struct drm_fb_helper_connector *fb_conn; 122 struct drm_fb_helper_connector **temp; 123 unsigned int count; 124 125 if (!drm_fbdev_emulation) 126 return 0; 127 128 lockdep_assert_held(&fb_helper->lock); 129 130 count = fb_helper->connector_count + 1; 131 132 if (count > fb_helper->connector_info_alloc_count) { 133 size_t size = count * sizeof(fb_conn); 134 135 temp = krealloc(fb_helper->connector_info, size, GFP_KERNEL); 136 if (!temp) 137 return -ENOMEM; 138 139 fb_helper->connector_info_alloc_count = count; 140 fb_helper->connector_info = temp; 141 } 142 143 fb_conn = kzalloc(sizeof(*fb_conn), GFP_KERNEL); 144 if (!fb_conn) 145 return -ENOMEM; 146 147 drm_connector_get(connector); 148 fb_conn->connector = connector; 149 fb_helper->connector_info[fb_helper->connector_count++] = fb_conn; 150 151 return 0; 152 } 153 154 int drm_fb_helper_add_one_connector(struct drm_fb_helper *fb_helper, 155 struct drm_connector *connector) 156 { 157 int err; 158 159 if (!fb_helper) 160 return 0; 161 162 mutex_lock(&fb_helper->lock); 163 err = __drm_fb_helper_add_one_connector(fb_helper, connector); 164 mutex_unlock(&fb_helper->lock); 165 166 return err; 167 } 168 EXPORT_SYMBOL(drm_fb_helper_add_one_connector); 169 170 /** 171 * drm_fb_helper_single_add_all_connectors() - add all connectors to fbdev 172 * emulation helper 173 * @fb_helper: fbdev initialized with drm_fb_helper_init, can be NULL 174 * 175 * This functions adds all the available connectors for use with the given 176 * fb_helper. This is a separate step to allow drivers to freely assign 177 * connectors to the fbdev, e.g. if some are reserved for special purposes or 178 * not adequate to be used for the fbcon. 179 * 180 * This function is protected against concurrent connector hotadds/removals 181 * using drm_fb_helper_add_one_connector() and 182 * drm_fb_helper_remove_one_connector(). 183 */ 184 int drm_fb_helper_single_add_all_connectors(struct drm_fb_helper *fb_helper) 185 { 186 struct drm_device *dev; 187 struct drm_connector *connector; 188 struct drm_connector_list_iter conn_iter; 189 int i, ret = 0; 190 191 if (!drm_fbdev_emulation || !fb_helper) 192 return 0; 193 194 dev = fb_helper->dev; 195 196 mutex_lock(&fb_helper->lock); 197 drm_connector_list_iter_begin(dev, &conn_iter); 198 drm_for_each_connector_iter(connector, &conn_iter) { 199 ret = __drm_fb_helper_add_one_connector(fb_helper, connector); 200 if (ret) 201 goto fail; 202 } 203 goto out; 204 205 fail: 206 drm_fb_helper_for_each_connector(fb_helper, i) { 207 struct drm_fb_helper_connector *fb_helper_connector = 208 fb_helper->connector_info[i]; 209 210 drm_connector_put(fb_helper_connector->connector); 211 212 kfree(fb_helper_connector); 213 fb_helper->connector_info[i] = NULL; 214 } 215 fb_helper->connector_count = 0; 216 out: 217 drm_connector_list_iter_end(&conn_iter); 218 mutex_unlock(&fb_helper->lock); 219 220 return ret; 221 } 222 EXPORT_SYMBOL(drm_fb_helper_single_add_all_connectors); 223 224 static int __drm_fb_helper_remove_one_connector(struct drm_fb_helper *fb_helper, 225 struct drm_connector *connector) 226 { 227 struct drm_fb_helper_connector *fb_helper_connector; 228 int i, j; 229 230 if (!drm_fbdev_emulation) 231 return 0; 232 233 lockdep_assert_held(&fb_helper->lock); 234 235 drm_fb_helper_for_each_connector(fb_helper, i) { 236 if (fb_helper->connector_info[i]->connector == connector) 237 break; 238 } 239 240 if (i == fb_helper->connector_count) 241 return -EINVAL; 242 fb_helper_connector = fb_helper->connector_info[i]; 243 drm_connector_put(fb_helper_connector->connector); 244 245 for (j = i + 1; j < fb_helper->connector_count; j++) 246 fb_helper->connector_info[j - 1] = fb_helper->connector_info[j]; 247 248 fb_helper->connector_count--; 249 kfree(fb_helper_connector); 250 251 return 0; 252 } 253 254 int drm_fb_helper_remove_one_connector(struct drm_fb_helper *fb_helper, 255 struct drm_connector *connector) 256 { 257 int err; 258 259 if (!fb_helper) 260 return 0; 261 262 mutex_lock(&fb_helper->lock); 263 err = __drm_fb_helper_remove_one_connector(fb_helper, connector); 264 mutex_unlock(&fb_helper->lock); 265 266 return err; 267 } 268 EXPORT_SYMBOL(drm_fb_helper_remove_one_connector); 269 270 static void drm_fb_helper_restore_lut_atomic(struct drm_crtc *crtc) 271 { 272 uint16_t *r_base, *g_base, *b_base; 273 274 if (crtc->funcs->gamma_set == NULL) 275 return; 276 277 r_base = crtc->gamma_store; 278 g_base = r_base + crtc->gamma_size; 279 b_base = g_base + crtc->gamma_size; 280 281 crtc->funcs->gamma_set(crtc, r_base, g_base, b_base, 282 crtc->gamma_size, NULL); 283 } 284 285 /** 286 * drm_fb_helper_debug_enter - implementation for &fb_ops.fb_debug_enter 287 * @info: fbdev registered by the helper 288 */ 289 int drm_fb_helper_debug_enter(struct fb_info *info) 290 { 291 struct drm_fb_helper *helper = info->par; 292 const struct drm_crtc_helper_funcs *funcs; 293 int i; 294 295 list_for_each_entry(helper, &kernel_fb_helper_list, kernel_fb_list) { 296 for (i = 0; i < helper->crtc_count; i++) { 297 struct drm_mode_set *mode_set = 298 &helper->crtc_info[i].mode_set; 299 300 if (!mode_set->crtc->enabled) 301 continue; 302 303 funcs = mode_set->crtc->helper_private; 304 if (funcs->mode_set_base_atomic == NULL) 305 continue; 306 307 if (drm_drv_uses_atomic_modeset(mode_set->crtc->dev)) 308 continue; 309 310 funcs->mode_set_base_atomic(mode_set->crtc, 311 mode_set->fb, 312 mode_set->x, 313 mode_set->y, 314 ENTER_ATOMIC_MODE_SET); 315 } 316 } 317 318 return 0; 319 } 320 EXPORT_SYMBOL(drm_fb_helper_debug_enter); 321 322 /** 323 * drm_fb_helper_debug_leave - implementation for &fb_ops.fb_debug_leave 324 * @info: fbdev registered by the helper 325 */ 326 int drm_fb_helper_debug_leave(struct fb_info *info) 327 { 328 struct drm_fb_helper *helper = info->par; 329 struct drm_crtc *crtc; 330 const struct drm_crtc_helper_funcs *funcs; 331 struct drm_framebuffer *fb; 332 int i; 333 334 for (i = 0; i < helper->crtc_count; i++) { 335 struct drm_mode_set *mode_set = &helper->crtc_info[i].mode_set; 336 337 crtc = mode_set->crtc; 338 if (drm_drv_uses_atomic_modeset(crtc->dev)) 339 continue; 340 341 funcs = crtc->helper_private; 342 fb = crtc->primary->fb; 343 344 if (!crtc->enabled) 345 continue; 346 347 if (!fb) { 348 DRM_ERROR("no fb to restore??\n"); 349 continue; 350 } 351 352 if (funcs->mode_set_base_atomic == NULL) 353 continue; 354 355 drm_fb_helper_restore_lut_atomic(mode_set->crtc); 356 funcs->mode_set_base_atomic(mode_set->crtc, fb, crtc->x, 357 crtc->y, LEAVE_ATOMIC_MODE_SET); 358 } 359 360 return 0; 361 } 362 EXPORT_SYMBOL(drm_fb_helper_debug_leave); 363 364 static int restore_fbdev_mode_atomic(struct drm_fb_helper *fb_helper, bool active) 365 { 366 struct drm_device *dev = fb_helper->dev; 367 struct drm_plane_state *plane_state; 368 struct drm_plane *plane; 369 struct drm_atomic_state *state; 370 int i, ret; 371 struct drm_modeset_acquire_ctx ctx; 372 373 drm_modeset_acquire_init(&ctx, 0); 374 375 state = drm_atomic_state_alloc(dev); 376 if (!state) { 377 ret = -ENOMEM; 378 goto out_ctx; 379 } 380 381 state->acquire_ctx = &ctx; 382 retry: 383 drm_for_each_plane(plane, dev) { 384 plane_state = drm_atomic_get_plane_state(state, plane); 385 if (IS_ERR(plane_state)) { 386 ret = PTR_ERR(plane_state); 387 goto out_state; 388 } 389 390 plane_state->rotation = DRM_MODE_ROTATE_0; 391 392 /* disable non-primary: */ 393 if (plane->type == DRM_PLANE_TYPE_PRIMARY) 394 continue; 395 396 ret = __drm_atomic_helper_disable_plane(plane, plane_state); 397 if (ret != 0) 398 goto out_state; 399 } 400 401 for (i = 0; i < fb_helper->crtc_count; i++) { 402 struct drm_mode_set *mode_set = &fb_helper->crtc_info[i].mode_set; 403 struct drm_plane *primary = mode_set->crtc->primary; 404 405 /* Cannot fail as we've already gotten the plane state above */ 406 plane_state = drm_atomic_get_new_plane_state(state, primary); 407 plane_state->rotation = fb_helper->crtc_info[i].rotation; 408 409 ret = __drm_atomic_helper_set_config(mode_set, state); 410 if (ret != 0) 411 goto out_state; 412 413 /* 414 * __drm_atomic_helper_set_config() sets active when a 415 * mode is set, unconditionally clear it if we force DPMS off 416 */ 417 if (!active) { 418 struct drm_crtc *crtc = mode_set->crtc; 419 struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state, crtc); 420 421 crtc_state->active = false; 422 } 423 } 424 425 ret = drm_atomic_commit(state); 426 427 out_state: 428 if (ret == -EDEADLK) 429 goto backoff; 430 431 drm_atomic_state_put(state); 432 out_ctx: 433 drm_modeset_drop_locks(&ctx); 434 drm_modeset_acquire_fini(&ctx); 435 436 return ret; 437 438 backoff: 439 drm_atomic_state_clear(state); 440 drm_modeset_backoff(&ctx); 441 442 goto retry; 443 } 444 445 static int restore_fbdev_mode_legacy(struct drm_fb_helper *fb_helper) 446 { 447 struct drm_device *dev = fb_helper->dev; 448 struct drm_plane *plane; 449 int i, ret = 0; 450 451 drm_modeset_lock_all(fb_helper->dev); 452 drm_for_each_plane(plane, dev) { 453 if (plane->type != DRM_PLANE_TYPE_PRIMARY) 454 drm_plane_force_disable(plane); 455 456 if (plane->rotation_property) 457 drm_mode_plane_set_obj_prop(plane, 458 plane->rotation_property, 459 DRM_MODE_ROTATE_0); 460 } 461 462 for (i = 0; i < fb_helper->crtc_count; i++) { 463 struct drm_mode_set *mode_set = &fb_helper->crtc_info[i].mode_set; 464 struct drm_crtc *crtc = mode_set->crtc; 465 466 if (crtc->funcs->cursor_set2) { 467 ret = crtc->funcs->cursor_set2(crtc, NULL, 0, 0, 0, 0, 0); 468 if (ret) 469 goto out; 470 } else if (crtc->funcs->cursor_set) { 471 ret = crtc->funcs->cursor_set(crtc, NULL, 0, 0, 0); 472 if (ret) 473 goto out; 474 } 475 476 ret = drm_mode_set_config_internal(mode_set); 477 if (ret) 478 goto out; 479 } 480 out: 481 drm_modeset_unlock_all(fb_helper->dev); 482 483 return ret; 484 } 485 486 static int restore_fbdev_mode(struct drm_fb_helper *fb_helper) 487 { 488 struct drm_device *dev = fb_helper->dev; 489 490 if (drm_drv_uses_atomic_modeset(dev)) 491 return restore_fbdev_mode_atomic(fb_helper, true); 492 else 493 return restore_fbdev_mode_legacy(fb_helper); 494 } 495 496 /** 497 * drm_fb_helper_restore_fbdev_mode_unlocked - restore fbdev configuration 498 * @fb_helper: driver-allocated fbdev helper, can be NULL 499 * 500 * This should be called from driver's drm &drm_driver.lastclose callback 501 * when implementing an fbcon on top of kms using this helper. This ensures that 502 * the user isn't greeted with a black screen when e.g. X dies. 503 * 504 * RETURNS: 505 * Zero if everything went ok, negative error code otherwise. 506 */ 507 int drm_fb_helper_restore_fbdev_mode_unlocked(struct drm_fb_helper *fb_helper) 508 { 509 bool do_delayed; 510 int ret; 511 512 if (!drm_fbdev_emulation || !fb_helper) 513 return -ENODEV; 514 515 if (READ_ONCE(fb_helper->deferred_setup)) 516 return 0; 517 518 mutex_lock(&fb_helper->lock); 519 ret = restore_fbdev_mode(fb_helper); 520 521 do_delayed = fb_helper->delayed_hotplug; 522 if (do_delayed) 523 fb_helper->delayed_hotplug = false; 524 mutex_unlock(&fb_helper->lock); 525 526 if (do_delayed) 527 drm_fb_helper_hotplug_event(fb_helper); 528 529 return ret; 530 } 531 EXPORT_SYMBOL(drm_fb_helper_restore_fbdev_mode_unlocked); 532 533 static bool drm_fb_helper_is_bound(struct drm_fb_helper *fb_helper) 534 { 535 struct drm_device *dev = fb_helper->dev; 536 struct drm_crtc *crtc; 537 int bound = 0, crtcs_bound = 0; 538 539 /* 540 * Sometimes user space wants everything disabled, so don't steal the 541 * display if there's a master. 542 */ 543 if (READ_ONCE(dev->master)) 544 return false; 545 546 drm_for_each_crtc(crtc, dev) { 547 drm_modeset_lock(&crtc->mutex, NULL); 548 if (crtc->primary->fb) 549 crtcs_bound++; 550 if (crtc->primary->fb == fb_helper->fb) 551 bound++; 552 drm_modeset_unlock(&crtc->mutex); 553 } 554 555 if (bound < crtcs_bound) 556 return false; 557 558 return true; 559 } 560 561 #ifdef CONFIG_MAGIC_SYSRQ 562 /* 563 * restore fbcon display for all kms driver's using this helper, used for sysrq 564 * and panic handling. 565 */ 566 static bool drm_fb_helper_force_kernel_mode(void) 567 { 568 bool ret, error = false; 569 struct drm_fb_helper *helper; 570 571 if (list_empty(&kernel_fb_helper_list)) 572 return false; 573 574 list_for_each_entry(helper, &kernel_fb_helper_list, kernel_fb_list) { 575 struct drm_device *dev = helper->dev; 576 577 if (dev->switch_power_state == DRM_SWITCH_POWER_OFF) 578 continue; 579 580 mutex_lock(&helper->lock); 581 ret = restore_fbdev_mode(helper); 582 if (ret) 583 error = true; 584 mutex_unlock(&helper->lock); 585 } 586 return error; 587 } 588 589 static void drm_fb_helper_restore_work_fn(struct work_struct *ignored) 590 { 591 bool ret; 592 593 ret = drm_fb_helper_force_kernel_mode(); 594 if (ret == true) 595 DRM_ERROR("Failed to restore crtc configuration\n"); 596 } 597 static DECLARE_WORK(drm_fb_helper_restore_work, drm_fb_helper_restore_work_fn); 598 599 static void drm_fb_helper_sysrq(int dummy1) 600 { 601 schedule_work(&drm_fb_helper_restore_work); 602 } 603 604 static struct sysrq_key_op sysrq_drm_fb_helper_restore_op = { 605 .handler = drm_fb_helper_sysrq, 606 .help_msg = "force-fb(V)", 607 .action_msg = "Restore framebuffer console", 608 }; 609 #else 610 static struct sysrq_key_op sysrq_drm_fb_helper_restore_op = { }; 611 #endif 612 613 static void dpms_legacy(struct drm_fb_helper *fb_helper, int dpms_mode) 614 { 615 struct drm_device *dev = fb_helper->dev; 616 struct drm_crtc *crtc; 617 struct drm_connector *connector; 618 int i, j; 619 620 drm_modeset_lock_all(dev); 621 for (i = 0; i < fb_helper->crtc_count; i++) { 622 crtc = fb_helper->crtc_info[i].mode_set.crtc; 623 624 if (!crtc->enabled) 625 continue; 626 627 /* Walk the connectors & encoders on this fb turning them on/off */ 628 drm_fb_helper_for_each_connector(fb_helper, j) { 629 connector = fb_helper->connector_info[j]->connector; 630 connector->funcs->dpms(connector, dpms_mode); 631 drm_object_property_set_value(&connector->base, 632 dev->mode_config.dpms_property, dpms_mode); 633 } 634 } 635 drm_modeset_unlock_all(dev); 636 } 637 638 static void drm_fb_helper_dpms(struct fb_info *info, int dpms_mode) 639 { 640 struct drm_fb_helper *fb_helper = info->par; 641 642 /* 643 * For each CRTC in this fb, turn the connectors on/off. 644 */ 645 mutex_lock(&fb_helper->lock); 646 if (!drm_fb_helper_is_bound(fb_helper)) { 647 mutex_unlock(&fb_helper->lock); 648 return; 649 } 650 651 if (drm_drv_uses_atomic_modeset(fb_helper->dev)) 652 restore_fbdev_mode_atomic(fb_helper, dpms_mode == DRM_MODE_DPMS_ON); 653 else 654 dpms_legacy(fb_helper, dpms_mode); 655 mutex_unlock(&fb_helper->lock); 656 } 657 658 /** 659 * drm_fb_helper_blank - implementation for &fb_ops.fb_blank 660 * @blank: desired blanking state 661 * @info: fbdev registered by the helper 662 */ 663 int drm_fb_helper_blank(int blank, struct fb_info *info) 664 { 665 if (oops_in_progress) 666 return -EBUSY; 667 668 switch (blank) { 669 /* Display: On; HSync: On, VSync: On */ 670 case FB_BLANK_UNBLANK: 671 drm_fb_helper_dpms(info, DRM_MODE_DPMS_ON); 672 break; 673 /* Display: Off; HSync: On, VSync: On */ 674 case FB_BLANK_NORMAL: 675 drm_fb_helper_dpms(info, DRM_MODE_DPMS_STANDBY); 676 break; 677 /* Display: Off; HSync: Off, VSync: On */ 678 case FB_BLANK_HSYNC_SUSPEND: 679 drm_fb_helper_dpms(info, DRM_MODE_DPMS_STANDBY); 680 break; 681 /* Display: Off; HSync: On, VSync: Off */ 682 case FB_BLANK_VSYNC_SUSPEND: 683 drm_fb_helper_dpms(info, DRM_MODE_DPMS_SUSPEND); 684 break; 685 /* Display: Off; HSync: Off, VSync: Off */ 686 case FB_BLANK_POWERDOWN: 687 drm_fb_helper_dpms(info, DRM_MODE_DPMS_OFF); 688 break; 689 } 690 return 0; 691 } 692 EXPORT_SYMBOL(drm_fb_helper_blank); 693 694 static void drm_fb_helper_modeset_release(struct drm_fb_helper *helper, 695 struct drm_mode_set *modeset) 696 { 697 int i; 698 699 for (i = 0; i < modeset->num_connectors; i++) { 700 drm_connector_put(modeset->connectors[i]); 701 modeset->connectors[i] = NULL; 702 } 703 modeset->num_connectors = 0; 704 705 drm_mode_destroy(helper->dev, modeset->mode); 706 modeset->mode = NULL; 707 708 /* FIXME should hold a ref? */ 709 modeset->fb = NULL; 710 } 711 712 static void drm_fb_helper_crtc_free(struct drm_fb_helper *helper) 713 { 714 int i; 715 716 for (i = 0; i < helper->connector_count; i++) { 717 drm_connector_put(helper->connector_info[i]->connector); 718 kfree(helper->connector_info[i]); 719 } 720 kfree(helper->connector_info); 721 722 for (i = 0; i < helper->crtc_count; i++) { 723 struct drm_mode_set *modeset = &helper->crtc_info[i].mode_set; 724 725 drm_fb_helper_modeset_release(helper, modeset); 726 kfree(modeset->connectors); 727 } 728 kfree(helper->crtc_info); 729 } 730 731 static void drm_fb_helper_resume_worker(struct work_struct *work) 732 { 733 struct drm_fb_helper *helper = container_of(work, struct drm_fb_helper, 734 resume_work); 735 736 console_lock(); 737 fb_set_suspend(helper->fbdev, 0); 738 console_unlock(); 739 } 740 741 static void drm_fb_helper_dirty_work(struct work_struct *work) 742 { 743 struct drm_fb_helper *helper = container_of(work, struct drm_fb_helper, 744 dirty_work); 745 struct drm_clip_rect *clip = &helper->dirty_clip; 746 struct drm_clip_rect clip_copy; 747 unsigned long flags; 748 749 spin_lock_irqsave(&helper->dirty_lock, flags); 750 clip_copy = *clip; 751 clip->x1 = clip->y1 = ~0; 752 clip->x2 = clip->y2 = 0; 753 spin_unlock_irqrestore(&helper->dirty_lock, flags); 754 755 /* call dirty callback only when it has been really touched */ 756 if (clip_copy.x1 < clip_copy.x2 && clip_copy.y1 < clip_copy.y2) 757 helper->fb->funcs->dirty(helper->fb, NULL, 0, 0, &clip_copy, 1); 758 } 759 760 /** 761 * drm_fb_helper_prepare - setup a drm_fb_helper structure 762 * @dev: DRM device 763 * @helper: driver-allocated fbdev helper structure to set up 764 * @funcs: pointer to structure of functions associate with this helper 765 * 766 * Sets up the bare minimum to make the framebuffer helper usable. This is 767 * useful to implement race-free initialization of the polling helpers. 768 */ 769 void drm_fb_helper_prepare(struct drm_device *dev, struct drm_fb_helper *helper, 770 const struct drm_fb_helper_funcs *funcs) 771 { 772 INIT_LIST_HEAD(&helper->kernel_fb_list); 773 spin_lock_init(&helper->dirty_lock); 774 INIT_WORK(&helper->resume_work, drm_fb_helper_resume_worker); 775 INIT_WORK(&helper->dirty_work, drm_fb_helper_dirty_work); 776 helper->dirty_clip.x1 = helper->dirty_clip.y1 = ~0; 777 mutex_init(&helper->lock); 778 helper->funcs = funcs; 779 helper->dev = dev; 780 } 781 EXPORT_SYMBOL(drm_fb_helper_prepare); 782 783 /** 784 * drm_fb_helper_init - initialize a &struct drm_fb_helper 785 * @dev: drm device 786 * @fb_helper: driver-allocated fbdev helper structure to initialize 787 * @max_conn_count: max connector count 788 * 789 * This allocates the structures for the fbdev helper with the given limits. 790 * Note that this won't yet touch the hardware (through the driver interfaces) 791 * nor register the fbdev. This is only done in drm_fb_helper_initial_config() 792 * to allow driver writes more control over the exact init sequence. 793 * 794 * Drivers must call drm_fb_helper_prepare() before calling this function. 795 * 796 * RETURNS: 797 * Zero if everything went ok, nonzero otherwise. 798 */ 799 int drm_fb_helper_init(struct drm_device *dev, 800 struct drm_fb_helper *fb_helper, 801 int max_conn_count) 802 { 803 struct drm_crtc *crtc; 804 struct drm_mode_config *config = &dev->mode_config; 805 int i; 806 807 if (!drm_fbdev_emulation) { 808 dev->fb_helper = fb_helper; 809 return 0; 810 } 811 812 if (!max_conn_count) 813 return -EINVAL; 814 815 fb_helper->crtc_info = kcalloc(config->num_crtc, sizeof(struct drm_fb_helper_crtc), GFP_KERNEL); 816 if (!fb_helper->crtc_info) 817 return -ENOMEM; 818 819 fb_helper->crtc_count = config->num_crtc; 820 fb_helper->connector_info = kcalloc(dev->mode_config.num_connector, sizeof(struct drm_fb_helper_connector *), GFP_KERNEL); 821 if (!fb_helper->connector_info) { 822 kfree(fb_helper->crtc_info); 823 return -ENOMEM; 824 } 825 fb_helper->connector_info_alloc_count = dev->mode_config.num_connector; 826 fb_helper->connector_count = 0; 827 828 for (i = 0; i < fb_helper->crtc_count; i++) { 829 fb_helper->crtc_info[i].mode_set.connectors = 830 kcalloc(max_conn_count, 831 sizeof(struct drm_connector *), 832 GFP_KERNEL); 833 834 if (!fb_helper->crtc_info[i].mode_set.connectors) 835 goto out_free; 836 fb_helper->crtc_info[i].mode_set.num_connectors = 0; 837 fb_helper->crtc_info[i].rotation = DRM_MODE_ROTATE_0; 838 } 839 840 i = 0; 841 drm_for_each_crtc(crtc, dev) { 842 fb_helper->crtc_info[i].mode_set.crtc = crtc; 843 i++; 844 } 845 846 dev->fb_helper = fb_helper; 847 848 return 0; 849 out_free: 850 drm_fb_helper_crtc_free(fb_helper); 851 return -ENOMEM; 852 } 853 EXPORT_SYMBOL(drm_fb_helper_init); 854 855 /** 856 * drm_fb_helper_alloc_fbi - allocate fb_info and some of its members 857 * @fb_helper: driver-allocated fbdev helper 858 * 859 * A helper to alloc fb_info and the members cmap and apertures. Called 860 * by the driver within the fb_probe fb_helper callback function. Drivers do not 861 * need to release the allocated fb_info structure themselves, this is 862 * automatically done when calling drm_fb_helper_fini(). 863 * 864 * RETURNS: 865 * fb_info pointer if things went okay, pointer containing error code 866 * otherwise 867 */ 868 struct fb_info *drm_fb_helper_alloc_fbi(struct drm_fb_helper *fb_helper) 869 { 870 struct device *dev = fb_helper->dev->dev; 871 struct fb_info *info; 872 int ret; 873 874 info = framebuffer_alloc(0, dev); 875 if (!info) 876 return ERR_PTR(-ENOMEM); 877 878 ret = fb_alloc_cmap(&info->cmap, 256, 0); 879 if (ret) 880 goto err_release; 881 882 info->apertures = alloc_apertures(1); 883 if (!info->apertures) { 884 ret = -ENOMEM; 885 goto err_free_cmap; 886 } 887 888 fb_helper->fbdev = info; 889 890 return info; 891 892 err_free_cmap: 893 fb_dealloc_cmap(&info->cmap); 894 err_release: 895 framebuffer_release(info); 896 return ERR_PTR(ret); 897 } 898 EXPORT_SYMBOL(drm_fb_helper_alloc_fbi); 899 900 /** 901 * drm_fb_helper_unregister_fbi - unregister fb_info framebuffer device 902 * @fb_helper: driver-allocated fbdev helper, can be NULL 903 * 904 * A wrapper around unregister_framebuffer, to release the fb_info 905 * framebuffer device. This must be called before releasing all resources for 906 * @fb_helper by calling drm_fb_helper_fini(). 907 */ 908 void drm_fb_helper_unregister_fbi(struct drm_fb_helper *fb_helper) 909 { 910 if (fb_helper && fb_helper->fbdev) 911 unregister_framebuffer(fb_helper->fbdev); 912 } 913 EXPORT_SYMBOL(drm_fb_helper_unregister_fbi); 914 915 /** 916 * drm_fb_helper_fini - finialize a &struct drm_fb_helper 917 * @fb_helper: driver-allocated fbdev helper, can be NULL 918 * 919 * This cleans up all remaining resources associated with @fb_helper. Must be 920 * called after drm_fb_helper_unlink_fbi() was called. 921 */ 922 void drm_fb_helper_fini(struct drm_fb_helper *fb_helper) 923 { 924 struct fb_info *info; 925 926 if (!fb_helper) 927 return; 928 929 fb_helper->dev->fb_helper = NULL; 930 931 if (!drm_fbdev_emulation) 932 return; 933 934 cancel_work_sync(&fb_helper->resume_work); 935 cancel_work_sync(&fb_helper->dirty_work); 936 937 info = fb_helper->fbdev; 938 if (info) { 939 if (info->cmap.len) 940 fb_dealloc_cmap(&info->cmap); 941 framebuffer_release(info); 942 } 943 fb_helper->fbdev = NULL; 944 945 mutex_lock(&kernel_fb_helper_lock); 946 if (!list_empty(&fb_helper->kernel_fb_list)) { 947 list_del(&fb_helper->kernel_fb_list); 948 if (list_empty(&kernel_fb_helper_list)) 949 unregister_sysrq_key('v', &sysrq_drm_fb_helper_restore_op); 950 } 951 mutex_unlock(&kernel_fb_helper_lock); 952 953 mutex_destroy(&fb_helper->lock); 954 drm_fb_helper_crtc_free(fb_helper); 955 956 } 957 EXPORT_SYMBOL(drm_fb_helper_fini); 958 959 /** 960 * drm_fb_helper_unlink_fbi - wrapper around unlink_framebuffer 961 * @fb_helper: driver-allocated fbdev helper, can be NULL 962 * 963 * A wrapper around unlink_framebuffer implemented by fbdev core 964 */ 965 void drm_fb_helper_unlink_fbi(struct drm_fb_helper *fb_helper) 966 { 967 if (fb_helper && fb_helper->fbdev) 968 unlink_framebuffer(fb_helper->fbdev); 969 } 970 EXPORT_SYMBOL(drm_fb_helper_unlink_fbi); 971 972 static void drm_fb_helper_dirty(struct fb_info *info, u32 x, u32 y, 973 u32 width, u32 height) 974 { 975 struct drm_fb_helper *helper = info->par; 976 struct drm_clip_rect *clip = &helper->dirty_clip; 977 unsigned long flags; 978 979 if (!helper->fb->funcs->dirty) 980 return; 981 982 spin_lock_irqsave(&helper->dirty_lock, flags); 983 clip->x1 = min_t(u32, clip->x1, x); 984 clip->y1 = min_t(u32, clip->y1, y); 985 clip->x2 = max_t(u32, clip->x2, x + width); 986 clip->y2 = max_t(u32, clip->y2, y + height); 987 spin_unlock_irqrestore(&helper->dirty_lock, flags); 988 989 schedule_work(&helper->dirty_work); 990 } 991 992 /** 993 * drm_fb_helper_deferred_io() - fbdev deferred_io callback function 994 * @info: fb_info struct pointer 995 * @pagelist: list of dirty mmap framebuffer pages 996 * 997 * This function is used as the &fb_deferred_io.deferred_io 998 * callback function for flushing the fbdev mmap writes. 999 */ 1000 void drm_fb_helper_deferred_io(struct fb_info *info, 1001 struct list_head *pagelist) 1002 { 1003 unsigned long start, end, min, max; 1004 struct page *page; 1005 u32 y1, y2; 1006 1007 min = ULONG_MAX; 1008 max = 0; 1009 list_for_each_entry(page, pagelist, lru) { 1010 start = page->index << PAGE_SHIFT; 1011 end = start + PAGE_SIZE - 1; 1012 min = min(min, start); 1013 max = max(max, end); 1014 } 1015 1016 if (min < max) { 1017 y1 = min / info->fix.line_length; 1018 y2 = min_t(u32, DIV_ROUND_UP(max, info->fix.line_length), 1019 info->var.yres); 1020 drm_fb_helper_dirty(info, 0, y1, info->var.xres, y2 - y1); 1021 } 1022 } 1023 EXPORT_SYMBOL(drm_fb_helper_deferred_io); 1024 1025 /** 1026 * drm_fb_helper_defio_init - fbdev deferred I/O initialization 1027 * @fb_helper: driver-allocated fbdev helper 1028 * 1029 * This function allocates &fb_deferred_io, sets callback to 1030 * drm_fb_helper_deferred_io(), delay to 50ms and calls fb_deferred_io_init(). 1031 * It should be called from the &drm_fb_helper_funcs->fb_probe callback. 1032 * drm_fb_helper_fbdev_teardown() cleans up deferred I/O. 1033 * 1034 * NOTE: A copy of &fb_ops is made and assigned to &info->fbops. This is done 1035 * because fb_deferred_io_cleanup() clears &fbops->fb_mmap and would thereby 1036 * affect other instances of that &fb_ops. 1037 * 1038 * Returns: 1039 * 0 on success or a negative error code on failure. 1040 */ 1041 int drm_fb_helper_defio_init(struct drm_fb_helper *fb_helper) 1042 { 1043 struct fb_info *info = fb_helper->fbdev; 1044 struct fb_deferred_io *fbdefio; 1045 struct fb_ops *fbops; 1046 1047 fbdefio = kzalloc(sizeof(*fbdefio), GFP_KERNEL); 1048 fbops = kzalloc(sizeof(*fbops), GFP_KERNEL); 1049 if (!fbdefio || !fbops) { 1050 kfree(fbdefio); 1051 kfree(fbops); 1052 return -ENOMEM; 1053 } 1054 1055 info->fbdefio = fbdefio; 1056 fbdefio->delay = msecs_to_jiffies(50); 1057 fbdefio->deferred_io = drm_fb_helper_deferred_io; 1058 1059 *fbops = *info->fbops; 1060 info->fbops = fbops; 1061 1062 fb_deferred_io_init(info); 1063 1064 return 0; 1065 } 1066 EXPORT_SYMBOL(drm_fb_helper_defio_init); 1067 1068 /** 1069 * drm_fb_helper_sys_read - wrapper around fb_sys_read 1070 * @info: fb_info struct pointer 1071 * @buf: userspace buffer to read from framebuffer memory 1072 * @count: number of bytes to read from framebuffer memory 1073 * @ppos: read offset within framebuffer memory 1074 * 1075 * A wrapper around fb_sys_read implemented by fbdev core 1076 */ 1077 ssize_t drm_fb_helper_sys_read(struct fb_info *info, char __user *buf, 1078 size_t count, loff_t *ppos) 1079 { 1080 return fb_sys_read(info, buf, count, ppos); 1081 } 1082 EXPORT_SYMBOL(drm_fb_helper_sys_read); 1083 1084 /** 1085 * drm_fb_helper_sys_write - wrapper around fb_sys_write 1086 * @info: fb_info struct pointer 1087 * @buf: userspace buffer to write to framebuffer memory 1088 * @count: number of bytes to write to framebuffer memory 1089 * @ppos: write offset within framebuffer memory 1090 * 1091 * A wrapper around fb_sys_write implemented by fbdev core 1092 */ 1093 ssize_t drm_fb_helper_sys_write(struct fb_info *info, const char __user *buf, 1094 size_t count, loff_t *ppos) 1095 { 1096 ssize_t ret; 1097 1098 ret = fb_sys_write(info, buf, count, ppos); 1099 if (ret > 0) 1100 drm_fb_helper_dirty(info, 0, 0, info->var.xres, 1101 info->var.yres); 1102 1103 return ret; 1104 } 1105 EXPORT_SYMBOL(drm_fb_helper_sys_write); 1106 1107 /** 1108 * drm_fb_helper_sys_fillrect - wrapper around sys_fillrect 1109 * @info: fbdev registered by the helper 1110 * @rect: info about rectangle to fill 1111 * 1112 * A wrapper around sys_fillrect implemented by fbdev core 1113 */ 1114 void drm_fb_helper_sys_fillrect(struct fb_info *info, 1115 const struct fb_fillrect *rect) 1116 { 1117 sys_fillrect(info, rect); 1118 drm_fb_helper_dirty(info, rect->dx, rect->dy, 1119 rect->width, rect->height); 1120 } 1121 EXPORT_SYMBOL(drm_fb_helper_sys_fillrect); 1122 1123 /** 1124 * drm_fb_helper_sys_copyarea - wrapper around sys_copyarea 1125 * @info: fbdev registered by the helper 1126 * @area: info about area to copy 1127 * 1128 * A wrapper around sys_copyarea implemented by fbdev core 1129 */ 1130 void drm_fb_helper_sys_copyarea(struct fb_info *info, 1131 const struct fb_copyarea *area) 1132 { 1133 sys_copyarea(info, area); 1134 drm_fb_helper_dirty(info, area->dx, area->dy, 1135 area->width, area->height); 1136 } 1137 EXPORT_SYMBOL(drm_fb_helper_sys_copyarea); 1138 1139 /** 1140 * drm_fb_helper_sys_imageblit - wrapper around sys_imageblit 1141 * @info: fbdev registered by the helper 1142 * @image: info about image to blit 1143 * 1144 * A wrapper around sys_imageblit implemented by fbdev core 1145 */ 1146 void drm_fb_helper_sys_imageblit(struct fb_info *info, 1147 const struct fb_image *image) 1148 { 1149 sys_imageblit(info, image); 1150 drm_fb_helper_dirty(info, image->dx, image->dy, 1151 image->width, image->height); 1152 } 1153 EXPORT_SYMBOL(drm_fb_helper_sys_imageblit); 1154 1155 /** 1156 * drm_fb_helper_cfb_fillrect - wrapper around cfb_fillrect 1157 * @info: fbdev registered by the helper 1158 * @rect: info about rectangle to fill 1159 * 1160 * A wrapper around cfb_fillrect implemented by fbdev core 1161 */ 1162 void drm_fb_helper_cfb_fillrect(struct fb_info *info, 1163 const struct fb_fillrect *rect) 1164 { 1165 cfb_fillrect(info, rect); 1166 drm_fb_helper_dirty(info, rect->dx, rect->dy, 1167 rect->width, rect->height); 1168 } 1169 EXPORT_SYMBOL(drm_fb_helper_cfb_fillrect); 1170 1171 /** 1172 * drm_fb_helper_cfb_copyarea - wrapper around cfb_copyarea 1173 * @info: fbdev registered by the helper 1174 * @area: info about area to copy 1175 * 1176 * A wrapper around cfb_copyarea implemented by fbdev core 1177 */ 1178 void drm_fb_helper_cfb_copyarea(struct fb_info *info, 1179 const struct fb_copyarea *area) 1180 { 1181 cfb_copyarea(info, area); 1182 drm_fb_helper_dirty(info, area->dx, area->dy, 1183 area->width, area->height); 1184 } 1185 EXPORT_SYMBOL(drm_fb_helper_cfb_copyarea); 1186 1187 /** 1188 * drm_fb_helper_cfb_imageblit - wrapper around cfb_imageblit 1189 * @info: fbdev registered by the helper 1190 * @image: info about image to blit 1191 * 1192 * A wrapper around cfb_imageblit implemented by fbdev core 1193 */ 1194 void drm_fb_helper_cfb_imageblit(struct fb_info *info, 1195 const struct fb_image *image) 1196 { 1197 cfb_imageblit(info, image); 1198 drm_fb_helper_dirty(info, image->dx, image->dy, 1199 image->width, image->height); 1200 } 1201 EXPORT_SYMBOL(drm_fb_helper_cfb_imageblit); 1202 1203 /** 1204 * drm_fb_helper_set_suspend - wrapper around fb_set_suspend 1205 * @fb_helper: driver-allocated fbdev helper, can be NULL 1206 * @suspend: whether to suspend or resume 1207 * 1208 * A wrapper around fb_set_suspend implemented by fbdev core. 1209 * Use drm_fb_helper_set_suspend_unlocked() if you don't need to take 1210 * the lock yourself 1211 */ 1212 void drm_fb_helper_set_suspend(struct drm_fb_helper *fb_helper, bool suspend) 1213 { 1214 if (fb_helper && fb_helper->fbdev) 1215 fb_set_suspend(fb_helper->fbdev, suspend); 1216 } 1217 EXPORT_SYMBOL(drm_fb_helper_set_suspend); 1218 1219 /** 1220 * drm_fb_helper_set_suspend_unlocked - wrapper around fb_set_suspend that also 1221 * takes the console lock 1222 * @fb_helper: driver-allocated fbdev helper, can be NULL 1223 * @suspend: whether to suspend or resume 1224 * 1225 * A wrapper around fb_set_suspend() that takes the console lock. If the lock 1226 * isn't available on resume, a worker is tasked with waiting for the lock 1227 * to become available. The console lock can be pretty contented on resume 1228 * due to all the printk activity. 1229 * 1230 * This function can be called multiple times with the same state since 1231 * &fb_info.state is checked to see if fbdev is running or not before locking. 1232 * 1233 * Use drm_fb_helper_set_suspend() if you need to take the lock yourself. 1234 */ 1235 void drm_fb_helper_set_suspend_unlocked(struct drm_fb_helper *fb_helper, 1236 bool suspend) 1237 { 1238 if (!fb_helper || !fb_helper->fbdev) 1239 return; 1240 1241 /* make sure there's no pending/ongoing resume */ 1242 flush_work(&fb_helper->resume_work); 1243 1244 if (suspend) { 1245 if (fb_helper->fbdev->state != FBINFO_STATE_RUNNING) 1246 return; 1247 1248 console_lock(); 1249 1250 } else { 1251 if (fb_helper->fbdev->state == FBINFO_STATE_RUNNING) 1252 return; 1253 1254 if (!console_trylock()) { 1255 schedule_work(&fb_helper->resume_work); 1256 return; 1257 } 1258 } 1259 1260 fb_set_suspend(fb_helper->fbdev, suspend); 1261 console_unlock(); 1262 } 1263 EXPORT_SYMBOL(drm_fb_helper_set_suspend_unlocked); 1264 1265 static int setcmap_pseudo_palette(struct fb_cmap *cmap, struct fb_info *info) 1266 { 1267 u32 *palette = (u32 *)info->pseudo_palette; 1268 int i; 1269 1270 if (cmap->start + cmap->len > 16) 1271 return -EINVAL; 1272 1273 for (i = 0; i < cmap->len; ++i) { 1274 u16 red = cmap->red[i]; 1275 u16 green = cmap->green[i]; 1276 u16 blue = cmap->blue[i]; 1277 u32 value; 1278 1279 red >>= 16 - info->var.red.length; 1280 green >>= 16 - info->var.green.length; 1281 blue >>= 16 - info->var.blue.length; 1282 value = (red << info->var.red.offset) | 1283 (green << info->var.green.offset) | 1284 (blue << info->var.blue.offset); 1285 if (info->var.transp.length > 0) { 1286 u32 mask = (1 << info->var.transp.length) - 1; 1287 1288 mask <<= info->var.transp.offset; 1289 value |= mask; 1290 } 1291 palette[cmap->start + i] = value; 1292 } 1293 1294 return 0; 1295 } 1296 1297 static int setcmap_legacy(struct fb_cmap *cmap, struct fb_info *info) 1298 { 1299 struct drm_fb_helper *fb_helper = info->par; 1300 struct drm_crtc *crtc; 1301 u16 *r, *g, *b; 1302 int i, ret = 0; 1303 1304 drm_modeset_lock_all(fb_helper->dev); 1305 for (i = 0; i < fb_helper->crtc_count; i++) { 1306 crtc = fb_helper->crtc_info[i].mode_set.crtc; 1307 if (!crtc->funcs->gamma_set || !crtc->gamma_size) 1308 return -EINVAL; 1309 1310 if (cmap->start + cmap->len > crtc->gamma_size) 1311 return -EINVAL; 1312 1313 r = crtc->gamma_store; 1314 g = r + crtc->gamma_size; 1315 b = g + crtc->gamma_size; 1316 1317 memcpy(r + cmap->start, cmap->red, cmap->len * sizeof(*r)); 1318 memcpy(g + cmap->start, cmap->green, cmap->len * sizeof(*g)); 1319 memcpy(b + cmap->start, cmap->blue, cmap->len * sizeof(*b)); 1320 1321 ret = crtc->funcs->gamma_set(crtc, r, g, b, 1322 crtc->gamma_size, NULL); 1323 if (ret) 1324 return ret; 1325 } 1326 drm_modeset_unlock_all(fb_helper->dev); 1327 1328 return ret; 1329 } 1330 1331 static struct drm_property_blob *setcmap_new_gamma_lut(struct drm_crtc *crtc, 1332 struct fb_cmap *cmap) 1333 { 1334 struct drm_device *dev = crtc->dev; 1335 struct drm_property_blob *gamma_lut; 1336 struct drm_color_lut *lut; 1337 int size = crtc->gamma_size; 1338 int i; 1339 1340 if (!size || cmap->start + cmap->len > size) 1341 return ERR_PTR(-EINVAL); 1342 1343 gamma_lut = drm_property_create_blob(dev, sizeof(*lut) * size, NULL); 1344 if (IS_ERR(gamma_lut)) 1345 return gamma_lut; 1346 1347 lut = gamma_lut->data; 1348 if (cmap->start || cmap->len != size) { 1349 u16 *r = crtc->gamma_store; 1350 u16 *g = r + crtc->gamma_size; 1351 u16 *b = g + crtc->gamma_size; 1352 1353 for (i = 0; i < cmap->start; i++) { 1354 lut[i].red = r[i]; 1355 lut[i].green = g[i]; 1356 lut[i].blue = b[i]; 1357 } 1358 for (i = cmap->start + cmap->len; i < size; i++) { 1359 lut[i].red = r[i]; 1360 lut[i].green = g[i]; 1361 lut[i].blue = b[i]; 1362 } 1363 } 1364 1365 for (i = 0; i < cmap->len; i++) { 1366 lut[cmap->start + i].red = cmap->red[i]; 1367 lut[cmap->start + i].green = cmap->green[i]; 1368 lut[cmap->start + i].blue = cmap->blue[i]; 1369 } 1370 1371 return gamma_lut; 1372 } 1373 1374 static int setcmap_atomic(struct fb_cmap *cmap, struct fb_info *info) 1375 { 1376 struct drm_fb_helper *fb_helper = info->par; 1377 struct drm_device *dev = fb_helper->dev; 1378 struct drm_property_blob *gamma_lut = NULL; 1379 struct drm_modeset_acquire_ctx ctx; 1380 struct drm_crtc_state *crtc_state; 1381 struct drm_atomic_state *state; 1382 struct drm_crtc *crtc; 1383 u16 *r, *g, *b; 1384 int i, ret = 0; 1385 bool replaced; 1386 1387 drm_modeset_acquire_init(&ctx, 0); 1388 1389 state = drm_atomic_state_alloc(dev); 1390 if (!state) { 1391 ret = -ENOMEM; 1392 goto out_ctx; 1393 } 1394 1395 state->acquire_ctx = &ctx; 1396 retry: 1397 for (i = 0; i < fb_helper->crtc_count; i++) { 1398 crtc = fb_helper->crtc_info[i].mode_set.crtc; 1399 1400 if (!gamma_lut) 1401 gamma_lut = setcmap_new_gamma_lut(crtc, cmap); 1402 if (IS_ERR(gamma_lut)) { 1403 ret = PTR_ERR(gamma_lut); 1404 gamma_lut = NULL; 1405 goto out_state; 1406 } 1407 1408 crtc_state = drm_atomic_get_crtc_state(state, crtc); 1409 if (IS_ERR(crtc_state)) { 1410 ret = PTR_ERR(crtc_state); 1411 goto out_state; 1412 } 1413 1414 replaced = drm_property_replace_blob(&crtc_state->degamma_lut, 1415 NULL); 1416 replaced |= drm_property_replace_blob(&crtc_state->ctm, NULL); 1417 replaced |= drm_property_replace_blob(&crtc_state->gamma_lut, 1418 gamma_lut); 1419 crtc_state->color_mgmt_changed |= replaced; 1420 } 1421 1422 ret = drm_atomic_commit(state); 1423 if (ret) 1424 goto out_state; 1425 1426 for (i = 0; i < fb_helper->crtc_count; i++) { 1427 crtc = fb_helper->crtc_info[i].mode_set.crtc; 1428 1429 r = crtc->gamma_store; 1430 g = r + crtc->gamma_size; 1431 b = g + crtc->gamma_size; 1432 1433 memcpy(r + cmap->start, cmap->red, cmap->len * sizeof(*r)); 1434 memcpy(g + cmap->start, cmap->green, cmap->len * sizeof(*g)); 1435 memcpy(b + cmap->start, cmap->blue, cmap->len * sizeof(*b)); 1436 } 1437 1438 out_state: 1439 if (ret == -EDEADLK) 1440 goto backoff; 1441 1442 drm_property_blob_put(gamma_lut); 1443 drm_atomic_state_put(state); 1444 out_ctx: 1445 drm_modeset_drop_locks(&ctx); 1446 drm_modeset_acquire_fini(&ctx); 1447 1448 return ret; 1449 1450 backoff: 1451 drm_atomic_state_clear(state); 1452 drm_modeset_backoff(&ctx); 1453 goto retry; 1454 } 1455 1456 /** 1457 * drm_fb_helper_setcmap - implementation for &fb_ops.fb_setcmap 1458 * @cmap: cmap to set 1459 * @info: fbdev registered by the helper 1460 */ 1461 int drm_fb_helper_setcmap(struct fb_cmap *cmap, struct fb_info *info) 1462 { 1463 struct drm_fb_helper *fb_helper = info->par; 1464 int ret; 1465 1466 if (oops_in_progress) 1467 return -EBUSY; 1468 1469 mutex_lock(&fb_helper->lock); 1470 1471 if (!drm_fb_helper_is_bound(fb_helper)) { 1472 ret = -EBUSY; 1473 goto out; 1474 } 1475 1476 if (info->fix.visual == FB_VISUAL_TRUECOLOR) 1477 ret = setcmap_pseudo_palette(cmap, info); 1478 else if (drm_drv_uses_atomic_modeset(fb_helper->dev)) 1479 ret = setcmap_atomic(cmap, info); 1480 else 1481 ret = setcmap_legacy(cmap, info); 1482 1483 out: 1484 mutex_unlock(&fb_helper->lock); 1485 1486 return ret; 1487 } 1488 EXPORT_SYMBOL(drm_fb_helper_setcmap); 1489 1490 /** 1491 * drm_fb_helper_ioctl - legacy ioctl implementation 1492 * @info: fbdev registered by the helper 1493 * @cmd: ioctl command 1494 * @arg: ioctl argument 1495 * 1496 * A helper to implement the standard fbdev ioctl. Only 1497 * FBIO_WAITFORVSYNC is implemented for now. 1498 */ 1499 int drm_fb_helper_ioctl(struct fb_info *info, unsigned int cmd, 1500 unsigned long arg) 1501 { 1502 struct drm_fb_helper *fb_helper = info->par; 1503 struct drm_mode_set *mode_set; 1504 struct drm_crtc *crtc; 1505 int ret = 0; 1506 1507 mutex_lock(&fb_helper->lock); 1508 if (!drm_fb_helper_is_bound(fb_helper)) { 1509 ret = -EBUSY; 1510 goto unlock; 1511 } 1512 1513 switch (cmd) { 1514 case FBIO_WAITFORVSYNC: 1515 /* 1516 * Only consider the first CRTC. 1517 * 1518 * This ioctl is supposed to take the CRTC number as 1519 * an argument, but in fbdev times, what that number 1520 * was supposed to be was quite unclear, different 1521 * drivers were passing that argument differently 1522 * (some by reference, some by value), and most of the 1523 * userspace applications were just hardcoding 0 as an 1524 * argument. 1525 * 1526 * The first CRTC should be the integrated panel on 1527 * most drivers, so this is the best choice we can 1528 * make. If we're not smart enough here, one should 1529 * just consider switch the userspace to KMS. 1530 */ 1531 mode_set = &fb_helper->crtc_info[0].mode_set; 1532 crtc = mode_set->crtc; 1533 1534 /* 1535 * Only wait for a vblank event if the CRTC is 1536 * enabled, otherwise just don't do anythintg, 1537 * not even report an error. 1538 */ 1539 ret = drm_crtc_vblank_get(crtc); 1540 if (!ret) { 1541 drm_crtc_wait_one_vblank(crtc); 1542 drm_crtc_vblank_put(crtc); 1543 } 1544 1545 ret = 0; 1546 goto unlock; 1547 default: 1548 ret = -ENOTTY; 1549 } 1550 1551 unlock: 1552 mutex_unlock(&fb_helper->lock); 1553 return ret; 1554 } 1555 EXPORT_SYMBOL(drm_fb_helper_ioctl); 1556 1557 /** 1558 * drm_fb_helper_check_var - implementation for &fb_ops.fb_check_var 1559 * @var: screeninfo to check 1560 * @info: fbdev registered by the helper 1561 */ 1562 int drm_fb_helper_check_var(struct fb_var_screeninfo *var, 1563 struct fb_info *info) 1564 { 1565 struct drm_fb_helper *fb_helper = info->par; 1566 struct drm_framebuffer *fb = fb_helper->fb; 1567 int depth; 1568 1569 if (var->pixclock != 0 || in_dbg_master()) 1570 return -EINVAL; 1571 1572 /* 1573 * Changes struct fb_var_screeninfo are currently not pushed back 1574 * to KMS, hence fail if different settings are requested. 1575 */ 1576 if (var->bits_per_pixel != fb->format->cpp[0] * 8 || 1577 var->xres > fb->width || var->yres > fb->height || 1578 var->xres_virtual > fb->width || var->yres_virtual > fb->height) { 1579 DRM_DEBUG("fb requested width/height/bpp can't fit in current fb " 1580 "request %dx%d-%d (virtual %dx%d) > %dx%d-%d\n", 1581 var->xres, var->yres, var->bits_per_pixel, 1582 var->xres_virtual, var->yres_virtual, 1583 fb->width, fb->height, fb->format->cpp[0] * 8); 1584 return -EINVAL; 1585 } 1586 1587 switch (var->bits_per_pixel) { 1588 case 16: 1589 depth = (var->green.length == 6) ? 16 : 15; 1590 break; 1591 case 32: 1592 depth = (var->transp.length > 0) ? 32 : 24; 1593 break; 1594 default: 1595 depth = var->bits_per_pixel; 1596 break; 1597 } 1598 1599 switch (depth) { 1600 case 8: 1601 var->red.offset = 0; 1602 var->green.offset = 0; 1603 var->blue.offset = 0; 1604 var->red.length = 8; 1605 var->green.length = 8; 1606 var->blue.length = 8; 1607 var->transp.length = 0; 1608 var->transp.offset = 0; 1609 break; 1610 case 15: 1611 var->red.offset = 10; 1612 var->green.offset = 5; 1613 var->blue.offset = 0; 1614 var->red.length = 5; 1615 var->green.length = 5; 1616 var->blue.length = 5; 1617 var->transp.length = 1; 1618 var->transp.offset = 15; 1619 break; 1620 case 16: 1621 var->red.offset = 11; 1622 var->green.offset = 5; 1623 var->blue.offset = 0; 1624 var->red.length = 5; 1625 var->green.length = 6; 1626 var->blue.length = 5; 1627 var->transp.length = 0; 1628 var->transp.offset = 0; 1629 break; 1630 case 24: 1631 var->red.offset = 16; 1632 var->green.offset = 8; 1633 var->blue.offset = 0; 1634 var->red.length = 8; 1635 var->green.length = 8; 1636 var->blue.length = 8; 1637 var->transp.length = 0; 1638 var->transp.offset = 0; 1639 break; 1640 case 32: 1641 var->red.offset = 16; 1642 var->green.offset = 8; 1643 var->blue.offset = 0; 1644 var->red.length = 8; 1645 var->green.length = 8; 1646 var->blue.length = 8; 1647 var->transp.length = 8; 1648 var->transp.offset = 24; 1649 break; 1650 default: 1651 return -EINVAL; 1652 } 1653 return 0; 1654 } 1655 EXPORT_SYMBOL(drm_fb_helper_check_var); 1656 1657 /** 1658 * drm_fb_helper_set_par - implementation for &fb_ops.fb_set_par 1659 * @info: fbdev registered by the helper 1660 * 1661 * This will let fbcon do the mode init and is called at initialization time by 1662 * the fbdev core when registering the driver, and later on through the hotplug 1663 * callback. 1664 */ 1665 int drm_fb_helper_set_par(struct fb_info *info) 1666 { 1667 struct drm_fb_helper *fb_helper = info->par; 1668 struct fb_var_screeninfo *var = &info->var; 1669 1670 if (oops_in_progress) 1671 return -EBUSY; 1672 1673 if (var->pixclock != 0) { 1674 DRM_ERROR("PIXEL CLOCK SET\n"); 1675 return -EINVAL; 1676 } 1677 1678 drm_fb_helper_restore_fbdev_mode_unlocked(fb_helper); 1679 1680 return 0; 1681 } 1682 EXPORT_SYMBOL(drm_fb_helper_set_par); 1683 1684 static void pan_set(struct drm_fb_helper *fb_helper, int x, int y) 1685 { 1686 int i; 1687 1688 for (i = 0; i < fb_helper->crtc_count; i++) { 1689 struct drm_mode_set *mode_set; 1690 1691 mode_set = &fb_helper->crtc_info[i].mode_set; 1692 1693 mode_set->x = x; 1694 mode_set->y = y; 1695 } 1696 } 1697 1698 static int pan_display_atomic(struct fb_var_screeninfo *var, 1699 struct fb_info *info) 1700 { 1701 struct drm_fb_helper *fb_helper = info->par; 1702 int ret; 1703 1704 pan_set(fb_helper, var->xoffset, var->yoffset); 1705 1706 ret = restore_fbdev_mode_atomic(fb_helper, true); 1707 if (!ret) { 1708 info->var.xoffset = var->xoffset; 1709 info->var.yoffset = var->yoffset; 1710 } else 1711 pan_set(fb_helper, info->var.xoffset, info->var.yoffset); 1712 1713 return ret; 1714 } 1715 1716 static int pan_display_legacy(struct fb_var_screeninfo *var, 1717 struct fb_info *info) 1718 { 1719 struct drm_fb_helper *fb_helper = info->par; 1720 struct drm_mode_set *modeset; 1721 int ret = 0; 1722 int i; 1723 1724 drm_modeset_lock_all(fb_helper->dev); 1725 for (i = 0; i < fb_helper->crtc_count; i++) { 1726 modeset = &fb_helper->crtc_info[i].mode_set; 1727 1728 modeset->x = var->xoffset; 1729 modeset->y = var->yoffset; 1730 1731 if (modeset->num_connectors) { 1732 ret = drm_mode_set_config_internal(modeset); 1733 if (!ret) { 1734 info->var.xoffset = var->xoffset; 1735 info->var.yoffset = var->yoffset; 1736 } 1737 } 1738 } 1739 drm_modeset_unlock_all(fb_helper->dev); 1740 1741 return ret; 1742 } 1743 1744 /** 1745 * drm_fb_helper_pan_display - implementation for &fb_ops.fb_pan_display 1746 * @var: updated screen information 1747 * @info: fbdev registered by the helper 1748 */ 1749 int drm_fb_helper_pan_display(struct fb_var_screeninfo *var, 1750 struct fb_info *info) 1751 { 1752 struct drm_fb_helper *fb_helper = info->par; 1753 struct drm_device *dev = fb_helper->dev; 1754 int ret; 1755 1756 if (oops_in_progress) 1757 return -EBUSY; 1758 1759 mutex_lock(&fb_helper->lock); 1760 if (!drm_fb_helper_is_bound(fb_helper)) { 1761 mutex_unlock(&fb_helper->lock); 1762 return -EBUSY; 1763 } 1764 1765 if (drm_drv_uses_atomic_modeset(dev)) 1766 ret = pan_display_atomic(var, info); 1767 else 1768 ret = pan_display_legacy(var, info); 1769 mutex_unlock(&fb_helper->lock); 1770 1771 return ret; 1772 } 1773 EXPORT_SYMBOL(drm_fb_helper_pan_display); 1774 1775 /* 1776 * Allocates the backing storage and sets up the fbdev info structure through 1777 * the ->fb_probe callback. 1778 */ 1779 static int drm_fb_helper_single_fb_probe(struct drm_fb_helper *fb_helper, 1780 int preferred_bpp) 1781 { 1782 int ret = 0; 1783 int crtc_count = 0; 1784 int i; 1785 struct drm_fb_helper_surface_size sizes; 1786 int gamma_size = 0; 1787 1788 memset(&sizes, 0, sizeof(struct drm_fb_helper_surface_size)); 1789 sizes.surface_depth = 24; 1790 sizes.surface_bpp = 32; 1791 sizes.fb_width = (u32)-1; 1792 sizes.fb_height = (u32)-1; 1793 1794 /* if driver picks 8 or 16 by default use that for both depth/bpp */ 1795 if (preferred_bpp != sizes.surface_bpp) 1796 sizes.surface_depth = sizes.surface_bpp = preferred_bpp; 1797 1798 /* first up get a count of crtcs now in use and new min/maxes width/heights */ 1799 drm_fb_helper_for_each_connector(fb_helper, i) { 1800 struct drm_fb_helper_connector *fb_helper_conn = fb_helper->connector_info[i]; 1801 struct drm_cmdline_mode *cmdline_mode; 1802 1803 cmdline_mode = &fb_helper_conn->connector->cmdline_mode; 1804 1805 if (cmdline_mode->bpp_specified) { 1806 switch (cmdline_mode->bpp) { 1807 case 8: 1808 sizes.surface_depth = sizes.surface_bpp = 8; 1809 break; 1810 case 15: 1811 sizes.surface_depth = 15; 1812 sizes.surface_bpp = 16; 1813 break; 1814 case 16: 1815 sizes.surface_depth = sizes.surface_bpp = 16; 1816 break; 1817 case 24: 1818 sizes.surface_depth = sizes.surface_bpp = 24; 1819 break; 1820 case 32: 1821 sizes.surface_depth = 24; 1822 sizes.surface_bpp = 32; 1823 break; 1824 } 1825 break; 1826 } 1827 } 1828 1829 crtc_count = 0; 1830 for (i = 0; i < fb_helper->crtc_count; i++) { 1831 struct drm_display_mode *desired_mode; 1832 struct drm_mode_set *mode_set; 1833 int x, y, j; 1834 /* in case of tile group, are we the last tile vert or horiz? 1835 * If no tile group you are always the last one both vertically 1836 * and horizontally 1837 */ 1838 bool lastv = true, lasth = true; 1839 1840 desired_mode = fb_helper->crtc_info[i].desired_mode; 1841 mode_set = &fb_helper->crtc_info[i].mode_set; 1842 1843 if (!desired_mode) 1844 continue; 1845 1846 crtc_count++; 1847 1848 x = fb_helper->crtc_info[i].x; 1849 y = fb_helper->crtc_info[i].y; 1850 1851 if (gamma_size == 0) 1852 gamma_size = fb_helper->crtc_info[i].mode_set.crtc->gamma_size; 1853 1854 sizes.surface_width = max_t(u32, desired_mode->hdisplay + x, sizes.surface_width); 1855 sizes.surface_height = max_t(u32, desired_mode->vdisplay + y, sizes.surface_height); 1856 1857 for (j = 0; j < mode_set->num_connectors; j++) { 1858 struct drm_connector *connector = mode_set->connectors[j]; 1859 1860 if (connector->has_tile) { 1861 lasth = (connector->tile_h_loc == (connector->num_h_tile - 1)); 1862 lastv = (connector->tile_v_loc == (connector->num_v_tile - 1)); 1863 /* cloning to multiple tiles is just crazy-talk, so: */ 1864 break; 1865 } 1866 } 1867 1868 if (lasth) 1869 sizes.fb_width = min_t(u32, desired_mode->hdisplay + x, sizes.fb_width); 1870 if (lastv) 1871 sizes.fb_height = min_t(u32, desired_mode->vdisplay + y, sizes.fb_height); 1872 } 1873 1874 if (crtc_count == 0 || sizes.fb_width == -1 || sizes.fb_height == -1) { 1875 DRM_INFO("Cannot find any crtc or sizes\n"); 1876 1877 /* First time: disable all crtc's.. */ 1878 if (!fb_helper->deferred_setup && !READ_ONCE(fb_helper->dev->master)) 1879 restore_fbdev_mode(fb_helper); 1880 return -EAGAIN; 1881 } 1882 1883 /* Handle our overallocation */ 1884 sizes.surface_height *= drm_fbdev_overalloc; 1885 sizes.surface_height /= 100; 1886 1887 /* push down into drivers */ 1888 ret = (*fb_helper->funcs->fb_probe)(fb_helper, &sizes); 1889 if (ret < 0) 1890 return ret; 1891 1892 strcpy(fb_helper->fb->comm, "[fbcon]"); 1893 return 0; 1894 } 1895 1896 /** 1897 * drm_fb_helper_fill_fix - initializes fixed fbdev information 1898 * @info: fbdev registered by the helper 1899 * @pitch: desired pitch 1900 * @depth: desired depth 1901 * 1902 * Helper to fill in the fixed fbdev information useful for a non-accelerated 1903 * fbdev emulations. Drivers which support acceleration methods which impose 1904 * additional constraints need to set up their own limits. 1905 * 1906 * Drivers should call this (or their equivalent setup code) from their 1907 * &drm_fb_helper_funcs.fb_probe callback. 1908 */ 1909 void drm_fb_helper_fill_fix(struct fb_info *info, uint32_t pitch, 1910 uint32_t depth) 1911 { 1912 info->fix.type = FB_TYPE_PACKED_PIXELS; 1913 info->fix.visual = depth == 8 ? FB_VISUAL_PSEUDOCOLOR : 1914 FB_VISUAL_TRUECOLOR; 1915 info->fix.mmio_start = 0; 1916 info->fix.mmio_len = 0; 1917 info->fix.type_aux = 0; 1918 info->fix.xpanstep = 1; /* doing it in hw */ 1919 info->fix.ypanstep = 1; /* doing it in hw */ 1920 info->fix.ywrapstep = 0; 1921 info->fix.accel = FB_ACCEL_NONE; 1922 1923 info->fix.line_length = pitch; 1924 } 1925 EXPORT_SYMBOL(drm_fb_helper_fill_fix); 1926 1927 /** 1928 * drm_fb_helper_fill_var - initalizes variable fbdev information 1929 * @info: fbdev instance to set up 1930 * @fb_helper: fb helper instance to use as template 1931 * @fb_width: desired fb width 1932 * @fb_height: desired fb height 1933 * 1934 * Sets up the variable fbdev metainformation from the given fb helper instance 1935 * and the drm framebuffer allocated in &drm_fb_helper.fb. 1936 * 1937 * Drivers should call this (or their equivalent setup code) from their 1938 * &drm_fb_helper_funcs.fb_probe callback after having allocated the fbdev 1939 * backing storage framebuffer. 1940 */ 1941 void drm_fb_helper_fill_var(struct fb_info *info, struct drm_fb_helper *fb_helper, 1942 uint32_t fb_width, uint32_t fb_height) 1943 { 1944 struct drm_framebuffer *fb = fb_helper->fb; 1945 1946 info->pseudo_palette = fb_helper->pseudo_palette; 1947 info->var.xres_virtual = fb->width; 1948 info->var.yres_virtual = fb->height; 1949 info->var.bits_per_pixel = fb->format->cpp[0] * 8; 1950 info->var.accel_flags = FB_ACCELF_TEXT; 1951 info->var.xoffset = 0; 1952 info->var.yoffset = 0; 1953 info->var.activate = FB_ACTIVATE_NOW; 1954 1955 switch (fb->format->depth) { 1956 case 8: 1957 info->var.red.offset = 0; 1958 info->var.green.offset = 0; 1959 info->var.blue.offset = 0; 1960 info->var.red.length = 8; /* 8bit DAC */ 1961 info->var.green.length = 8; 1962 info->var.blue.length = 8; 1963 info->var.transp.offset = 0; 1964 info->var.transp.length = 0; 1965 break; 1966 case 15: 1967 info->var.red.offset = 10; 1968 info->var.green.offset = 5; 1969 info->var.blue.offset = 0; 1970 info->var.red.length = 5; 1971 info->var.green.length = 5; 1972 info->var.blue.length = 5; 1973 info->var.transp.offset = 15; 1974 info->var.transp.length = 1; 1975 break; 1976 case 16: 1977 info->var.red.offset = 11; 1978 info->var.green.offset = 5; 1979 info->var.blue.offset = 0; 1980 info->var.red.length = 5; 1981 info->var.green.length = 6; 1982 info->var.blue.length = 5; 1983 info->var.transp.offset = 0; 1984 break; 1985 case 24: 1986 info->var.red.offset = 16; 1987 info->var.green.offset = 8; 1988 info->var.blue.offset = 0; 1989 info->var.red.length = 8; 1990 info->var.green.length = 8; 1991 info->var.blue.length = 8; 1992 info->var.transp.offset = 0; 1993 info->var.transp.length = 0; 1994 break; 1995 case 32: 1996 info->var.red.offset = 16; 1997 info->var.green.offset = 8; 1998 info->var.blue.offset = 0; 1999 info->var.red.length = 8; 2000 info->var.green.length = 8; 2001 info->var.blue.length = 8; 2002 info->var.transp.offset = 24; 2003 info->var.transp.length = 8; 2004 break; 2005 default: 2006 break; 2007 } 2008 2009 info->var.xres = fb_width; 2010 info->var.yres = fb_height; 2011 } 2012 EXPORT_SYMBOL(drm_fb_helper_fill_var); 2013 2014 static int drm_fb_helper_probe_connector_modes(struct drm_fb_helper *fb_helper, 2015 uint32_t maxX, 2016 uint32_t maxY) 2017 { 2018 struct drm_connector *connector; 2019 int i, count = 0; 2020 2021 drm_fb_helper_for_each_connector(fb_helper, i) { 2022 connector = fb_helper->connector_info[i]->connector; 2023 count += connector->funcs->fill_modes(connector, maxX, maxY); 2024 } 2025 2026 return count; 2027 } 2028 2029 struct drm_display_mode *drm_has_preferred_mode(struct drm_fb_helper_connector *fb_connector, int width, int height) 2030 { 2031 struct drm_display_mode *mode; 2032 2033 list_for_each_entry(mode, &fb_connector->connector->modes, head) { 2034 if (mode->hdisplay > width || 2035 mode->vdisplay > height) 2036 continue; 2037 if (mode->type & DRM_MODE_TYPE_PREFERRED) 2038 return mode; 2039 } 2040 return NULL; 2041 } 2042 EXPORT_SYMBOL(drm_has_preferred_mode); 2043 2044 static bool drm_has_cmdline_mode(struct drm_fb_helper_connector *fb_connector) 2045 { 2046 return fb_connector->connector->cmdline_mode.specified; 2047 } 2048 2049 struct drm_display_mode *drm_pick_cmdline_mode(struct drm_fb_helper_connector *fb_helper_conn) 2050 { 2051 struct drm_cmdline_mode *cmdline_mode; 2052 struct drm_display_mode *mode; 2053 bool prefer_non_interlace; 2054 2055 cmdline_mode = &fb_helper_conn->connector->cmdline_mode; 2056 if (cmdline_mode->specified == false) 2057 return NULL; 2058 2059 /* attempt to find a matching mode in the list of modes 2060 * we have gotten so far, if not add a CVT mode that conforms 2061 */ 2062 if (cmdline_mode->rb || cmdline_mode->margins) 2063 goto create_mode; 2064 2065 prefer_non_interlace = !cmdline_mode->interlace; 2066 again: 2067 list_for_each_entry(mode, &fb_helper_conn->connector->modes, head) { 2068 /* check width/height */ 2069 if (mode->hdisplay != cmdline_mode->xres || 2070 mode->vdisplay != cmdline_mode->yres) 2071 continue; 2072 2073 if (cmdline_mode->refresh_specified) { 2074 if (mode->vrefresh != cmdline_mode->refresh) 2075 continue; 2076 } 2077 2078 if (cmdline_mode->interlace) { 2079 if (!(mode->flags & DRM_MODE_FLAG_INTERLACE)) 2080 continue; 2081 } else if (prefer_non_interlace) { 2082 if (mode->flags & DRM_MODE_FLAG_INTERLACE) 2083 continue; 2084 } 2085 return mode; 2086 } 2087 2088 if (prefer_non_interlace) { 2089 prefer_non_interlace = false; 2090 goto again; 2091 } 2092 2093 create_mode: 2094 mode = drm_mode_create_from_cmdline_mode(fb_helper_conn->connector->dev, 2095 cmdline_mode); 2096 list_add(&mode->head, &fb_helper_conn->connector->modes); 2097 return mode; 2098 } 2099 EXPORT_SYMBOL(drm_pick_cmdline_mode); 2100 2101 static bool drm_connector_enabled(struct drm_connector *connector, bool strict) 2102 { 2103 bool enable; 2104 2105 if (connector->display_info.non_desktop) 2106 return false; 2107 2108 if (strict) 2109 enable = connector->status == connector_status_connected; 2110 else 2111 enable = connector->status != connector_status_disconnected; 2112 2113 return enable; 2114 } 2115 2116 static void drm_enable_connectors(struct drm_fb_helper *fb_helper, 2117 bool *enabled) 2118 { 2119 bool any_enabled = false; 2120 struct drm_connector *connector; 2121 int i = 0; 2122 2123 drm_fb_helper_for_each_connector(fb_helper, i) { 2124 connector = fb_helper->connector_info[i]->connector; 2125 enabled[i] = drm_connector_enabled(connector, true); 2126 DRM_DEBUG_KMS("connector %d enabled? %s\n", connector->base.id, 2127 connector->display_info.non_desktop ? "non desktop" : enabled[i] ? "yes" : "no"); 2128 2129 any_enabled |= enabled[i]; 2130 } 2131 2132 if (any_enabled) 2133 return; 2134 2135 drm_fb_helper_for_each_connector(fb_helper, i) { 2136 connector = fb_helper->connector_info[i]->connector; 2137 enabled[i] = drm_connector_enabled(connector, false); 2138 } 2139 } 2140 2141 static bool drm_target_cloned(struct drm_fb_helper *fb_helper, 2142 struct drm_display_mode **modes, 2143 struct drm_fb_offset *offsets, 2144 bool *enabled, int width, int height) 2145 { 2146 int count, i, j; 2147 bool can_clone = false; 2148 struct drm_fb_helper_connector *fb_helper_conn; 2149 struct drm_display_mode *dmt_mode, *mode; 2150 2151 /* only contemplate cloning in the single crtc case */ 2152 if (fb_helper->crtc_count > 1) 2153 return false; 2154 2155 count = 0; 2156 drm_fb_helper_for_each_connector(fb_helper, i) { 2157 if (enabled[i]) 2158 count++; 2159 } 2160 2161 /* only contemplate cloning if more than one connector is enabled */ 2162 if (count <= 1) 2163 return false; 2164 2165 /* check the command line or if nothing common pick 1024x768 */ 2166 can_clone = true; 2167 drm_fb_helper_for_each_connector(fb_helper, i) { 2168 if (!enabled[i]) 2169 continue; 2170 fb_helper_conn = fb_helper->connector_info[i]; 2171 modes[i] = drm_pick_cmdline_mode(fb_helper_conn); 2172 if (!modes[i]) { 2173 can_clone = false; 2174 break; 2175 } 2176 for (j = 0; j < i; j++) { 2177 if (!enabled[j]) 2178 continue; 2179 if (!drm_mode_match(modes[j], modes[i], 2180 DRM_MODE_MATCH_TIMINGS | 2181 DRM_MODE_MATCH_CLOCK | 2182 DRM_MODE_MATCH_FLAGS | 2183 DRM_MODE_MATCH_3D_FLAGS)) 2184 can_clone = false; 2185 } 2186 } 2187 2188 if (can_clone) { 2189 DRM_DEBUG_KMS("can clone using command line\n"); 2190 return true; 2191 } 2192 2193 /* try and find a 1024x768 mode on each connector */ 2194 can_clone = true; 2195 dmt_mode = drm_mode_find_dmt(fb_helper->dev, 1024, 768, 60, false); 2196 2197 drm_fb_helper_for_each_connector(fb_helper, i) { 2198 if (!enabled[i]) 2199 continue; 2200 2201 fb_helper_conn = fb_helper->connector_info[i]; 2202 list_for_each_entry(mode, &fb_helper_conn->connector->modes, head) { 2203 if (drm_mode_match(mode, dmt_mode, 2204 DRM_MODE_MATCH_TIMINGS | 2205 DRM_MODE_MATCH_CLOCK | 2206 DRM_MODE_MATCH_FLAGS | 2207 DRM_MODE_MATCH_3D_FLAGS)) 2208 modes[i] = mode; 2209 } 2210 if (!modes[i]) 2211 can_clone = false; 2212 } 2213 2214 if (can_clone) { 2215 DRM_DEBUG_KMS("can clone using 1024x768\n"); 2216 return true; 2217 } 2218 DRM_INFO("kms: can't enable cloning when we probably wanted to.\n"); 2219 return false; 2220 } 2221 2222 static int drm_get_tile_offsets(struct drm_fb_helper *fb_helper, 2223 struct drm_display_mode **modes, 2224 struct drm_fb_offset *offsets, 2225 int idx, 2226 int h_idx, int v_idx) 2227 { 2228 struct drm_fb_helper_connector *fb_helper_conn; 2229 int i; 2230 int hoffset = 0, voffset = 0; 2231 2232 drm_fb_helper_for_each_connector(fb_helper, i) { 2233 fb_helper_conn = fb_helper->connector_info[i]; 2234 if (!fb_helper_conn->connector->has_tile) 2235 continue; 2236 2237 if (!modes[i] && (h_idx || v_idx)) { 2238 DRM_DEBUG_KMS("no modes for connector tiled %d %d\n", i, 2239 fb_helper_conn->connector->base.id); 2240 continue; 2241 } 2242 if (fb_helper_conn->connector->tile_h_loc < h_idx) 2243 hoffset += modes[i]->hdisplay; 2244 2245 if (fb_helper_conn->connector->tile_v_loc < v_idx) 2246 voffset += modes[i]->vdisplay; 2247 } 2248 offsets[idx].x = hoffset; 2249 offsets[idx].y = voffset; 2250 DRM_DEBUG_KMS("returned %d %d for %d %d\n", hoffset, voffset, h_idx, v_idx); 2251 return 0; 2252 } 2253 2254 static bool drm_target_preferred(struct drm_fb_helper *fb_helper, 2255 struct drm_display_mode **modes, 2256 struct drm_fb_offset *offsets, 2257 bool *enabled, int width, int height) 2258 { 2259 struct drm_fb_helper_connector *fb_helper_conn; 2260 const u64 mask = BIT_ULL(fb_helper->connector_count) - 1; 2261 u64 conn_configured = 0; 2262 int tile_pass = 0; 2263 int i; 2264 2265 retry: 2266 drm_fb_helper_for_each_connector(fb_helper, i) { 2267 fb_helper_conn = fb_helper->connector_info[i]; 2268 2269 if (conn_configured & BIT_ULL(i)) 2270 continue; 2271 2272 if (enabled[i] == false) { 2273 conn_configured |= BIT_ULL(i); 2274 continue; 2275 } 2276 2277 /* first pass over all the untiled connectors */ 2278 if (tile_pass == 0 && fb_helper_conn->connector->has_tile) 2279 continue; 2280 2281 if (tile_pass == 1) { 2282 if (fb_helper_conn->connector->tile_h_loc != 0 || 2283 fb_helper_conn->connector->tile_v_loc != 0) 2284 continue; 2285 2286 } else { 2287 if (fb_helper_conn->connector->tile_h_loc != tile_pass - 1 && 2288 fb_helper_conn->connector->tile_v_loc != tile_pass - 1) 2289 /* if this tile_pass doesn't cover any of the tiles - keep going */ 2290 continue; 2291 2292 /* 2293 * find the tile offsets for this pass - need to find 2294 * all tiles left and above 2295 */ 2296 drm_get_tile_offsets(fb_helper, modes, offsets, 2297 i, fb_helper_conn->connector->tile_h_loc, fb_helper_conn->connector->tile_v_loc); 2298 } 2299 DRM_DEBUG_KMS("looking for cmdline mode on connector %d\n", 2300 fb_helper_conn->connector->base.id); 2301 2302 /* got for command line mode first */ 2303 modes[i] = drm_pick_cmdline_mode(fb_helper_conn); 2304 if (!modes[i]) { 2305 DRM_DEBUG_KMS("looking for preferred mode on connector %d %d\n", 2306 fb_helper_conn->connector->base.id, fb_helper_conn->connector->tile_group ? fb_helper_conn->connector->tile_group->id : 0); 2307 modes[i] = drm_has_preferred_mode(fb_helper_conn, width, height); 2308 } 2309 /* No preferred modes, pick one off the list */ 2310 if (!modes[i] && !list_empty(&fb_helper_conn->connector->modes)) { 2311 list_for_each_entry(modes[i], &fb_helper_conn->connector->modes, head) 2312 break; 2313 } 2314 DRM_DEBUG_KMS("found mode %s\n", modes[i] ? modes[i]->name : 2315 "none"); 2316 conn_configured |= BIT_ULL(i); 2317 } 2318 2319 if ((conn_configured & mask) != mask) { 2320 tile_pass++; 2321 goto retry; 2322 } 2323 return true; 2324 } 2325 2326 static int drm_pick_crtcs(struct drm_fb_helper *fb_helper, 2327 struct drm_fb_helper_crtc **best_crtcs, 2328 struct drm_display_mode **modes, 2329 int n, int width, int height) 2330 { 2331 int c, o; 2332 struct drm_connector *connector; 2333 const struct drm_connector_helper_funcs *connector_funcs; 2334 struct drm_encoder *encoder; 2335 int my_score, best_score, score; 2336 struct drm_fb_helper_crtc **crtcs, *crtc; 2337 struct drm_fb_helper_connector *fb_helper_conn; 2338 2339 if (n == fb_helper->connector_count) 2340 return 0; 2341 2342 fb_helper_conn = fb_helper->connector_info[n]; 2343 connector = fb_helper_conn->connector; 2344 2345 best_crtcs[n] = NULL; 2346 best_score = drm_pick_crtcs(fb_helper, best_crtcs, modes, n+1, width, height); 2347 if (modes[n] == NULL) 2348 return best_score; 2349 2350 crtcs = kcalloc(fb_helper->connector_count, 2351 sizeof(struct drm_fb_helper_crtc *), GFP_KERNEL); 2352 if (!crtcs) 2353 return best_score; 2354 2355 my_score = 1; 2356 if (connector->status == connector_status_connected) 2357 my_score++; 2358 if (drm_has_cmdline_mode(fb_helper_conn)) 2359 my_score++; 2360 if (drm_has_preferred_mode(fb_helper_conn, width, height)) 2361 my_score++; 2362 2363 connector_funcs = connector->helper_private; 2364 2365 /* 2366 * If the DRM device implements atomic hooks and ->best_encoder() is 2367 * NULL we fallback to the default drm_atomic_helper_best_encoder() 2368 * helper. 2369 */ 2370 if (drm_drv_uses_atomic_modeset(fb_helper->dev) && 2371 !connector_funcs->best_encoder) 2372 encoder = drm_atomic_helper_best_encoder(connector); 2373 else 2374 encoder = connector_funcs->best_encoder(connector); 2375 2376 if (!encoder) 2377 goto out; 2378 2379 /* 2380 * select a crtc for this connector and then attempt to configure 2381 * remaining connectors 2382 */ 2383 for (c = 0; c < fb_helper->crtc_count; c++) { 2384 crtc = &fb_helper->crtc_info[c]; 2385 2386 if ((encoder->possible_crtcs & (1 << c)) == 0) 2387 continue; 2388 2389 for (o = 0; o < n; o++) 2390 if (best_crtcs[o] == crtc) 2391 break; 2392 2393 if (o < n) { 2394 /* ignore cloning unless only a single crtc */ 2395 if (fb_helper->crtc_count > 1) 2396 continue; 2397 2398 if (!drm_mode_equal(modes[o], modes[n])) 2399 continue; 2400 } 2401 2402 crtcs[n] = crtc; 2403 memcpy(crtcs, best_crtcs, n * sizeof(struct drm_fb_helper_crtc *)); 2404 score = my_score + drm_pick_crtcs(fb_helper, crtcs, modes, n + 1, 2405 width, height); 2406 if (score > best_score) { 2407 best_score = score; 2408 memcpy(best_crtcs, crtcs, 2409 fb_helper->connector_count * 2410 sizeof(struct drm_fb_helper_crtc *)); 2411 } 2412 } 2413 out: 2414 kfree(crtcs); 2415 return best_score; 2416 } 2417 2418 /* 2419 * This function checks if rotation is necessary because of panel orientation 2420 * and if it is, if it is supported. 2421 * If rotation is necessary and supported, its gets set in fb_crtc.rotation. 2422 * If rotation is necessary but not supported, a DRM_MODE_ROTATE_* flag gets 2423 * or-ed into fb_helper->sw_rotations. In drm_setup_crtcs_fb() we check if only 2424 * one bit is set and then we set fb_info.fbcon_rotate_hint to make fbcon do 2425 * the unsupported rotation. 2426 */ 2427 static void drm_setup_crtc_rotation(struct drm_fb_helper *fb_helper, 2428 struct drm_fb_helper_crtc *fb_crtc, 2429 struct drm_connector *connector) 2430 { 2431 struct drm_plane *plane = fb_crtc->mode_set.crtc->primary; 2432 uint64_t valid_mask = 0; 2433 int i, rotation; 2434 2435 fb_crtc->rotation = DRM_MODE_ROTATE_0; 2436 2437 switch (connector->display_info.panel_orientation) { 2438 case DRM_MODE_PANEL_ORIENTATION_BOTTOM_UP: 2439 rotation = DRM_MODE_ROTATE_180; 2440 break; 2441 case DRM_MODE_PANEL_ORIENTATION_LEFT_UP: 2442 rotation = DRM_MODE_ROTATE_90; 2443 break; 2444 case DRM_MODE_PANEL_ORIENTATION_RIGHT_UP: 2445 rotation = DRM_MODE_ROTATE_270; 2446 break; 2447 default: 2448 rotation = DRM_MODE_ROTATE_0; 2449 } 2450 2451 /* 2452 * TODO: support 90 / 270 degree hardware rotation, 2453 * depending on the hardware this may require the framebuffer 2454 * to be in a specific tiling format. 2455 */ 2456 if (rotation != DRM_MODE_ROTATE_180 || !plane->rotation_property) { 2457 fb_helper->sw_rotations |= rotation; 2458 return; 2459 } 2460 2461 for (i = 0; i < plane->rotation_property->num_values; i++) 2462 valid_mask |= (1ULL << plane->rotation_property->values[i]); 2463 2464 if (!(rotation & valid_mask)) { 2465 fb_helper->sw_rotations |= rotation; 2466 return; 2467 } 2468 2469 fb_crtc->rotation = rotation; 2470 /* Rotating in hardware, fbcon should not rotate */ 2471 fb_helper->sw_rotations |= DRM_MODE_ROTATE_0; 2472 } 2473 2474 static void drm_setup_crtcs(struct drm_fb_helper *fb_helper, 2475 u32 width, u32 height) 2476 { 2477 struct drm_device *dev = fb_helper->dev; 2478 struct drm_fb_helper_crtc **crtcs; 2479 struct drm_display_mode **modes; 2480 struct drm_fb_offset *offsets; 2481 bool *enabled; 2482 int i; 2483 2484 DRM_DEBUG_KMS("\n"); 2485 /* prevent concurrent modification of connector_count by hotplug */ 2486 lockdep_assert_held(&fb_helper->lock); 2487 2488 crtcs = kcalloc(fb_helper->connector_count, 2489 sizeof(struct drm_fb_helper_crtc *), GFP_KERNEL); 2490 modes = kcalloc(fb_helper->connector_count, 2491 sizeof(struct drm_display_mode *), GFP_KERNEL); 2492 offsets = kcalloc(fb_helper->connector_count, 2493 sizeof(struct drm_fb_offset), GFP_KERNEL); 2494 enabled = kcalloc(fb_helper->connector_count, 2495 sizeof(bool), GFP_KERNEL); 2496 if (!crtcs || !modes || !enabled || !offsets) { 2497 DRM_ERROR("Memory allocation failed\n"); 2498 goto out; 2499 } 2500 2501 mutex_lock(&fb_helper->dev->mode_config.mutex); 2502 if (drm_fb_helper_probe_connector_modes(fb_helper, width, height) == 0) 2503 DRM_DEBUG_KMS("No connectors reported connected with modes\n"); 2504 drm_enable_connectors(fb_helper, enabled); 2505 2506 if (!(fb_helper->funcs->initial_config && 2507 fb_helper->funcs->initial_config(fb_helper, crtcs, modes, 2508 offsets, 2509 enabled, width, height))) { 2510 memset(modes, 0, fb_helper->connector_count*sizeof(modes[0])); 2511 memset(crtcs, 0, fb_helper->connector_count*sizeof(crtcs[0])); 2512 memset(offsets, 0, fb_helper->connector_count*sizeof(offsets[0])); 2513 2514 if (!drm_target_cloned(fb_helper, modes, offsets, 2515 enabled, width, height) && 2516 !drm_target_preferred(fb_helper, modes, offsets, 2517 enabled, width, height)) 2518 DRM_ERROR("Unable to find initial modes\n"); 2519 2520 DRM_DEBUG_KMS("picking CRTCs for %dx%d config\n", 2521 width, height); 2522 2523 drm_pick_crtcs(fb_helper, crtcs, modes, 0, width, height); 2524 } 2525 mutex_unlock(&fb_helper->dev->mode_config.mutex); 2526 2527 /* need to set the modesets up here for use later */ 2528 /* fill out the connector<->crtc mappings into the modesets */ 2529 for (i = 0; i < fb_helper->crtc_count; i++) 2530 drm_fb_helper_modeset_release(fb_helper, 2531 &fb_helper->crtc_info[i].mode_set); 2532 2533 fb_helper->sw_rotations = 0; 2534 drm_fb_helper_for_each_connector(fb_helper, i) { 2535 struct drm_display_mode *mode = modes[i]; 2536 struct drm_fb_helper_crtc *fb_crtc = crtcs[i]; 2537 struct drm_fb_offset *offset = &offsets[i]; 2538 2539 if (mode && fb_crtc) { 2540 struct drm_mode_set *modeset = &fb_crtc->mode_set; 2541 struct drm_connector *connector = 2542 fb_helper->connector_info[i]->connector; 2543 2544 DRM_DEBUG_KMS("desired mode %s set on crtc %d (%d,%d)\n", 2545 mode->name, fb_crtc->mode_set.crtc->base.id, offset->x, offset->y); 2546 2547 fb_crtc->desired_mode = mode; 2548 fb_crtc->x = offset->x; 2549 fb_crtc->y = offset->y; 2550 modeset->mode = drm_mode_duplicate(dev, 2551 fb_crtc->desired_mode); 2552 drm_connector_get(connector); 2553 drm_setup_crtc_rotation(fb_helper, fb_crtc, connector); 2554 modeset->connectors[modeset->num_connectors++] = connector; 2555 modeset->x = offset->x; 2556 modeset->y = offset->y; 2557 } 2558 } 2559 out: 2560 kfree(crtcs); 2561 kfree(modes); 2562 kfree(offsets); 2563 kfree(enabled); 2564 } 2565 2566 /* 2567 * This is a continuation of drm_setup_crtcs() that sets up anything related 2568 * to the framebuffer. During initialization, drm_setup_crtcs() is called before 2569 * the framebuffer has been allocated (fb_helper->fb and fb_helper->fbdev). 2570 * So, any setup that touches those fields needs to be done here instead of in 2571 * drm_setup_crtcs(). 2572 */ 2573 static void drm_setup_crtcs_fb(struct drm_fb_helper *fb_helper) 2574 { 2575 struct fb_info *info = fb_helper->fbdev; 2576 int i; 2577 2578 for (i = 0; i < fb_helper->crtc_count; i++) 2579 if (fb_helper->crtc_info[i].mode_set.num_connectors) 2580 fb_helper->crtc_info[i].mode_set.fb = fb_helper->fb; 2581 2582 mutex_lock(&fb_helper->dev->mode_config.mutex); 2583 drm_fb_helper_for_each_connector(fb_helper, i) { 2584 struct drm_connector *connector = 2585 fb_helper->connector_info[i]->connector; 2586 2587 /* use first connected connector for the physical dimensions */ 2588 if (connector->status == connector_status_connected) { 2589 info->var.width = connector->display_info.width_mm; 2590 info->var.height = connector->display_info.height_mm; 2591 break; 2592 } 2593 } 2594 mutex_unlock(&fb_helper->dev->mode_config.mutex); 2595 2596 switch (fb_helper->sw_rotations) { 2597 case DRM_MODE_ROTATE_0: 2598 info->fbcon_rotate_hint = FB_ROTATE_UR; 2599 break; 2600 case DRM_MODE_ROTATE_90: 2601 info->fbcon_rotate_hint = FB_ROTATE_CCW; 2602 break; 2603 case DRM_MODE_ROTATE_180: 2604 info->fbcon_rotate_hint = FB_ROTATE_UD; 2605 break; 2606 case DRM_MODE_ROTATE_270: 2607 info->fbcon_rotate_hint = FB_ROTATE_CW; 2608 break; 2609 default: 2610 /* 2611 * Multiple bits are set / multiple rotations requested 2612 * fbcon cannot handle separate rotation settings per 2613 * output, so fallback to unrotated. 2614 */ 2615 info->fbcon_rotate_hint = FB_ROTATE_UR; 2616 } 2617 } 2618 2619 /* Note: Drops fb_helper->lock before returning. */ 2620 static int 2621 __drm_fb_helper_initial_config_and_unlock(struct drm_fb_helper *fb_helper, 2622 int bpp_sel) 2623 { 2624 struct drm_device *dev = fb_helper->dev; 2625 struct fb_info *info; 2626 unsigned int width, height; 2627 int ret; 2628 2629 width = dev->mode_config.max_width; 2630 height = dev->mode_config.max_height; 2631 2632 drm_setup_crtcs(fb_helper, width, height); 2633 ret = drm_fb_helper_single_fb_probe(fb_helper, bpp_sel); 2634 if (ret < 0) { 2635 if (ret == -EAGAIN) { 2636 fb_helper->preferred_bpp = bpp_sel; 2637 fb_helper->deferred_setup = true; 2638 ret = 0; 2639 } 2640 mutex_unlock(&fb_helper->lock); 2641 2642 return ret; 2643 } 2644 drm_setup_crtcs_fb(fb_helper); 2645 2646 fb_helper->deferred_setup = false; 2647 2648 info = fb_helper->fbdev; 2649 info->var.pixclock = 0; 2650 2651 /* Need to drop locks to avoid recursive deadlock in 2652 * register_framebuffer. This is ok because the only thing left to do is 2653 * register the fbdev emulation instance in kernel_fb_helper_list. */ 2654 mutex_unlock(&fb_helper->lock); 2655 2656 ret = register_framebuffer(info); 2657 if (ret < 0) 2658 return ret; 2659 2660 dev_info(dev->dev, "fb%d: %s frame buffer device\n", 2661 info->node, info->fix.id); 2662 2663 mutex_lock(&kernel_fb_helper_lock); 2664 if (list_empty(&kernel_fb_helper_list)) 2665 register_sysrq_key('v', &sysrq_drm_fb_helper_restore_op); 2666 2667 list_add(&fb_helper->kernel_fb_list, &kernel_fb_helper_list); 2668 mutex_unlock(&kernel_fb_helper_lock); 2669 2670 return 0; 2671 } 2672 2673 /** 2674 * drm_fb_helper_initial_config - setup a sane initial connector configuration 2675 * @fb_helper: fb_helper device struct 2676 * @bpp_sel: bpp value to use for the framebuffer configuration 2677 * 2678 * Scans the CRTCs and connectors and tries to put together an initial setup. 2679 * At the moment, this is a cloned configuration across all heads with 2680 * a new framebuffer object as the backing store. 2681 * 2682 * Note that this also registers the fbdev and so allows userspace to call into 2683 * the driver through the fbdev interfaces. 2684 * 2685 * This function will call down into the &drm_fb_helper_funcs.fb_probe callback 2686 * to let the driver allocate and initialize the fbdev info structure and the 2687 * drm framebuffer used to back the fbdev. drm_fb_helper_fill_var() and 2688 * drm_fb_helper_fill_fix() are provided as helpers to setup simple default 2689 * values for the fbdev info structure. 2690 * 2691 * HANG DEBUGGING: 2692 * 2693 * When you have fbcon support built-in or already loaded, this function will do 2694 * a full modeset to setup the fbdev console. Due to locking misdesign in the 2695 * VT/fbdev subsystem that entire modeset sequence has to be done while holding 2696 * console_lock. Until console_unlock is called no dmesg lines will be sent out 2697 * to consoles, not even serial console. This means when your driver crashes, 2698 * you will see absolutely nothing else but a system stuck in this function, 2699 * with no further output. Any kind of printk() you place within your own driver 2700 * or in the drm core modeset code will also never show up. 2701 * 2702 * Standard debug practice is to run the fbcon setup without taking the 2703 * console_lock as a hack, to be able to see backtraces and crashes on the 2704 * serial line. This can be done by setting the fb.lockless_register_fb=1 kernel 2705 * cmdline option. 2706 * 2707 * The other option is to just disable fbdev emulation since very likely the 2708 * first modeset from userspace will crash in the same way, and is even easier 2709 * to debug. This can be done by setting the drm_kms_helper.fbdev_emulation=0 2710 * kernel cmdline option. 2711 * 2712 * RETURNS: 2713 * Zero if everything went ok, nonzero otherwise. 2714 */ 2715 int drm_fb_helper_initial_config(struct drm_fb_helper *fb_helper, int bpp_sel) 2716 { 2717 int ret; 2718 2719 if (!drm_fbdev_emulation) 2720 return 0; 2721 2722 mutex_lock(&fb_helper->lock); 2723 ret = __drm_fb_helper_initial_config_and_unlock(fb_helper, bpp_sel); 2724 2725 return ret; 2726 } 2727 EXPORT_SYMBOL(drm_fb_helper_initial_config); 2728 2729 /** 2730 * drm_fb_helper_hotplug_event - respond to a hotplug notification by 2731 * probing all the outputs attached to the fb 2732 * @fb_helper: driver-allocated fbdev helper, can be NULL 2733 * 2734 * Scan the connectors attached to the fb_helper and try to put together a 2735 * setup after notification of a change in output configuration. 2736 * 2737 * Called at runtime, takes the mode config locks to be able to check/change the 2738 * modeset configuration. Must be run from process context (which usually means 2739 * either the output polling work or a work item launched from the driver's 2740 * hotplug interrupt). 2741 * 2742 * Note that drivers may call this even before calling 2743 * drm_fb_helper_initial_config but only after drm_fb_helper_init. This allows 2744 * for a race-free fbcon setup and will make sure that the fbdev emulation will 2745 * not miss any hotplug events. 2746 * 2747 * RETURNS: 2748 * 0 on success and a non-zero error code otherwise. 2749 */ 2750 int drm_fb_helper_hotplug_event(struct drm_fb_helper *fb_helper) 2751 { 2752 int err = 0; 2753 2754 if (!drm_fbdev_emulation || !fb_helper) 2755 return 0; 2756 2757 mutex_lock(&fb_helper->lock); 2758 if (fb_helper->deferred_setup) { 2759 err = __drm_fb_helper_initial_config_and_unlock(fb_helper, 2760 fb_helper->preferred_bpp); 2761 return err; 2762 } 2763 2764 if (!fb_helper->fb || !drm_fb_helper_is_bound(fb_helper)) { 2765 fb_helper->delayed_hotplug = true; 2766 mutex_unlock(&fb_helper->lock); 2767 return err; 2768 } 2769 2770 DRM_DEBUG_KMS("\n"); 2771 2772 drm_setup_crtcs(fb_helper, fb_helper->fb->width, fb_helper->fb->height); 2773 drm_setup_crtcs_fb(fb_helper); 2774 mutex_unlock(&fb_helper->lock); 2775 2776 drm_fb_helper_set_par(fb_helper->fbdev); 2777 2778 return 0; 2779 } 2780 EXPORT_SYMBOL(drm_fb_helper_hotplug_event); 2781 2782 /** 2783 * drm_fb_helper_fbdev_setup() - Setup fbdev emulation 2784 * @dev: DRM device 2785 * @fb_helper: fbdev helper structure to set up 2786 * @funcs: fbdev helper functions 2787 * @preferred_bpp: Preferred bits per pixel for the device. 2788 * @dev->mode_config.preferred_depth is used if this is zero. 2789 * @max_conn_count: Maximum number of connectors. 2790 * @dev->mode_config.num_connector is used if this is zero. 2791 * 2792 * This function sets up fbdev emulation and registers fbdev for access by 2793 * userspace. If all connectors are disconnected, setup is deferred to the next 2794 * time drm_fb_helper_hotplug_event() is called. 2795 * The caller must to provide a &drm_fb_helper_funcs->fb_probe callback 2796 * function. 2797 * 2798 * See also: drm_fb_helper_initial_config() 2799 * 2800 * Returns: 2801 * Zero on success or negative error code on failure. 2802 */ 2803 int drm_fb_helper_fbdev_setup(struct drm_device *dev, 2804 struct drm_fb_helper *fb_helper, 2805 const struct drm_fb_helper_funcs *funcs, 2806 unsigned int preferred_bpp, 2807 unsigned int max_conn_count) 2808 { 2809 int ret; 2810 2811 if (!preferred_bpp) 2812 preferred_bpp = dev->mode_config.preferred_depth; 2813 if (!preferred_bpp) 2814 preferred_bpp = 32; 2815 2816 if (!max_conn_count) 2817 max_conn_count = dev->mode_config.num_connector; 2818 if (!max_conn_count) { 2819 DRM_DEV_ERROR(dev->dev, "No connectors\n"); 2820 return -EINVAL; 2821 } 2822 2823 drm_fb_helper_prepare(dev, fb_helper, funcs); 2824 2825 ret = drm_fb_helper_init(dev, fb_helper, max_conn_count); 2826 if (ret < 0) { 2827 DRM_DEV_ERROR(dev->dev, "Failed to initialize fbdev helper\n"); 2828 return ret; 2829 } 2830 2831 ret = drm_fb_helper_single_add_all_connectors(fb_helper); 2832 if (ret < 0) { 2833 DRM_DEV_ERROR(dev->dev, "Failed to add connectors\n"); 2834 goto err_drm_fb_helper_fini; 2835 } 2836 2837 if (!drm_drv_uses_atomic_modeset(dev)) 2838 drm_helper_disable_unused_functions(dev); 2839 2840 ret = drm_fb_helper_initial_config(fb_helper, preferred_bpp); 2841 if (ret < 0) { 2842 DRM_DEV_ERROR(dev->dev, "Failed to set fbdev configuration\n"); 2843 goto err_drm_fb_helper_fini; 2844 } 2845 2846 return 0; 2847 2848 err_drm_fb_helper_fini: 2849 drm_fb_helper_fini(fb_helper); 2850 2851 return ret; 2852 } 2853 EXPORT_SYMBOL(drm_fb_helper_fbdev_setup); 2854 2855 /** 2856 * drm_fb_helper_fbdev_teardown - Tear down fbdev emulation 2857 * @dev: DRM device 2858 * 2859 * This function unregisters fbdev if not already done and cleans up the 2860 * associated resources including the &drm_framebuffer. 2861 * The driver is responsible for freeing the &drm_fb_helper structure which is 2862 * stored in &drm_device->fb_helper. Do note that this pointer has been cleared 2863 * when this function returns. 2864 * 2865 * In order to support device removal/unplug while file handles are still open, 2866 * drm_fb_helper_unregister_fbi() should be called on device removal and 2867 * drm_fb_helper_fbdev_teardown() in the &drm_driver->release callback when 2868 * file handles are closed. 2869 */ 2870 void drm_fb_helper_fbdev_teardown(struct drm_device *dev) 2871 { 2872 struct drm_fb_helper *fb_helper = dev->fb_helper; 2873 struct fb_ops *fbops = NULL; 2874 2875 if (!fb_helper) 2876 return; 2877 2878 /* Unregister if it hasn't been done already */ 2879 if (fb_helper->fbdev && fb_helper->fbdev->dev) 2880 drm_fb_helper_unregister_fbi(fb_helper); 2881 2882 if (fb_helper->fbdev && fb_helper->fbdev->fbdefio) { 2883 fb_deferred_io_cleanup(fb_helper->fbdev); 2884 kfree(fb_helper->fbdev->fbdefio); 2885 fbops = fb_helper->fbdev->fbops; 2886 } 2887 2888 drm_fb_helper_fini(fb_helper); 2889 kfree(fbops); 2890 2891 if (fb_helper->fb) 2892 drm_framebuffer_remove(fb_helper->fb); 2893 } 2894 EXPORT_SYMBOL(drm_fb_helper_fbdev_teardown); 2895 2896 /** 2897 * drm_fb_helper_lastclose - DRM driver lastclose helper for fbdev emulation 2898 * @dev: DRM device 2899 * 2900 * This function can be used as the &drm_driver->lastclose callback for drivers 2901 * that only need to call drm_fb_helper_restore_fbdev_mode_unlocked(). 2902 */ 2903 void drm_fb_helper_lastclose(struct drm_device *dev) 2904 { 2905 drm_fb_helper_restore_fbdev_mode_unlocked(dev->fb_helper); 2906 } 2907 EXPORT_SYMBOL(drm_fb_helper_lastclose); 2908 2909 /** 2910 * drm_fb_helper_output_poll_changed - DRM mode config \.output_poll_changed 2911 * helper for fbdev emulation 2912 * @dev: DRM device 2913 * 2914 * This function can be used as the 2915 * &drm_mode_config_funcs.output_poll_changed callback for drivers that only 2916 * need to call drm_fb_helper_hotplug_event(). 2917 */ 2918 void drm_fb_helper_output_poll_changed(struct drm_device *dev) 2919 { 2920 drm_fb_helper_hotplug_event(dev->fb_helper); 2921 } 2922 EXPORT_SYMBOL(drm_fb_helper_output_poll_changed); 2923 2924 /* The Kconfig DRM_KMS_HELPER selects FRAMEBUFFER_CONSOLE (if !EXPERT) 2925 * but the module doesn't depend on any fb console symbols. At least 2926 * attempt to load fbcon to avoid leaving the system without a usable console. 2927 */ 2928 int __init drm_fb_helper_modinit(void) 2929 { 2930 #if defined(CONFIG_FRAMEBUFFER_CONSOLE_MODULE) && !defined(CONFIG_EXPERT) 2931 const char name[] = "fbcon"; 2932 struct module *fbcon; 2933 2934 mutex_lock(&module_mutex); 2935 fbcon = find_module(name); 2936 mutex_unlock(&module_mutex); 2937 2938 if (!fbcon) 2939 request_module_nowait(name); 2940 #endif 2941 return 0; 2942 } 2943 EXPORT_SYMBOL(drm_fb_helper_modinit); 2944