2 * Copyright (c) 2006-2009 Red Hat Inc.
3 * Copyright (c) 2006-2008 Intel Corporation
4 * Copyright (c) 2007 Dave Airlie <airlied@linux.ie>
6 * DRM framebuffer helper functions
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.
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
27 * Dave Airlie <airlied@linux.ie>
28 * Jesse Barnes <jesse.barnes@intel.com>
30 #include <linux/kernel.h>
31 #include <linux/sysrq.h>
32 #include <linux/slab.h>
34 #include <linux/module.h>
37 #include "drm_fb_helper.h"
38 #include "drm_crtc_helper.h"
40 MODULE_AUTHOR("David Airlie, Jesse Barnes");
41 MODULE_DESCRIPTION("DRM KMS helper");
42 MODULE_LICENSE("GPL and additional rights");
44 static LIST_HEAD(kernel_fb_helper_list);
46 /* simple single crtc case helper function */
47 int drm_fb_helper_single_add_all_connectors(struct drm_fb_helper *fb_helper)
49 struct drm_device *dev = fb_helper->dev;
50 struct drm_connector *connector;
53 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
54 struct drm_fb_helper_connector *fb_helper_connector;
56 fb_helper_connector = kzalloc(sizeof(struct drm_fb_helper_connector), GFP_KERNEL);
57 if (!fb_helper_connector)
60 fb_helper_connector->connector = connector;
61 fb_helper->connector_info[fb_helper->connector_count++] = fb_helper_connector;
65 for (i = 0; i < fb_helper->connector_count; i++) {
66 kfree(fb_helper->connector_info[i]);
67 fb_helper->connector_info[i] = NULL;
69 fb_helper->connector_count = 0;
72 EXPORT_SYMBOL(drm_fb_helper_single_add_all_connectors);
74 static int drm_fb_helper_parse_command_line(struct drm_fb_helper *fb_helper)
76 struct drm_fb_helper_connector *fb_helper_conn;
79 for (i = 0; i < fb_helper->connector_count; i++) {
80 struct drm_cmdline_mode *mode;
81 struct drm_connector *connector;
84 fb_helper_conn = fb_helper->connector_info[i];
85 connector = fb_helper_conn->connector;
86 mode = &fb_helper_conn->cmdline_mode;
88 /* do something on return - turn off connector maybe */
89 if (fb_get_options(drm_get_connector_name(connector), &option))
92 if (drm_mode_parse_command_line_for_connector(option,
97 switch (mode->force) {
98 case DRM_FORCE_OFF: s = "OFF"; break;
99 case DRM_FORCE_ON_DIGITAL: s = "ON - dig"; break;
101 case DRM_FORCE_ON: s = "ON"; break;
104 DRM_INFO("forcing %s connector %s\n",
105 drm_get_connector_name(connector), s);
106 connector->force = mode->force;
109 DRM_DEBUG_KMS("cmdline mode for connector %s %dx%d@%dHz%s%s%s\n",
110 drm_get_connector_name(connector),
111 mode->xres, mode->yres,
112 mode->refresh_specified ? mode->refresh : 60,
113 mode->rb ? " reduced blanking" : "",
114 mode->margins ? " with margins" : "",
115 mode->interlace ? " interlaced" : "");
122 static void drm_fb_helper_save_lut_atomic(struct drm_crtc *crtc, struct drm_fb_helper *helper)
124 uint16_t *r_base, *g_base, *b_base;
127 r_base = crtc->gamma_store;
128 g_base = r_base + crtc->gamma_size;
129 b_base = g_base + crtc->gamma_size;
131 for (i = 0; i < crtc->gamma_size; i++)
132 helper->funcs->gamma_get(crtc, &r_base[i], &g_base[i], &b_base[i], i);
135 static void drm_fb_helper_restore_lut_atomic(struct drm_crtc *crtc)
137 uint16_t *r_base, *g_base, *b_base;
139 r_base = crtc->gamma_store;
140 g_base = r_base + crtc->gamma_size;
141 b_base = g_base + crtc->gamma_size;
143 crtc->funcs->gamma_set(crtc, r_base, g_base, b_base, 0, crtc->gamma_size);
146 int drm_fb_helper_debug_enter(struct fb_info *info)
148 struct drm_fb_helper *helper = info->par;
149 struct drm_crtc_helper_funcs *funcs;
152 if (list_empty(&kernel_fb_helper_list))
155 list_for_each_entry(helper, &kernel_fb_helper_list, kernel_fb_list) {
156 for (i = 0; i < helper->crtc_count; i++) {
157 struct drm_mode_set *mode_set =
158 &helper->crtc_info[i].mode_set;
160 if (!mode_set->crtc->enabled)
163 funcs = mode_set->crtc->helper_private;
164 drm_fb_helper_save_lut_atomic(mode_set->crtc, helper);
165 funcs->mode_set_base_atomic(mode_set->crtc,
169 ENTER_ATOMIC_MODE_SET);
175 EXPORT_SYMBOL(drm_fb_helper_debug_enter);
177 /* Find the real fb for a given fb helper CRTC */
178 static struct drm_framebuffer *drm_mode_config_fb(struct drm_crtc *crtc)
180 struct drm_device *dev = crtc->dev;
183 list_for_each_entry(c, &dev->mode_config.crtc_list, head) {
184 if (crtc->base.id == c->base.id)
191 int drm_fb_helper_debug_leave(struct fb_info *info)
193 struct drm_fb_helper *helper = info->par;
194 struct drm_crtc *crtc;
195 struct drm_crtc_helper_funcs *funcs;
196 struct drm_framebuffer *fb;
199 for (i = 0; i < helper->crtc_count; i++) {
200 struct drm_mode_set *mode_set = &helper->crtc_info[i].mode_set;
201 crtc = mode_set->crtc;
202 funcs = crtc->helper_private;
203 fb = drm_mode_config_fb(crtc);
209 DRM_ERROR("no fb to restore??\n");
213 drm_fb_helper_restore_lut_atomic(mode_set->crtc);
214 funcs->mode_set_base_atomic(mode_set->crtc, fb, crtc->x,
215 crtc->y, LEAVE_ATOMIC_MODE_SET);
220 EXPORT_SYMBOL(drm_fb_helper_debug_leave);
222 bool drm_fb_helper_restore_fbdev_mode(struct drm_fb_helper *fb_helper)
226 for (i = 0; i < fb_helper->crtc_count; i++) {
227 struct drm_mode_set *mode_set = &fb_helper->crtc_info[i].mode_set;
228 ret = drm_crtc_helper_set_config(mode_set);
234 EXPORT_SYMBOL(drm_fb_helper_restore_fbdev_mode);
236 bool drm_fb_helper_force_kernel_mode(void)
238 bool ret, error = false;
239 struct drm_fb_helper *helper;
241 if (list_empty(&kernel_fb_helper_list))
244 list_for_each_entry(helper, &kernel_fb_helper_list, kernel_fb_list) {
245 if (helper->dev->switch_power_state == DRM_SWITCH_POWER_OFF)
248 ret = drm_fb_helper_restore_fbdev_mode(helper);
255 int drm_fb_helper_panic(struct notifier_block *n, unsigned long ununsed,
259 * It's a waste of time and effort to switch back to text console
260 * if the kernel should reboot before panic messages can be seen.
262 if (panic_timeout < 0)
265 printk(KERN_ERR "panic occurred, switching back to text console\n");
266 return drm_fb_helper_force_kernel_mode();
268 EXPORT_SYMBOL(drm_fb_helper_panic);
270 static struct notifier_block paniced = {
271 .notifier_call = drm_fb_helper_panic,
275 * drm_fb_helper_restore - restore the framebuffer console (kernel) config
277 * Restore's the kernel's fbcon mode, used for lastclose & panic paths.
279 void drm_fb_helper_restore(void)
282 ret = drm_fb_helper_force_kernel_mode();
284 DRM_ERROR("Failed to restore crtc configuration\n");
286 EXPORT_SYMBOL(drm_fb_helper_restore);
288 #ifdef CONFIG_MAGIC_SYSRQ
289 static void drm_fb_helper_restore_work_fn(struct work_struct *ignored)
291 drm_fb_helper_restore();
293 static DECLARE_WORK(drm_fb_helper_restore_work, drm_fb_helper_restore_work_fn);
295 static void drm_fb_helper_sysrq(int dummy1)
297 schedule_work(&drm_fb_helper_restore_work);
300 static struct sysrq_key_op sysrq_drm_fb_helper_restore_op = {
301 .handler = drm_fb_helper_sysrq,
302 .help_msg = "force-fb(V)",
303 .action_msg = "Restore framebuffer console",
306 static struct sysrq_key_op sysrq_drm_fb_helper_restore_op = { };
309 static void drm_fb_helper_dpms(struct fb_info *info, int dpms_mode)
311 struct drm_fb_helper *fb_helper = info->par;
312 struct drm_device *dev = fb_helper->dev;
313 struct drm_crtc *crtc;
314 struct drm_connector *connector;
318 * For each CRTC in this fb, turn the connectors on/off.
320 mutex_lock(&dev->mode_config.mutex);
321 for (i = 0; i < fb_helper->crtc_count; i++) {
322 crtc = fb_helper->crtc_info[i].mode_set.crtc;
327 /* Walk the connectors & encoders on this fb turning them on/off */
328 for (j = 0; j < fb_helper->connector_count; j++) {
329 connector = fb_helper->connector_info[j]->connector;
330 drm_helper_connector_dpms(connector, dpms_mode);
331 drm_connector_property_set_value(connector,
332 dev->mode_config.dpms_property, dpms_mode);
335 mutex_unlock(&dev->mode_config.mutex);
338 int drm_fb_helper_blank(int blank, struct fb_info *info)
341 /* Display: On; HSync: On, VSync: On */
342 case FB_BLANK_UNBLANK:
343 drm_fb_helper_dpms(info, DRM_MODE_DPMS_ON);
345 /* Display: Off; HSync: On, VSync: On */
346 case FB_BLANK_NORMAL:
347 drm_fb_helper_dpms(info, DRM_MODE_DPMS_STANDBY);
349 /* Display: Off; HSync: Off, VSync: On */
350 case FB_BLANK_HSYNC_SUSPEND:
351 drm_fb_helper_dpms(info, DRM_MODE_DPMS_STANDBY);
353 /* Display: Off; HSync: On, VSync: Off */
354 case FB_BLANK_VSYNC_SUSPEND:
355 drm_fb_helper_dpms(info, DRM_MODE_DPMS_SUSPEND);
357 /* Display: Off; HSync: Off, VSync: Off */
358 case FB_BLANK_POWERDOWN:
359 drm_fb_helper_dpms(info, DRM_MODE_DPMS_OFF);
364 EXPORT_SYMBOL(drm_fb_helper_blank);
366 static void drm_fb_helper_crtc_free(struct drm_fb_helper *helper)
370 for (i = 0; i < helper->connector_count; i++)
371 kfree(helper->connector_info[i]);
372 kfree(helper->connector_info);
373 for (i = 0; i < helper->crtc_count; i++) {
374 kfree(helper->crtc_info[i].mode_set.connectors);
375 if (helper->crtc_info[i].mode_set.mode)
376 drm_mode_destroy(helper->dev, helper->crtc_info[i].mode_set.mode);
378 kfree(helper->crtc_info);
381 int drm_fb_helper_init(struct drm_device *dev,
382 struct drm_fb_helper *fb_helper,
383 int crtc_count, int max_conn_count)
385 struct drm_crtc *crtc;
389 fb_helper->dev = dev;
391 INIT_LIST_HEAD(&fb_helper->kernel_fb_list);
393 fb_helper->crtc_info = kcalloc(crtc_count, sizeof(struct drm_fb_helper_crtc), GFP_KERNEL);
394 if (!fb_helper->crtc_info)
397 fb_helper->crtc_count = crtc_count;
398 fb_helper->connector_info = kcalloc(dev->mode_config.num_connector, sizeof(struct drm_fb_helper_connector *), GFP_KERNEL);
399 if (!fb_helper->connector_info) {
400 kfree(fb_helper->crtc_info);
403 fb_helper->connector_count = 0;
405 for (i = 0; i < crtc_count; i++) {
406 fb_helper->crtc_info[i].mode_set.connectors =
407 kcalloc(max_conn_count,
408 sizeof(struct drm_connector *),
411 if (!fb_helper->crtc_info[i].mode_set.connectors) {
415 fb_helper->crtc_info[i].mode_set.num_connectors = 0;
419 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
420 fb_helper->crtc_info[i].mode_set.crtc = crtc;
426 drm_fb_helper_crtc_free(fb_helper);
429 EXPORT_SYMBOL(drm_fb_helper_init);
431 void drm_fb_helper_fini(struct drm_fb_helper *fb_helper)
433 if (!list_empty(&fb_helper->kernel_fb_list)) {
434 list_del(&fb_helper->kernel_fb_list);
435 if (list_empty(&kernel_fb_helper_list)) {
436 printk(KERN_INFO "drm: unregistered panic notifier\n");
437 atomic_notifier_chain_unregister(&panic_notifier_list,
439 unregister_sysrq_key('v', &sysrq_drm_fb_helper_restore_op);
443 drm_fb_helper_crtc_free(fb_helper);
446 EXPORT_SYMBOL(drm_fb_helper_fini);
448 static int setcolreg(struct drm_crtc *crtc, u16 red, u16 green,
449 u16 blue, u16 regno, struct fb_info *info)
451 struct drm_fb_helper *fb_helper = info->par;
452 struct drm_framebuffer *fb = fb_helper->fb;
455 if (info->fix.visual == FB_VISUAL_TRUECOLOR) {
458 /* place color in psuedopalette */
461 palette = (u32 *)info->pseudo_palette;
462 red >>= (16 - info->var.red.length);
463 green >>= (16 - info->var.green.length);
464 blue >>= (16 - info->var.blue.length);
465 value = (red << info->var.red.offset) |
466 (green << info->var.green.offset) |
467 (blue << info->var.blue.offset);
468 if (info->var.transp.length > 0) {
469 u32 mask = (1 << info->var.transp.length) - 1;
470 mask <<= info->var.transp.offset;
473 palette[regno] = value;
479 if (fb->bits_per_pixel == 16) {
482 if (fb->depth == 16 && regno > 63)
484 if (fb->depth == 15 && regno > 31)
487 if (fb->depth == 16) {
491 for (i = 0; i < 8; i++)
492 fb_helper->funcs->gamma_set(crtc, red,
493 green, blue, pindex + i);
496 fb_helper->funcs->gamma_get(crtc, &r,
500 for (i = 0; i < 4; i++)
501 fb_helper->funcs->gamma_set(crtc, r,
508 fb_helper->funcs->gamma_set(crtc, red, green, blue, pindex);
512 int drm_fb_helper_setcmap(struct fb_cmap *cmap, struct fb_info *info)
514 struct drm_fb_helper *fb_helper = info->par;
515 struct drm_crtc_helper_funcs *crtc_funcs;
516 u16 *red, *green, *blue, *transp;
517 struct drm_crtc *crtc;
521 for (i = 0; i < fb_helper->crtc_count; i++) {
522 crtc = fb_helper->crtc_info[i].mode_set.crtc;
523 crtc_funcs = crtc->helper_private;
528 transp = cmap->transp;
531 for (j = 0; j < cmap->len; j++) {
532 u16 hred, hgreen, hblue, htransp = 0xffff;
541 rc = setcolreg(crtc, hred, hgreen, hblue, start++, info);
545 crtc_funcs->load_lut(crtc);
549 EXPORT_SYMBOL(drm_fb_helper_setcmap);
551 int drm_fb_helper_check_var(struct fb_var_screeninfo *var,
552 struct fb_info *info)
554 struct drm_fb_helper *fb_helper = info->par;
555 struct drm_framebuffer *fb = fb_helper->fb;
558 if (var->pixclock != 0 || in_dbg_master())
561 /* Need to resize the fb object !!! */
562 if (var->bits_per_pixel > fb->bits_per_pixel || var->xres > fb->width || var->yres > fb->height) {
563 DRM_DEBUG("fb userspace requested width/height/bpp is greater than current fb "
564 "object %dx%d-%d > %dx%d-%d\n", var->xres, var->yres, var->bits_per_pixel,
565 fb->width, fb->height, fb->bits_per_pixel);
569 switch (var->bits_per_pixel) {
571 depth = (var->green.length == 6) ? 16 : 15;
574 depth = (var->transp.length > 0) ? 32 : 24;
577 depth = var->bits_per_pixel;
584 var->green.offset = 0;
585 var->blue.offset = 0;
587 var->green.length = 8;
588 var->blue.length = 8;
589 var->transp.length = 0;
590 var->transp.offset = 0;
593 var->red.offset = 10;
594 var->green.offset = 5;
595 var->blue.offset = 0;
597 var->green.length = 5;
598 var->blue.length = 5;
599 var->transp.length = 1;
600 var->transp.offset = 15;
603 var->red.offset = 11;
604 var->green.offset = 5;
605 var->blue.offset = 0;
607 var->green.length = 6;
608 var->blue.length = 5;
609 var->transp.length = 0;
610 var->transp.offset = 0;
613 var->red.offset = 16;
614 var->green.offset = 8;
615 var->blue.offset = 0;
617 var->green.length = 8;
618 var->blue.length = 8;
619 var->transp.length = 0;
620 var->transp.offset = 0;
623 var->red.offset = 16;
624 var->green.offset = 8;
625 var->blue.offset = 0;
627 var->green.length = 8;
628 var->blue.length = 8;
629 var->transp.length = 8;
630 var->transp.offset = 24;
637 EXPORT_SYMBOL(drm_fb_helper_check_var);
639 /* this will let fbcon do the mode init */
640 int drm_fb_helper_set_par(struct fb_info *info)
642 struct drm_fb_helper *fb_helper = info->par;
643 struct drm_device *dev = fb_helper->dev;
644 struct fb_var_screeninfo *var = &info->var;
645 struct drm_crtc *crtc;
649 if (var->pixclock != 0) {
650 DRM_ERROR("PIXEL CLOCK SET\n");
654 mutex_lock(&dev->mode_config.mutex);
655 for (i = 0; i < fb_helper->crtc_count; i++) {
656 crtc = fb_helper->crtc_info[i].mode_set.crtc;
657 ret = crtc->funcs->set_config(&fb_helper->crtc_info[i].mode_set);
659 mutex_unlock(&dev->mode_config.mutex);
663 mutex_unlock(&dev->mode_config.mutex);
665 if (fb_helper->delayed_hotplug) {
666 fb_helper->delayed_hotplug = false;
667 drm_fb_helper_hotplug_event(fb_helper);
671 EXPORT_SYMBOL(drm_fb_helper_set_par);
673 int drm_fb_helper_pan_display(struct fb_var_screeninfo *var,
674 struct fb_info *info)
676 struct drm_fb_helper *fb_helper = info->par;
677 struct drm_device *dev = fb_helper->dev;
678 struct drm_mode_set *modeset;
679 struct drm_crtc *crtc;
683 mutex_lock(&dev->mode_config.mutex);
684 for (i = 0; i < fb_helper->crtc_count; i++) {
685 crtc = fb_helper->crtc_info[i].mode_set.crtc;
687 modeset = &fb_helper->crtc_info[i].mode_set;
689 modeset->x = var->xoffset;
690 modeset->y = var->yoffset;
692 if (modeset->num_connectors) {
693 ret = crtc->funcs->set_config(modeset);
695 info->var.xoffset = var->xoffset;
696 info->var.yoffset = var->yoffset;
700 mutex_unlock(&dev->mode_config.mutex);
703 EXPORT_SYMBOL(drm_fb_helper_pan_display);
705 int drm_fb_helper_single_fb_probe(struct drm_fb_helper *fb_helper,
711 struct fb_info *info;
712 struct drm_fb_helper_surface_size sizes;
715 memset(&sizes, 0, sizeof(struct drm_fb_helper_surface_size));
716 sizes.surface_depth = 24;
717 sizes.surface_bpp = 32;
718 sizes.fb_width = (unsigned)-1;
719 sizes.fb_height = (unsigned)-1;
721 /* if driver picks 8 or 16 by default use that
722 for both depth/bpp */
723 if (preferred_bpp != sizes.surface_bpp) {
724 sizes.surface_depth = sizes.surface_bpp = preferred_bpp;
726 /* first up get a count of crtcs now in use and new min/maxes width/heights */
727 for (i = 0; i < fb_helper->connector_count; i++) {
728 struct drm_fb_helper_connector *fb_helper_conn = fb_helper->connector_info[i];
729 struct drm_cmdline_mode *cmdline_mode;
731 cmdline_mode = &fb_helper_conn->cmdline_mode;
733 if (cmdline_mode->bpp_specified) {
734 switch (cmdline_mode->bpp) {
736 sizes.surface_depth = sizes.surface_bpp = 8;
739 sizes.surface_depth = 15;
740 sizes.surface_bpp = 16;
743 sizes.surface_depth = sizes.surface_bpp = 16;
746 sizes.surface_depth = sizes.surface_bpp = 24;
749 sizes.surface_depth = 24;
750 sizes.surface_bpp = 32;
758 for (i = 0; i < fb_helper->crtc_count; i++) {
759 struct drm_display_mode *desired_mode;
760 desired_mode = fb_helper->crtc_info[i].desired_mode;
764 gamma_size = fb_helper->crtc_info[i].mode_set.crtc->gamma_size;
765 if (desired_mode->hdisplay < sizes.fb_width)
766 sizes.fb_width = desired_mode->hdisplay;
767 if (desired_mode->vdisplay < sizes.fb_height)
768 sizes.fb_height = desired_mode->vdisplay;
769 if (desired_mode->hdisplay > sizes.surface_width)
770 sizes.surface_width = desired_mode->hdisplay;
771 if (desired_mode->vdisplay > sizes.surface_height)
772 sizes.surface_height = desired_mode->vdisplay;
777 if (crtc_count == 0 || sizes.fb_width == -1 || sizes.fb_height == -1) {
778 /* hmm everyone went away - assume VGA cable just fell out
779 and will come back later. */
780 DRM_INFO("Cannot find any crtc or sizes - going 1024x768\n");
781 sizes.fb_width = sizes.surface_width = 1024;
782 sizes.fb_height = sizes.surface_height = 768;
785 /* push down into drivers */
786 new_fb = (*fb_helper->funcs->fb_probe)(fb_helper, &sizes);
790 info = fb_helper->fbdev;
792 /* set the fb pointer */
793 for (i = 0; i < fb_helper->crtc_count; i++) {
794 fb_helper->crtc_info[i].mode_set.fb = fb_helper->fb;
798 info->var.pixclock = 0;
799 if (register_framebuffer(info) < 0) {
803 printk(KERN_INFO "fb%d: %s frame buffer device\n", info->node,
807 drm_fb_helper_set_par(info);
810 /* Switch back to kernel console on panic */
811 /* multi card linked list maybe */
812 if (list_empty(&kernel_fb_helper_list)) {
813 printk(KERN_INFO "drm: registered panic notifier\n");
814 atomic_notifier_chain_register(&panic_notifier_list,
816 register_sysrq_key('v', &sysrq_drm_fb_helper_restore_op);
819 list_add(&fb_helper->kernel_fb_list, &kernel_fb_helper_list);
823 EXPORT_SYMBOL(drm_fb_helper_single_fb_probe);
825 void drm_fb_helper_fill_fix(struct fb_info *info, uint32_t pitch,
828 info->fix.type = FB_TYPE_PACKED_PIXELS;
829 info->fix.visual = depth == 8 ? FB_VISUAL_PSEUDOCOLOR :
831 info->fix.mmio_start = 0;
832 info->fix.mmio_len = 0;
833 info->fix.type_aux = 0;
834 info->fix.xpanstep = 1; /* doing it in hw */
835 info->fix.ypanstep = 1; /* doing it in hw */
836 info->fix.ywrapstep = 0;
837 info->fix.accel = FB_ACCEL_NONE;
838 info->fix.type_aux = 0;
840 info->fix.line_length = pitch;
843 EXPORT_SYMBOL(drm_fb_helper_fill_fix);
845 void drm_fb_helper_fill_var(struct fb_info *info, struct drm_fb_helper *fb_helper,
846 uint32_t fb_width, uint32_t fb_height)
848 struct drm_framebuffer *fb = fb_helper->fb;
849 info->pseudo_palette = fb_helper->pseudo_palette;
850 info->var.xres_virtual = fb->width;
851 info->var.yres_virtual = fb->height;
852 info->var.bits_per_pixel = fb->bits_per_pixel;
853 info->var.accel_flags = FB_ACCELF_TEXT;
854 info->var.xoffset = 0;
855 info->var.yoffset = 0;
856 info->var.activate = FB_ACTIVATE_NOW;
857 info->var.height = -1;
858 info->var.width = -1;
862 info->var.red.offset = 0;
863 info->var.green.offset = 0;
864 info->var.blue.offset = 0;
865 info->var.red.length = 8; /* 8bit DAC */
866 info->var.green.length = 8;
867 info->var.blue.length = 8;
868 info->var.transp.offset = 0;
869 info->var.transp.length = 0;
872 info->var.red.offset = 10;
873 info->var.green.offset = 5;
874 info->var.blue.offset = 0;
875 info->var.red.length = 5;
876 info->var.green.length = 5;
877 info->var.blue.length = 5;
878 info->var.transp.offset = 15;
879 info->var.transp.length = 1;
882 info->var.red.offset = 11;
883 info->var.green.offset = 5;
884 info->var.blue.offset = 0;
885 info->var.red.length = 5;
886 info->var.green.length = 6;
887 info->var.blue.length = 5;
888 info->var.transp.offset = 0;
891 info->var.red.offset = 16;
892 info->var.green.offset = 8;
893 info->var.blue.offset = 0;
894 info->var.red.length = 8;
895 info->var.green.length = 8;
896 info->var.blue.length = 8;
897 info->var.transp.offset = 0;
898 info->var.transp.length = 0;
901 info->var.red.offset = 16;
902 info->var.green.offset = 8;
903 info->var.blue.offset = 0;
904 info->var.red.length = 8;
905 info->var.green.length = 8;
906 info->var.blue.length = 8;
907 info->var.transp.offset = 24;
908 info->var.transp.length = 8;
914 info->var.xres = fb_width;
915 info->var.yres = fb_height;
917 EXPORT_SYMBOL(drm_fb_helper_fill_var);
919 static int drm_fb_helper_probe_connector_modes(struct drm_fb_helper *fb_helper,
923 struct drm_connector *connector;
927 for (i = 0; i < fb_helper->connector_count; i++) {
928 connector = fb_helper->connector_info[i]->connector;
929 count += connector->funcs->fill_modes(connector, maxX, maxY);
935 static struct drm_display_mode *drm_has_preferred_mode(struct drm_fb_helper_connector *fb_connector, int width, int height)
937 struct drm_display_mode *mode;
939 list_for_each_entry(mode, &fb_connector->connector->modes, head) {
940 if (drm_mode_width(mode) > width ||
941 drm_mode_height(mode) > height)
943 if (mode->type & DRM_MODE_TYPE_PREFERRED)
949 static bool drm_has_cmdline_mode(struct drm_fb_helper_connector *fb_connector)
951 struct drm_cmdline_mode *cmdline_mode;
952 cmdline_mode = &fb_connector->cmdline_mode;
953 return cmdline_mode->specified;
956 static struct drm_display_mode *drm_pick_cmdline_mode(struct drm_fb_helper_connector *fb_helper_conn,
957 int width, int height)
959 struct drm_cmdline_mode *cmdline_mode;
960 struct drm_display_mode *mode = NULL;
962 cmdline_mode = &fb_helper_conn->cmdline_mode;
963 if (cmdline_mode->specified == false)
966 /* attempt to find a matching mode in the list of modes
967 * we have gotten so far, if not add a CVT mode that conforms
969 if (cmdline_mode->rb || cmdline_mode->margins)
972 list_for_each_entry(mode, &fb_helper_conn->connector->modes, head) {
973 /* check width/height */
974 if (mode->hdisplay != cmdline_mode->xres ||
975 mode->vdisplay != cmdline_mode->yres)
978 if (cmdline_mode->refresh_specified) {
979 if (mode->vrefresh != cmdline_mode->refresh)
983 if (cmdline_mode->interlace) {
984 if (!(mode->flags & DRM_MODE_FLAG_INTERLACE))
991 mode = drm_mode_create_from_cmdline_mode(fb_helper_conn->connector->dev,
993 list_add(&mode->head, &fb_helper_conn->connector->modes);
997 static bool drm_connector_enabled(struct drm_connector *connector, bool strict)
1002 enable = connector->status == connector_status_connected;
1004 enable = connector->status != connector_status_disconnected;
1009 static void drm_enable_connectors(struct drm_fb_helper *fb_helper,
1012 bool any_enabled = false;
1013 struct drm_connector *connector;
1016 for (i = 0; i < fb_helper->connector_count; i++) {
1017 connector = fb_helper->connector_info[i]->connector;
1018 enabled[i] = drm_connector_enabled(connector, true);
1019 DRM_DEBUG_KMS("connector %d enabled? %s\n", connector->base.id,
1020 enabled[i] ? "yes" : "no");
1021 any_enabled |= enabled[i];
1027 for (i = 0; i < fb_helper->connector_count; i++) {
1028 connector = fb_helper->connector_info[i]->connector;
1029 enabled[i] = drm_connector_enabled(connector, false);
1033 static bool drm_target_cloned(struct drm_fb_helper *fb_helper,
1034 struct drm_display_mode **modes,
1035 bool *enabled, int width, int height)
1038 bool can_clone = false;
1039 struct drm_fb_helper_connector *fb_helper_conn;
1040 struct drm_display_mode *dmt_mode, *mode;
1042 /* only contemplate cloning in the single crtc case */
1043 if (fb_helper->crtc_count > 1)
1047 for (i = 0; i < fb_helper->connector_count; i++) {
1052 /* only contemplate cloning if more than one connector is enabled */
1056 /* check the command line or if nothing common pick 1024x768 */
1058 for (i = 0; i < fb_helper->connector_count; i++) {
1061 fb_helper_conn = fb_helper->connector_info[i];
1062 modes[i] = drm_pick_cmdline_mode(fb_helper_conn, width, height);
1067 for (j = 0; j < i; j++) {
1070 if (!drm_mode_equal(modes[j], modes[i]))
1076 DRM_DEBUG_KMS("can clone using command line\n");
1080 /* try and find a 1024x768 mode on each connector */
1082 dmt_mode = drm_mode_find_dmt(fb_helper->dev, 1024, 768, 60);
1084 for (i = 0; i < fb_helper->connector_count; i++) {
1089 fb_helper_conn = fb_helper->connector_info[i];
1090 list_for_each_entry(mode, &fb_helper_conn->connector->modes, head) {
1091 if (drm_mode_equal(mode, dmt_mode))
1099 DRM_DEBUG_KMS("can clone using 1024x768\n");
1102 DRM_INFO("kms: can't enable cloning when we probably wanted to.\n");
1106 static bool drm_target_preferred(struct drm_fb_helper *fb_helper,
1107 struct drm_display_mode **modes,
1108 bool *enabled, int width, int height)
1110 struct drm_fb_helper_connector *fb_helper_conn;
1113 for (i = 0; i < fb_helper->connector_count; i++) {
1114 fb_helper_conn = fb_helper->connector_info[i];
1116 if (enabled[i] == false)
1119 DRM_DEBUG_KMS("looking for cmdline mode on connector %d\n",
1120 fb_helper_conn->connector->base.id);
1122 /* got for command line mode first */
1123 modes[i] = drm_pick_cmdline_mode(fb_helper_conn, width, height);
1125 DRM_DEBUG_KMS("looking for preferred mode on connector %d\n",
1126 fb_helper_conn->connector->base.id);
1127 modes[i] = drm_has_preferred_mode(fb_helper_conn, width, height);
1129 /* No preferred modes, pick one off the list */
1130 if (!modes[i] && !list_empty(&fb_helper_conn->connector->modes)) {
1131 list_for_each_entry(modes[i], &fb_helper_conn->connector->modes, head)
1134 DRM_DEBUG_KMS("found mode %s\n", modes[i] ? modes[i]->name :
1140 static int drm_pick_crtcs(struct drm_fb_helper *fb_helper,
1141 struct drm_fb_helper_crtc **best_crtcs,
1142 struct drm_display_mode **modes,
1143 int n, int width, int height)
1146 struct drm_device *dev = fb_helper->dev;
1147 struct drm_connector *connector;
1148 struct drm_connector_helper_funcs *connector_funcs;
1149 struct drm_encoder *encoder;
1150 struct drm_fb_helper_crtc *best_crtc;
1151 int my_score, best_score, score;
1152 struct drm_fb_helper_crtc **crtcs, *crtc;
1153 struct drm_fb_helper_connector *fb_helper_conn;
1155 if (n == fb_helper->connector_count)
1158 fb_helper_conn = fb_helper->connector_info[n];
1159 connector = fb_helper_conn->connector;
1161 best_crtcs[n] = NULL;
1163 best_score = drm_pick_crtcs(fb_helper, best_crtcs, modes, n+1, width, height);
1164 if (modes[n] == NULL)
1167 crtcs = kzalloc(dev->mode_config.num_connector *
1168 sizeof(struct drm_fb_helper_crtc *), GFP_KERNEL);
1173 if (connector->status == connector_status_connected)
1175 if (drm_has_cmdline_mode(fb_helper_conn))
1177 if (drm_has_preferred_mode(fb_helper_conn, width, height))
1180 connector_funcs = connector->helper_private;
1181 encoder = connector_funcs->best_encoder(connector);
1185 /* select a crtc for this connector and then attempt to configure
1186 remaining connectors */
1187 for (c = 0; c < fb_helper->crtc_count; c++) {
1188 crtc = &fb_helper->crtc_info[c];
1190 if ((encoder->possible_crtcs & (1 << c)) == 0) {
1194 for (o = 0; o < n; o++)
1195 if (best_crtcs[o] == crtc)
1199 /* ignore cloning unless only a single crtc */
1200 if (fb_helper->crtc_count > 1)
1203 if (!drm_mode_equal(modes[o], modes[n]))
1208 memcpy(crtcs, best_crtcs, n * sizeof(struct drm_fb_helper_crtc *));
1209 score = my_score + drm_pick_crtcs(fb_helper, crtcs, modes, n + 1,
1211 if (score > best_score) {
1214 memcpy(best_crtcs, crtcs,
1215 dev->mode_config.num_connector *
1216 sizeof(struct drm_fb_helper_crtc *));
1224 static void drm_setup_crtcs(struct drm_fb_helper *fb_helper)
1226 struct drm_device *dev = fb_helper->dev;
1227 struct drm_fb_helper_crtc **crtcs;
1228 struct drm_display_mode **modes;
1229 struct drm_encoder *encoder;
1230 struct drm_mode_set *modeset;
1235 DRM_DEBUG_KMS("\n");
1237 width = dev->mode_config.max_width;
1238 height = dev->mode_config.max_height;
1240 /* clean out all the encoder/crtc combos */
1241 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
1242 encoder->crtc = NULL;
1245 crtcs = kcalloc(dev->mode_config.num_connector,
1246 sizeof(struct drm_fb_helper_crtc *), GFP_KERNEL);
1247 modes = kcalloc(dev->mode_config.num_connector,
1248 sizeof(struct drm_display_mode *), GFP_KERNEL);
1249 enabled = kcalloc(dev->mode_config.num_connector,
1250 sizeof(bool), GFP_KERNEL);
1252 drm_enable_connectors(fb_helper, enabled);
1254 ret = drm_target_cloned(fb_helper, modes, enabled, width, height);
1256 ret = drm_target_preferred(fb_helper, modes, enabled, width, height);
1258 DRM_ERROR("Unable to find initial modes\n");
1261 DRM_DEBUG_KMS("picking CRTCs for %dx%d config\n", width, height);
1263 drm_pick_crtcs(fb_helper, crtcs, modes, 0, width, height);
1265 /* need to set the modesets up here for use later */
1266 /* fill out the connector<->crtc mappings into the modesets */
1267 for (i = 0; i < fb_helper->crtc_count; i++) {
1268 modeset = &fb_helper->crtc_info[i].mode_set;
1269 modeset->num_connectors = 0;
1272 for (i = 0; i < fb_helper->connector_count; i++) {
1273 struct drm_display_mode *mode = modes[i];
1274 struct drm_fb_helper_crtc *fb_crtc = crtcs[i];
1275 modeset = &fb_crtc->mode_set;
1277 if (mode && fb_crtc) {
1278 DRM_DEBUG_KMS("desired mode %s set on crtc %d\n",
1279 mode->name, fb_crtc->mode_set.crtc->base.id);
1280 fb_crtc->desired_mode = mode;
1282 drm_mode_destroy(dev, modeset->mode);
1283 modeset->mode = drm_mode_duplicate(dev,
1284 fb_crtc->desired_mode);
1285 modeset->connectors[modeset->num_connectors++] = fb_helper->connector_info[i]->connector;
1295 * drm_helper_initial_config - setup a sane initial connector configuration
1299 * Called at init time, must take mode config lock.
1301 * Scan the CRTCs and connectors and try to put together an initial setup.
1302 * At the moment, this is a cloned configuration across all heads with
1303 * a new framebuffer object as the backing store.
1306 * Zero if everything went ok, nonzero otherwise.
1308 bool drm_fb_helper_initial_config(struct drm_fb_helper *fb_helper, int bpp_sel)
1310 struct drm_device *dev = fb_helper->dev;
1313 /* disable all the possible outputs/crtcs before entering KMS mode */
1314 drm_helper_disable_unused_functions(fb_helper->dev);
1316 drm_fb_helper_parse_command_line(fb_helper);
1318 count = drm_fb_helper_probe_connector_modes(fb_helper,
1319 dev->mode_config.max_width,
1320 dev->mode_config.max_height);
1322 * we shouldn't end up with no modes here.
1325 printk(KERN_INFO "No connectors reported connected with modes\n");
1327 drm_setup_crtcs(fb_helper);
1329 return drm_fb_helper_single_fb_probe(fb_helper, bpp_sel);
1331 EXPORT_SYMBOL(drm_fb_helper_initial_config);
1334 * drm_fb_helper_hotplug_event - respond to a hotplug notification by
1335 * probing all the outputs attached to the fb.
1336 * @fb_helper: the drm_fb_helper
1339 * Called at runtime, must take mode config lock.
1341 * Scan the connectors attached to the fb_helper and try to put together a
1342 * setup after *notification of a change in output configuration.
1345 * 0 on success and a non-zero error code otherwise.
1347 int drm_fb_helper_hotplug_event(struct drm_fb_helper *fb_helper)
1349 struct drm_device *dev = fb_helper->dev;
1351 u32 max_width, max_height, bpp_sel;
1352 bool bound = false, crtcs_bound = false;
1353 struct drm_crtc *crtc;
1358 mutex_lock(&dev->mode_config.mutex);
1359 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
1362 if (crtc->fb == fb_helper->fb)
1366 if (!bound && crtcs_bound) {
1367 fb_helper->delayed_hotplug = true;
1368 mutex_unlock(&dev->mode_config.mutex);
1371 DRM_DEBUG_KMS("\n");
1373 max_width = fb_helper->fb->width;
1374 max_height = fb_helper->fb->height;
1375 bpp_sel = fb_helper->fb->bits_per_pixel;
1377 count = drm_fb_helper_probe_connector_modes(fb_helper, max_width,
1379 drm_setup_crtcs(fb_helper);
1380 mutex_unlock(&dev->mode_config.mutex);
1382 return drm_fb_helper_single_fb_probe(fb_helper, bpp_sel);
1384 EXPORT_SYMBOL(drm_fb_helper_hotplug_event);
1386 /* The Kconfig DRM_KMS_HELPER selects FRAMEBUFFER_CONSOLE (if !EXPERT)
1387 * but the module doesn't depend on any fb console symbols. At least
1388 * attempt to load fbcon to avoid leaving the system without a usable console.
1390 #if defined(CONFIG_FRAMEBUFFER_CONSOLE_MODULE) && !defined(CONFIG_EXPERT)
1391 static int __init drm_fb_helper_modinit(void)
1393 const char *name = "fbcon";
1394 struct module *fbcon;
1396 mutex_lock(&module_mutex);
1397 fbcon = find_module(name);
1398 mutex_unlock(&module_mutex);
1401 request_module_nowait(name);
1405 module_init(drm_fb_helper_modinit);