Loading...
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#include <linux/kernel.h>
31#include <linux/sysrq.h>
32#include <linux/slab.h>
33#include <linux/fb.h>
34#include "drmP.h"
35#include "drm_crtc.h"
36#include "drm_fb_helper.h"
37#include "drm_crtc_helper.h"
38
39MODULE_AUTHOR("David Airlie, Jesse Barnes");
40MODULE_DESCRIPTION("DRM KMS helper");
41MODULE_LICENSE("GPL and additional rights");
42
43static LIST_HEAD(kernel_fb_helper_list);
44
45/* simple single crtc case helper function */
46int drm_fb_helper_single_add_all_connectors(struct drm_fb_helper *fb_helper)
47{
48 struct drm_device *dev = fb_helper->dev;
49 struct drm_connector *connector;
50 int i;
51
52 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
53 struct drm_fb_helper_connector *fb_helper_connector;
54
55 fb_helper_connector = kzalloc(sizeof(struct drm_fb_helper_connector), GFP_KERNEL);
56 if (!fb_helper_connector)
57 goto fail;
58
59 fb_helper_connector->connector = connector;
60 fb_helper->connector_info[fb_helper->connector_count++] = fb_helper_connector;
61 }
62 return 0;
63fail:
64 for (i = 0; i < fb_helper->connector_count; i++) {
65 kfree(fb_helper->connector_info[i]);
66 fb_helper->connector_info[i] = NULL;
67 }
68 fb_helper->connector_count = 0;
69 return -ENOMEM;
70}
71EXPORT_SYMBOL(drm_fb_helper_single_add_all_connectors);
72
73static int drm_fb_helper_parse_command_line(struct drm_fb_helper *fb_helper)
74{
75 struct drm_fb_helper_connector *fb_helper_conn;
76 int i;
77
78 for (i = 0; i < fb_helper->connector_count; i++) {
79 struct drm_cmdline_mode *mode;
80 struct drm_connector *connector;
81 char *option = NULL;
82
83 fb_helper_conn = fb_helper->connector_info[i];
84 connector = fb_helper_conn->connector;
85 mode = &fb_helper_conn->cmdline_mode;
86
87 /* do something on return - turn off connector maybe */
88 if (fb_get_options(drm_get_connector_name(connector), &option))
89 continue;
90
91 if (drm_mode_parse_command_line_for_connector(option,
92 connector,
93 mode)) {
94 if (mode->force) {
95 const char *s;
96 switch (mode->force) {
97 case DRM_FORCE_OFF: s = "OFF"; break;
98 case DRM_FORCE_ON_DIGITAL: s = "ON - dig"; break;
99 default:
100 case DRM_FORCE_ON: s = "ON"; break;
101 }
102
103 DRM_INFO("forcing %s connector %s\n",
104 drm_get_connector_name(connector), s);
105 connector->force = mode->force;
106 }
107
108 DRM_DEBUG_KMS("cmdline mode for connector %s %dx%d@%dHz%s%s%s\n",
109 drm_get_connector_name(connector),
110 mode->xres, mode->yres,
111 mode->refresh_specified ? mode->refresh : 60,
112 mode->rb ? " reduced blanking" : "",
113 mode->margins ? " with margins" : "",
114 mode->interlace ? " interlaced" : "");
115 }
116
117 }
118 return 0;
119}
120
121static void drm_fb_helper_save_lut_atomic(struct drm_crtc *crtc, struct drm_fb_helper *helper)
122{
123 uint16_t *r_base, *g_base, *b_base;
124 int i;
125
126 r_base = crtc->gamma_store;
127 g_base = r_base + crtc->gamma_size;
128 b_base = g_base + crtc->gamma_size;
129
130 for (i = 0; i < crtc->gamma_size; i++)
131 helper->funcs->gamma_get(crtc, &r_base[i], &g_base[i], &b_base[i], i);
132}
133
134static void drm_fb_helper_restore_lut_atomic(struct drm_crtc *crtc)
135{
136 uint16_t *r_base, *g_base, *b_base;
137
138 r_base = crtc->gamma_store;
139 g_base = r_base + crtc->gamma_size;
140 b_base = g_base + crtc->gamma_size;
141
142 crtc->funcs->gamma_set(crtc, r_base, g_base, b_base, 0, crtc->gamma_size);
143}
144
145int drm_fb_helper_debug_enter(struct fb_info *info)
146{
147 struct drm_fb_helper *helper = info->par;
148 struct drm_crtc_helper_funcs *funcs;
149 int i;
150
151 if (list_empty(&kernel_fb_helper_list))
152 return false;
153
154 list_for_each_entry(helper, &kernel_fb_helper_list, kernel_fb_list) {
155 for (i = 0; i < helper->crtc_count; i++) {
156 struct drm_mode_set *mode_set =
157 &helper->crtc_info[i].mode_set;
158
159 if (!mode_set->crtc->enabled)
160 continue;
161
162 funcs = mode_set->crtc->helper_private;
163 drm_fb_helper_save_lut_atomic(mode_set->crtc, helper);
164 funcs->mode_set_base_atomic(mode_set->crtc,
165 mode_set->fb,
166 mode_set->x,
167 mode_set->y,
168 ENTER_ATOMIC_MODE_SET);
169 }
170 }
171
172 return 0;
173}
174EXPORT_SYMBOL(drm_fb_helper_debug_enter);
175
176/* Find the real fb for a given fb helper CRTC */
177static struct drm_framebuffer *drm_mode_config_fb(struct drm_crtc *crtc)
178{
179 struct drm_device *dev = crtc->dev;
180 struct drm_crtc *c;
181
182 list_for_each_entry(c, &dev->mode_config.crtc_list, head) {
183 if (crtc->base.id == c->base.id)
184 return c->fb;
185 }
186
187 return NULL;
188}
189
190int drm_fb_helper_debug_leave(struct fb_info *info)
191{
192 struct drm_fb_helper *helper = info->par;
193 struct drm_crtc *crtc;
194 struct drm_crtc_helper_funcs *funcs;
195 struct drm_framebuffer *fb;
196 int i;
197
198 for (i = 0; i < helper->crtc_count; i++) {
199 struct drm_mode_set *mode_set = &helper->crtc_info[i].mode_set;
200 crtc = mode_set->crtc;
201 funcs = crtc->helper_private;
202 fb = drm_mode_config_fb(crtc);
203
204 if (!crtc->enabled)
205 continue;
206
207 if (!fb) {
208 DRM_ERROR("no fb to restore??\n");
209 continue;
210 }
211
212 drm_fb_helper_restore_lut_atomic(mode_set->crtc);
213 funcs->mode_set_base_atomic(mode_set->crtc, fb, crtc->x,
214 crtc->y, LEAVE_ATOMIC_MODE_SET);
215 }
216
217 return 0;
218}
219EXPORT_SYMBOL(drm_fb_helper_debug_leave);
220
221bool drm_fb_helper_restore_fbdev_mode(struct drm_fb_helper *fb_helper)
222{
223 bool error = false;
224 int i, ret;
225 for (i = 0; i < fb_helper->crtc_count; i++) {
226 struct drm_mode_set *mode_set = &fb_helper->crtc_info[i].mode_set;
227 ret = drm_crtc_helper_set_config(mode_set);
228 if (ret)
229 error = true;
230 }
231 return error;
232}
233EXPORT_SYMBOL(drm_fb_helper_restore_fbdev_mode);
234
235bool drm_fb_helper_force_kernel_mode(void)
236{
237 bool ret, error = false;
238 struct drm_fb_helper *helper;
239
240 if (list_empty(&kernel_fb_helper_list))
241 return false;
242
243 list_for_each_entry(helper, &kernel_fb_helper_list, kernel_fb_list) {
244 if (helper->dev->switch_power_state == DRM_SWITCH_POWER_OFF)
245 continue;
246
247 ret = drm_fb_helper_restore_fbdev_mode(helper);
248 if (ret)
249 error = true;
250 }
251 return error;
252}
253
254int drm_fb_helper_panic(struct notifier_block *n, unsigned long ununsed,
255 void *panic_str)
256{
257 printk(KERN_ERR "panic occurred, switching back to text console\n");
258 return drm_fb_helper_force_kernel_mode();
259}
260EXPORT_SYMBOL(drm_fb_helper_panic);
261
262static struct notifier_block paniced = {
263 .notifier_call = drm_fb_helper_panic,
264};
265
266/**
267 * drm_fb_helper_restore - restore the framebuffer console (kernel) config
268 *
269 * Restore's the kernel's fbcon mode, used for lastclose & panic paths.
270 */
271void drm_fb_helper_restore(void)
272{
273 bool ret;
274 ret = drm_fb_helper_force_kernel_mode();
275 if (ret == true)
276 DRM_ERROR("Failed to restore crtc configuration\n");
277}
278EXPORT_SYMBOL(drm_fb_helper_restore);
279
280#ifdef CONFIG_MAGIC_SYSRQ
281static void drm_fb_helper_restore_work_fn(struct work_struct *ignored)
282{
283 drm_fb_helper_restore();
284}
285static DECLARE_WORK(drm_fb_helper_restore_work, drm_fb_helper_restore_work_fn);
286
287static void drm_fb_helper_sysrq(int dummy1)
288{
289 schedule_work(&drm_fb_helper_restore_work);
290}
291
292static struct sysrq_key_op sysrq_drm_fb_helper_restore_op = {
293 .handler = drm_fb_helper_sysrq,
294 .help_msg = "force-fb(V)",
295 .action_msg = "Restore framebuffer console",
296};
297#else
298static struct sysrq_key_op sysrq_drm_fb_helper_restore_op = { };
299#endif
300
301static void drm_fb_helper_on(struct fb_info *info)
302{
303 struct drm_fb_helper *fb_helper = info->par;
304 struct drm_device *dev = fb_helper->dev;
305 struct drm_crtc *crtc;
306 struct drm_crtc_helper_funcs *crtc_funcs;
307 struct drm_connector *connector;
308 struct drm_encoder *encoder;
309 int i, j;
310
311 /*
312 * For each CRTC in this fb, turn the crtc on then,
313 * find all associated encoders and turn them on.
314 */
315 mutex_lock(&dev->mode_config.mutex);
316 for (i = 0; i < fb_helper->crtc_count; i++) {
317 crtc = fb_helper->crtc_info[i].mode_set.crtc;
318 crtc_funcs = crtc->helper_private;
319
320 if (!crtc->enabled)
321 continue;
322
323 crtc_funcs->dpms(crtc, DRM_MODE_DPMS_ON);
324
325 /* Walk the connectors & encoders on this fb turning them on */
326 for (j = 0; j < fb_helper->connector_count; j++) {
327 connector = fb_helper->connector_info[j]->connector;
328 connector->dpms = DRM_MODE_DPMS_ON;
329 drm_connector_property_set_value(connector,
330 dev->mode_config.dpms_property,
331 DRM_MODE_DPMS_ON);
332 }
333 /* Found a CRTC on this fb, now find encoders */
334 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
335 if (encoder->crtc == crtc) {
336 struct drm_encoder_helper_funcs *encoder_funcs;
337
338 encoder_funcs = encoder->helper_private;
339 encoder_funcs->dpms(encoder, DRM_MODE_DPMS_ON);
340 }
341 }
342 }
343 mutex_unlock(&dev->mode_config.mutex);
344}
345
346static void drm_fb_helper_off(struct fb_info *info, int dpms_mode)
347{
348 struct drm_fb_helper *fb_helper = info->par;
349 struct drm_device *dev = fb_helper->dev;
350 struct drm_crtc *crtc;
351 struct drm_crtc_helper_funcs *crtc_funcs;
352 struct drm_connector *connector;
353 struct drm_encoder *encoder;
354 int i, j;
355
356 /*
357 * For each CRTC in this fb, find all associated encoders
358 * and turn them off, then turn off the CRTC.
359 */
360 mutex_lock(&dev->mode_config.mutex);
361 for (i = 0; i < fb_helper->crtc_count; i++) {
362 crtc = fb_helper->crtc_info[i].mode_set.crtc;
363 crtc_funcs = crtc->helper_private;
364
365 if (!crtc->enabled)
366 continue;
367
368 /* Walk the connectors on this fb and mark them off */
369 for (j = 0; j < fb_helper->connector_count; j++) {
370 connector = fb_helper->connector_info[j]->connector;
371 connector->dpms = dpms_mode;
372 drm_connector_property_set_value(connector,
373 dev->mode_config.dpms_property,
374 dpms_mode);
375 }
376 /* Found a CRTC on this fb, now find encoders */
377 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
378 if (encoder->crtc == crtc) {
379 struct drm_encoder_helper_funcs *encoder_funcs;
380
381 encoder_funcs = encoder->helper_private;
382 encoder_funcs->dpms(encoder, dpms_mode);
383 }
384 }
385 crtc_funcs->dpms(crtc, DRM_MODE_DPMS_OFF);
386 }
387 mutex_unlock(&dev->mode_config.mutex);
388}
389
390int drm_fb_helper_blank(int blank, struct fb_info *info)
391{
392 switch (blank) {
393 /* Display: On; HSync: On, VSync: On */
394 case FB_BLANK_UNBLANK:
395 drm_fb_helper_on(info);
396 break;
397 /* Display: Off; HSync: On, VSync: On */
398 case FB_BLANK_NORMAL:
399 drm_fb_helper_off(info, DRM_MODE_DPMS_STANDBY);
400 break;
401 /* Display: Off; HSync: Off, VSync: On */
402 case FB_BLANK_HSYNC_SUSPEND:
403 drm_fb_helper_off(info, DRM_MODE_DPMS_STANDBY);
404 break;
405 /* Display: Off; HSync: On, VSync: Off */
406 case FB_BLANK_VSYNC_SUSPEND:
407 drm_fb_helper_off(info, DRM_MODE_DPMS_SUSPEND);
408 break;
409 /* Display: Off; HSync: Off, VSync: Off */
410 case FB_BLANK_POWERDOWN:
411 drm_fb_helper_off(info, DRM_MODE_DPMS_OFF);
412 break;
413 }
414 return 0;
415}
416EXPORT_SYMBOL(drm_fb_helper_blank);
417
418static void drm_fb_helper_crtc_free(struct drm_fb_helper *helper)
419{
420 int i;
421
422 for (i = 0; i < helper->connector_count; i++)
423 kfree(helper->connector_info[i]);
424 kfree(helper->connector_info);
425 for (i = 0; i < helper->crtc_count; i++)
426 kfree(helper->crtc_info[i].mode_set.connectors);
427 kfree(helper->crtc_info);
428}
429
430int drm_fb_helper_init(struct drm_device *dev,
431 struct drm_fb_helper *fb_helper,
432 int crtc_count, int max_conn_count)
433{
434 struct drm_crtc *crtc;
435 int ret = 0;
436 int i;
437
438 fb_helper->dev = dev;
439
440 INIT_LIST_HEAD(&fb_helper->kernel_fb_list);
441
442 fb_helper->crtc_info = kcalloc(crtc_count, sizeof(struct drm_fb_helper_crtc), GFP_KERNEL);
443 if (!fb_helper->crtc_info)
444 return -ENOMEM;
445
446 fb_helper->crtc_count = crtc_count;
447 fb_helper->connector_info = kcalloc(dev->mode_config.num_connector, sizeof(struct drm_fb_helper_connector *), GFP_KERNEL);
448 if (!fb_helper->connector_info) {
449 kfree(fb_helper->crtc_info);
450 return -ENOMEM;
451 }
452 fb_helper->connector_count = 0;
453
454 for (i = 0; i < crtc_count; i++) {
455 fb_helper->crtc_info[i].mode_set.connectors =
456 kcalloc(max_conn_count,
457 sizeof(struct drm_connector *),
458 GFP_KERNEL);
459
460 if (!fb_helper->crtc_info[i].mode_set.connectors) {
461 ret = -ENOMEM;
462 goto out_free;
463 }
464 fb_helper->crtc_info[i].mode_set.num_connectors = 0;
465 }
466
467 i = 0;
468 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
469 fb_helper->crtc_info[i].crtc_id = crtc->base.id;
470 fb_helper->crtc_info[i].mode_set.crtc = crtc;
471 i++;
472 }
473 fb_helper->conn_limit = max_conn_count;
474 return 0;
475out_free:
476 drm_fb_helper_crtc_free(fb_helper);
477 return -ENOMEM;
478}
479EXPORT_SYMBOL(drm_fb_helper_init);
480
481void drm_fb_helper_fini(struct drm_fb_helper *fb_helper)
482{
483 if (!list_empty(&fb_helper->kernel_fb_list)) {
484 list_del(&fb_helper->kernel_fb_list);
485 if (list_empty(&kernel_fb_helper_list)) {
486 printk(KERN_INFO "drm: unregistered panic notifier\n");
487 atomic_notifier_chain_unregister(&panic_notifier_list,
488 &paniced);
489 unregister_sysrq_key('v', &sysrq_drm_fb_helper_restore_op);
490 }
491 }
492
493 drm_fb_helper_crtc_free(fb_helper);
494
495}
496EXPORT_SYMBOL(drm_fb_helper_fini);
497
498static int setcolreg(struct drm_crtc *crtc, u16 red, u16 green,
499 u16 blue, u16 regno, struct fb_info *info)
500{
501 struct drm_fb_helper *fb_helper = info->par;
502 struct drm_framebuffer *fb = fb_helper->fb;
503 int pindex;
504
505 if (info->fix.visual == FB_VISUAL_TRUECOLOR) {
506 u32 *palette;
507 u32 value;
508 /* place color in psuedopalette */
509 if (regno > 16)
510 return -EINVAL;
511 palette = (u32 *)info->pseudo_palette;
512 red >>= (16 - info->var.red.length);
513 green >>= (16 - info->var.green.length);
514 blue >>= (16 - info->var.blue.length);
515 value = (red << info->var.red.offset) |
516 (green << info->var.green.offset) |
517 (blue << info->var.blue.offset);
518 if (info->var.transp.length > 0) {
519 u32 mask = (1 << info->var.transp.length) - 1;
520 mask <<= info->var.transp.offset;
521 value |= mask;
522 }
523 palette[regno] = value;
524 return 0;
525 }
526
527 pindex = regno;
528
529 if (fb->bits_per_pixel == 16) {
530 pindex = regno << 3;
531
532 if (fb->depth == 16 && regno > 63)
533 return -EINVAL;
534 if (fb->depth == 15 && regno > 31)
535 return -EINVAL;
536
537 if (fb->depth == 16) {
538 u16 r, g, b;
539 int i;
540 if (regno < 32) {
541 for (i = 0; i < 8; i++)
542 fb_helper->funcs->gamma_set(crtc, red,
543 green, blue, pindex + i);
544 }
545
546 fb_helper->funcs->gamma_get(crtc, &r,
547 &g, &b,
548 pindex >> 1);
549
550 for (i = 0; i < 4; i++)
551 fb_helper->funcs->gamma_set(crtc, r,
552 green, b,
553 (pindex >> 1) + i);
554 }
555 }
556
557 if (fb->depth != 16)
558 fb_helper->funcs->gamma_set(crtc, red, green, blue, pindex);
559 return 0;
560}
561
562int drm_fb_helper_setcmap(struct fb_cmap *cmap, struct fb_info *info)
563{
564 struct drm_fb_helper *fb_helper = info->par;
565 struct drm_crtc_helper_funcs *crtc_funcs;
566 u16 *red, *green, *blue, *transp;
567 struct drm_crtc *crtc;
568 int i, j, rc = 0;
569 int start;
570
571 for (i = 0; i < fb_helper->crtc_count; i++) {
572 crtc = fb_helper->crtc_info[i].mode_set.crtc;
573 crtc_funcs = crtc->helper_private;
574
575 red = cmap->red;
576 green = cmap->green;
577 blue = cmap->blue;
578 transp = cmap->transp;
579 start = cmap->start;
580
581 for (j = 0; j < cmap->len; j++) {
582 u16 hred, hgreen, hblue, htransp = 0xffff;
583
584 hred = *red++;
585 hgreen = *green++;
586 hblue = *blue++;
587
588 if (transp)
589 htransp = *transp++;
590
591 rc = setcolreg(crtc, hred, hgreen, hblue, start++, info);
592 if (rc)
593 return rc;
594 }
595 crtc_funcs->load_lut(crtc);
596 }
597 return rc;
598}
599EXPORT_SYMBOL(drm_fb_helper_setcmap);
600
601int drm_fb_helper_check_var(struct fb_var_screeninfo *var,
602 struct fb_info *info)
603{
604 struct drm_fb_helper *fb_helper = info->par;
605 struct drm_framebuffer *fb = fb_helper->fb;
606 int depth;
607
608 if (var->pixclock != 0 || in_dbg_master())
609 return -EINVAL;
610
611 /* Need to resize the fb object !!! */
612 if (var->bits_per_pixel > fb->bits_per_pixel || var->xres > fb->width || var->yres > fb->height) {
613 DRM_DEBUG("fb userspace requested width/height/bpp is greater than current fb "
614 "object %dx%d-%d > %dx%d-%d\n", var->xres, var->yres, var->bits_per_pixel,
615 fb->width, fb->height, fb->bits_per_pixel);
616 return -EINVAL;
617 }
618
619 switch (var->bits_per_pixel) {
620 case 16:
621 depth = (var->green.length == 6) ? 16 : 15;
622 break;
623 case 32:
624 depth = (var->transp.length > 0) ? 32 : 24;
625 break;
626 default:
627 depth = var->bits_per_pixel;
628 break;
629 }
630
631 switch (depth) {
632 case 8:
633 var->red.offset = 0;
634 var->green.offset = 0;
635 var->blue.offset = 0;
636 var->red.length = 8;
637 var->green.length = 8;
638 var->blue.length = 8;
639 var->transp.length = 0;
640 var->transp.offset = 0;
641 break;
642 case 15:
643 var->red.offset = 10;
644 var->green.offset = 5;
645 var->blue.offset = 0;
646 var->red.length = 5;
647 var->green.length = 5;
648 var->blue.length = 5;
649 var->transp.length = 1;
650 var->transp.offset = 15;
651 break;
652 case 16:
653 var->red.offset = 11;
654 var->green.offset = 5;
655 var->blue.offset = 0;
656 var->red.length = 5;
657 var->green.length = 6;
658 var->blue.length = 5;
659 var->transp.length = 0;
660 var->transp.offset = 0;
661 break;
662 case 24:
663 var->red.offset = 16;
664 var->green.offset = 8;
665 var->blue.offset = 0;
666 var->red.length = 8;
667 var->green.length = 8;
668 var->blue.length = 8;
669 var->transp.length = 0;
670 var->transp.offset = 0;
671 break;
672 case 32:
673 var->red.offset = 16;
674 var->green.offset = 8;
675 var->blue.offset = 0;
676 var->red.length = 8;
677 var->green.length = 8;
678 var->blue.length = 8;
679 var->transp.length = 8;
680 var->transp.offset = 24;
681 break;
682 default:
683 return -EINVAL;
684 }
685 return 0;
686}
687EXPORT_SYMBOL(drm_fb_helper_check_var);
688
689/* this will let fbcon do the mode init */
690int drm_fb_helper_set_par(struct fb_info *info)
691{
692 struct drm_fb_helper *fb_helper = info->par;
693 struct drm_device *dev = fb_helper->dev;
694 struct fb_var_screeninfo *var = &info->var;
695 struct drm_crtc *crtc;
696 int ret;
697 int i;
698
699 if (var->pixclock != 0) {
700 DRM_ERROR("PIXEL CLOCK SET\n");
701 return -EINVAL;
702 }
703
704 mutex_lock(&dev->mode_config.mutex);
705 for (i = 0; i < fb_helper->crtc_count; i++) {
706 crtc = fb_helper->crtc_info[i].mode_set.crtc;
707 ret = crtc->funcs->set_config(&fb_helper->crtc_info[i].mode_set);
708 if (ret) {
709 mutex_unlock(&dev->mode_config.mutex);
710 return ret;
711 }
712 }
713 mutex_unlock(&dev->mode_config.mutex);
714
715 if (fb_helper->delayed_hotplug) {
716 fb_helper->delayed_hotplug = false;
717 drm_fb_helper_hotplug_event(fb_helper);
718 }
719 return 0;
720}
721EXPORT_SYMBOL(drm_fb_helper_set_par);
722
723int drm_fb_helper_pan_display(struct fb_var_screeninfo *var,
724 struct fb_info *info)
725{
726 struct drm_fb_helper *fb_helper = info->par;
727 struct drm_device *dev = fb_helper->dev;
728 struct drm_mode_set *modeset;
729 struct drm_crtc *crtc;
730 int ret = 0;
731 int i;
732
733 mutex_lock(&dev->mode_config.mutex);
734 for (i = 0; i < fb_helper->crtc_count; i++) {
735 crtc = fb_helper->crtc_info[i].mode_set.crtc;
736
737 modeset = &fb_helper->crtc_info[i].mode_set;
738
739 modeset->x = var->xoffset;
740 modeset->y = var->yoffset;
741
742 if (modeset->num_connectors) {
743 ret = crtc->funcs->set_config(modeset);
744 if (!ret) {
745 info->var.xoffset = var->xoffset;
746 info->var.yoffset = var->yoffset;
747 }
748 }
749 }
750 mutex_unlock(&dev->mode_config.mutex);
751 return ret;
752}
753EXPORT_SYMBOL(drm_fb_helper_pan_display);
754
755int drm_fb_helper_single_fb_probe(struct drm_fb_helper *fb_helper,
756 int preferred_bpp)
757{
758 int new_fb = 0;
759 int crtc_count = 0;
760 int i;
761 struct fb_info *info;
762 struct drm_fb_helper_surface_size sizes;
763 int gamma_size = 0;
764
765 memset(&sizes, 0, sizeof(struct drm_fb_helper_surface_size));
766 sizes.surface_depth = 24;
767 sizes.surface_bpp = 32;
768 sizes.fb_width = (unsigned)-1;
769 sizes.fb_height = (unsigned)-1;
770
771 /* if driver picks 8 or 16 by default use that
772 for both depth/bpp */
773 if (preferred_bpp != sizes.surface_bpp) {
774 sizes.surface_depth = sizes.surface_bpp = preferred_bpp;
775 }
776 /* first up get a count of crtcs now in use and new min/maxes width/heights */
777 for (i = 0; i < fb_helper->connector_count; i++) {
778 struct drm_fb_helper_connector *fb_helper_conn = fb_helper->connector_info[i];
779 struct drm_cmdline_mode *cmdline_mode;
780
781 cmdline_mode = &fb_helper_conn->cmdline_mode;
782
783 if (cmdline_mode->bpp_specified) {
784 switch (cmdline_mode->bpp) {
785 case 8:
786 sizes.surface_depth = sizes.surface_bpp = 8;
787 break;
788 case 15:
789 sizes.surface_depth = 15;
790 sizes.surface_bpp = 16;
791 break;
792 case 16:
793 sizes.surface_depth = sizes.surface_bpp = 16;
794 break;
795 case 24:
796 sizes.surface_depth = sizes.surface_bpp = 24;
797 break;
798 case 32:
799 sizes.surface_depth = 24;
800 sizes.surface_bpp = 32;
801 break;
802 }
803 break;
804 }
805 }
806
807 crtc_count = 0;
808 for (i = 0; i < fb_helper->crtc_count; i++) {
809 struct drm_display_mode *desired_mode;
810 desired_mode = fb_helper->crtc_info[i].desired_mode;
811
812 if (desired_mode) {
813 if (gamma_size == 0)
814 gamma_size = fb_helper->crtc_info[i].mode_set.crtc->gamma_size;
815 if (desired_mode->hdisplay < sizes.fb_width)
816 sizes.fb_width = desired_mode->hdisplay;
817 if (desired_mode->vdisplay < sizes.fb_height)
818 sizes.fb_height = desired_mode->vdisplay;
819 if (desired_mode->hdisplay > sizes.surface_width)
820 sizes.surface_width = desired_mode->hdisplay;
821 if (desired_mode->vdisplay > sizes.surface_height)
822 sizes.surface_height = desired_mode->vdisplay;
823 crtc_count++;
824 }
825 }
826
827 if (crtc_count == 0 || sizes.fb_width == -1 || sizes.fb_height == -1) {
828 /* hmm everyone went away - assume VGA cable just fell out
829 and will come back later. */
830 DRM_INFO("Cannot find any crtc or sizes - going 1024x768\n");
831 sizes.fb_width = sizes.surface_width = 1024;
832 sizes.fb_height = sizes.surface_height = 768;
833 }
834
835 /* push down into drivers */
836 new_fb = (*fb_helper->funcs->fb_probe)(fb_helper, &sizes);
837 if (new_fb < 0)
838 return new_fb;
839
840 info = fb_helper->fbdev;
841
842 /* set the fb pointer */
843 for (i = 0; i < fb_helper->crtc_count; i++) {
844 fb_helper->crtc_info[i].mode_set.fb = fb_helper->fb;
845 }
846
847 if (new_fb) {
848 info->var.pixclock = 0;
849 if (register_framebuffer(info) < 0) {
850 return -EINVAL;
851 }
852
853 printk(KERN_INFO "fb%d: %s frame buffer device\n", info->node,
854 info->fix.id);
855
856 } else {
857 drm_fb_helper_set_par(info);
858 }
859
860 /* Switch back to kernel console on panic */
861 /* multi card linked list maybe */
862 if (list_empty(&kernel_fb_helper_list)) {
863 printk(KERN_INFO "drm: registered panic notifier\n");
864 atomic_notifier_chain_register(&panic_notifier_list,
865 &paniced);
866 register_sysrq_key('v', &sysrq_drm_fb_helper_restore_op);
867 }
868 if (new_fb)
869 list_add(&fb_helper->kernel_fb_list, &kernel_fb_helper_list);
870
871 return 0;
872}
873EXPORT_SYMBOL(drm_fb_helper_single_fb_probe);
874
875void drm_fb_helper_fill_fix(struct fb_info *info, uint32_t pitch,
876 uint32_t depth)
877{
878 info->fix.type = FB_TYPE_PACKED_PIXELS;
879 info->fix.visual = depth == 8 ? FB_VISUAL_PSEUDOCOLOR :
880 FB_VISUAL_TRUECOLOR;
881 info->fix.mmio_start = 0;
882 info->fix.mmio_len = 0;
883 info->fix.type_aux = 0;
884 info->fix.xpanstep = 1; /* doing it in hw */
885 info->fix.ypanstep = 1; /* doing it in hw */
886 info->fix.ywrapstep = 0;
887 info->fix.accel = FB_ACCEL_NONE;
888 info->fix.type_aux = 0;
889
890 info->fix.line_length = pitch;
891 return;
892}
893EXPORT_SYMBOL(drm_fb_helper_fill_fix);
894
895void drm_fb_helper_fill_var(struct fb_info *info, struct drm_fb_helper *fb_helper,
896 uint32_t fb_width, uint32_t fb_height)
897{
898 struct drm_framebuffer *fb = fb_helper->fb;
899 info->pseudo_palette = fb_helper->pseudo_palette;
900 info->var.xres_virtual = fb->width;
901 info->var.yres_virtual = fb->height;
902 info->var.bits_per_pixel = fb->bits_per_pixel;
903 info->var.accel_flags = FB_ACCELF_TEXT;
904 info->var.xoffset = 0;
905 info->var.yoffset = 0;
906 info->var.activate = FB_ACTIVATE_NOW;
907 info->var.height = -1;
908 info->var.width = -1;
909
910 switch (fb->depth) {
911 case 8:
912 info->var.red.offset = 0;
913 info->var.green.offset = 0;
914 info->var.blue.offset = 0;
915 info->var.red.length = 8; /* 8bit DAC */
916 info->var.green.length = 8;
917 info->var.blue.length = 8;
918 info->var.transp.offset = 0;
919 info->var.transp.length = 0;
920 break;
921 case 15:
922 info->var.red.offset = 10;
923 info->var.green.offset = 5;
924 info->var.blue.offset = 0;
925 info->var.red.length = 5;
926 info->var.green.length = 5;
927 info->var.blue.length = 5;
928 info->var.transp.offset = 15;
929 info->var.transp.length = 1;
930 break;
931 case 16:
932 info->var.red.offset = 11;
933 info->var.green.offset = 5;
934 info->var.blue.offset = 0;
935 info->var.red.length = 5;
936 info->var.green.length = 6;
937 info->var.blue.length = 5;
938 info->var.transp.offset = 0;
939 break;
940 case 24:
941 info->var.red.offset = 16;
942 info->var.green.offset = 8;
943 info->var.blue.offset = 0;
944 info->var.red.length = 8;
945 info->var.green.length = 8;
946 info->var.blue.length = 8;
947 info->var.transp.offset = 0;
948 info->var.transp.length = 0;
949 break;
950 case 32:
951 info->var.red.offset = 16;
952 info->var.green.offset = 8;
953 info->var.blue.offset = 0;
954 info->var.red.length = 8;
955 info->var.green.length = 8;
956 info->var.blue.length = 8;
957 info->var.transp.offset = 24;
958 info->var.transp.length = 8;
959 break;
960 default:
961 break;
962 }
963
964 info->var.xres = fb_width;
965 info->var.yres = fb_height;
966}
967EXPORT_SYMBOL(drm_fb_helper_fill_var);
968
969static int drm_fb_helper_probe_connector_modes(struct drm_fb_helper *fb_helper,
970 uint32_t maxX,
971 uint32_t maxY)
972{
973 struct drm_connector *connector;
974 int count = 0;
975 int i;
976
977 for (i = 0; i < fb_helper->connector_count; i++) {
978 connector = fb_helper->connector_info[i]->connector;
979 count += connector->funcs->fill_modes(connector, maxX, maxY);
980 }
981
982 return count;
983}
984
985static struct drm_display_mode *drm_has_preferred_mode(struct drm_fb_helper_connector *fb_connector, int width, int height)
986{
987 struct drm_display_mode *mode;
988
989 list_for_each_entry(mode, &fb_connector->connector->modes, head) {
990 if (drm_mode_width(mode) > width ||
991 drm_mode_height(mode) > height)
992 continue;
993 if (mode->type & DRM_MODE_TYPE_PREFERRED)
994 return mode;
995 }
996 return NULL;
997}
998
999static bool drm_has_cmdline_mode(struct drm_fb_helper_connector *fb_connector)
1000{
1001 struct drm_cmdline_mode *cmdline_mode;
1002 cmdline_mode = &fb_connector->cmdline_mode;
1003 return cmdline_mode->specified;
1004}
1005
1006static struct drm_display_mode *drm_pick_cmdline_mode(struct drm_fb_helper_connector *fb_helper_conn,
1007 int width, int height)
1008{
1009 struct drm_cmdline_mode *cmdline_mode;
1010 struct drm_display_mode *mode = NULL;
1011
1012 cmdline_mode = &fb_helper_conn->cmdline_mode;
1013 if (cmdline_mode->specified == false)
1014 return mode;
1015
1016 /* attempt to find a matching mode in the list of modes
1017 * we have gotten so far, if not add a CVT mode that conforms
1018 */
1019 if (cmdline_mode->rb || cmdline_mode->margins)
1020 goto create_mode;
1021
1022 list_for_each_entry(mode, &fb_helper_conn->connector->modes, head) {
1023 /* check width/height */
1024 if (mode->hdisplay != cmdline_mode->xres ||
1025 mode->vdisplay != cmdline_mode->yres)
1026 continue;
1027
1028 if (cmdline_mode->refresh_specified) {
1029 if (mode->vrefresh != cmdline_mode->refresh)
1030 continue;
1031 }
1032
1033 if (cmdline_mode->interlace) {
1034 if (!(mode->flags & DRM_MODE_FLAG_INTERLACE))
1035 continue;
1036 }
1037 return mode;
1038 }
1039
1040create_mode:
1041 mode = drm_mode_create_from_cmdline_mode(fb_helper_conn->connector->dev,
1042 cmdline_mode);
1043 list_add(&mode->head, &fb_helper_conn->connector->modes);
1044 return mode;
1045}
1046
1047static bool drm_connector_enabled(struct drm_connector *connector, bool strict)
1048{
1049 bool enable;
1050
1051 if (strict) {
1052 enable = connector->status == connector_status_connected;
1053 } else {
1054 enable = connector->status != connector_status_disconnected;
1055 }
1056 return enable;
1057}
1058
1059static void drm_enable_connectors(struct drm_fb_helper *fb_helper,
1060 bool *enabled)
1061{
1062 bool any_enabled = false;
1063 struct drm_connector *connector;
1064 int i = 0;
1065
1066 for (i = 0; i < fb_helper->connector_count; i++) {
1067 connector = fb_helper->connector_info[i]->connector;
1068 enabled[i] = drm_connector_enabled(connector, true);
1069 DRM_DEBUG_KMS("connector %d enabled? %s\n", connector->base.id,
1070 enabled[i] ? "yes" : "no");
1071 any_enabled |= enabled[i];
1072 }
1073
1074 if (any_enabled)
1075 return;
1076
1077 for (i = 0; i < fb_helper->connector_count; i++) {
1078 connector = fb_helper->connector_info[i]->connector;
1079 enabled[i] = drm_connector_enabled(connector, false);
1080 }
1081}
1082
1083static bool drm_target_cloned(struct drm_fb_helper *fb_helper,
1084 struct drm_display_mode **modes,
1085 bool *enabled, int width, int height)
1086{
1087 int count, i, j;
1088 bool can_clone = false;
1089 struct drm_fb_helper_connector *fb_helper_conn;
1090 struct drm_display_mode *dmt_mode, *mode;
1091
1092 /* only contemplate cloning in the single crtc case */
1093 if (fb_helper->crtc_count > 1)
1094 return false;
1095
1096 count = 0;
1097 for (i = 0; i < fb_helper->connector_count; i++) {
1098 if (enabled[i])
1099 count++;
1100 }
1101
1102 /* only contemplate cloning if more than one connector is enabled */
1103 if (count <= 1)
1104 return false;
1105
1106 /* check the command line or if nothing common pick 1024x768 */
1107 can_clone = true;
1108 for (i = 0; i < fb_helper->connector_count; i++) {
1109 if (!enabled[i])
1110 continue;
1111 fb_helper_conn = fb_helper->connector_info[i];
1112 modes[i] = drm_pick_cmdline_mode(fb_helper_conn, width, height);
1113 if (!modes[i]) {
1114 can_clone = false;
1115 break;
1116 }
1117 for (j = 0; j < i; j++) {
1118 if (!enabled[j])
1119 continue;
1120 if (!drm_mode_equal(modes[j], modes[i]))
1121 can_clone = false;
1122 }
1123 }
1124
1125 if (can_clone) {
1126 DRM_DEBUG_KMS("can clone using command line\n");
1127 return true;
1128 }
1129
1130 /* try and find a 1024x768 mode on each connector */
1131 can_clone = true;
1132 dmt_mode = drm_mode_find_dmt(fb_helper->dev, 1024, 768, 60);
1133
1134 for (i = 0; i < fb_helper->connector_count; i++) {
1135
1136 if (!enabled[i])
1137 continue;
1138
1139 fb_helper_conn = fb_helper->connector_info[i];
1140 list_for_each_entry(mode, &fb_helper_conn->connector->modes, head) {
1141 if (drm_mode_equal(mode, dmt_mode))
1142 modes[i] = mode;
1143 }
1144 if (!modes[i])
1145 can_clone = false;
1146 }
1147
1148 if (can_clone) {
1149 DRM_DEBUG_KMS("can clone using 1024x768\n");
1150 return true;
1151 }
1152 DRM_INFO("kms: can't enable cloning when we probably wanted to.\n");
1153 return false;
1154}
1155
1156static bool drm_target_preferred(struct drm_fb_helper *fb_helper,
1157 struct drm_display_mode **modes,
1158 bool *enabled, int width, int height)
1159{
1160 struct drm_fb_helper_connector *fb_helper_conn;
1161 int i;
1162
1163 for (i = 0; i < fb_helper->connector_count; i++) {
1164 fb_helper_conn = fb_helper->connector_info[i];
1165
1166 if (enabled[i] == false)
1167 continue;
1168
1169 DRM_DEBUG_KMS("looking for cmdline mode on connector %d\n",
1170 fb_helper_conn->connector->base.id);
1171
1172 /* got for command line mode first */
1173 modes[i] = drm_pick_cmdline_mode(fb_helper_conn, width, height);
1174 if (!modes[i]) {
1175 DRM_DEBUG_KMS("looking for preferred mode on connector %d\n",
1176 fb_helper_conn->connector->base.id);
1177 modes[i] = drm_has_preferred_mode(fb_helper_conn, width, height);
1178 }
1179 /* No preferred modes, pick one off the list */
1180 if (!modes[i] && !list_empty(&fb_helper_conn->connector->modes)) {
1181 list_for_each_entry(modes[i], &fb_helper_conn->connector->modes, head)
1182 break;
1183 }
1184 DRM_DEBUG_KMS("found mode %s\n", modes[i] ? modes[i]->name :
1185 "none");
1186 }
1187 return true;
1188}
1189
1190static int drm_pick_crtcs(struct drm_fb_helper *fb_helper,
1191 struct drm_fb_helper_crtc **best_crtcs,
1192 struct drm_display_mode **modes,
1193 int n, int width, int height)
1194{
1195 int c, o;
1196 struct drm_device *dev = fb_helper->dev;
1197 struct drm_connector *connector;
1198 struct drm_connector_helper_funcs *connector_funcs;
1199 struct drm_encoder *encoder;
1200 struct drm_fb_helper_crtc *best_crtc;
1201 int my_score, best_score, score;
1202 struct drm_fb_helper_crtc **crtcs, *crtc;
1203 struct drm_fb_helper_connector *fb_helper_conn;
1204
1205 if (n == fb_helper->connector_count)
1206 return 0;
1207
1208 fb_helper_conn = fb_helper->connector_info[n];
1209 connector = fb_helper_conn->connector;
1210
1211 best_crtcs[n] = NULL;
1212 best_crtc = NULL;
1213 best_score = drm_pick_crtcs(fb_helper, best_crtcs, modes, n+1, width, height);
1214 if (modes[n] == NULL)
1215 return best_score;
1216
1217 crtcs = kzalloc(dev->mode_config.num_connector *
1218 sizeof(struct drm_fb_helper_crtc *), GFP_KERNEL);
1219 if (!crtcs)
1220 return best_score;
1221
1222 my_score = 1;
1223 if (connector->status == connector_status_connected)
1224 my_score++;
1225 if (drm_has_cmdline_mode(fb_helper_conn))
1226 my_score++;
1227 if (drm_has_preferred_mode(fb_helper_conn, width, height))
1228 my_score++;
1229
1230 connector_funcs = connector->helper_private;
1231 encoder = connector_funcs->best_encoder(connector);
1232 if (!encoder)
1233 goto out;
1234
1235 /* select a crtc for this connector and then attempt to configure
1236 remaining connectors */
1237 for (c = 0; c < fb_helper->crtc_count; c++) {
1238 crtc = &fb_helper->crtc_info[c];
1239
1240 if ((encoder->possible_crtcs & (1 << c)) == 0) {
1241 continue;
1242 }
1243
1244 for (o = 0; o < n; o++)
1245 if (best_crtcs[o] == crtc)
1246 break;
1247
1248 if (o < n) {
1249 /* ignore cloning unless only a single crtc */
1250 if (fb_helper->crtc_count > 1)
1251 continue;
1252
1253 if (!drm_mode_equal(modes[o], modes[n]))
1254 continue;
1255 }
1256
1257 crtcs[n] = crtc;
1258 memcpy(crtcs, best_crtcs, n * sizeof(struct drm_fb_helper_crtc *));
1259 score = my_score + drm_pick_crtcs(fb_helper, crtcs, modes, n + 1,
1260 width, height);
1261 if (score > best_score) {
1262 best_crtc = crtc;
1263 best_score = score;
1264 memcpy(best_crtcs, crtcs,
1265 dev->mode_config.num_connector *
1266 sizeof(struct drm_fb_helper_crtc *));
1267 }
1268 }
1269out:
1270 kfree(crtcs);
1271 return best_score;
1272}
1273
1274static void drm_setup_crtcs(struct drm_fb_helper *fb_helper)
1275{
1276 struct drm_device *dev = fb_helper->dev;
1277 struct drm_fb_helper_crtc **crtcs;
1278 struct drm_display_mode **modes;
1279 struct drm_encoder *encoder;
1280 struct drm_mode_set *modeset;
1281 bool *enabled;
1282 int width, height;
1283 int i, ret;
1284
1285 DRM_DEBUG_KMS("\n");
1286
1287 width = dev->mode_config.max_width;
1288 height = dev->mode_config.max_height;
1289
1290 /* clean out all the encoder/crtc combos */
1291 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
1292 encoder->crtc = NULL;
1293 }
1294
1295 crtcs = kcalloc(dev->mode_config.num_connector,
1296 sizeof(struct drm_fb_helper_crtc *), GFP_KERNEL);
1297 modes = kcalloc(dev->mode_config.num_connector,
1298 sizeof(struct drm_display_mode *), GFP_KERNEL);
1299 enabled = kcalloc(dev->mode_config.num_connector,
1300 sizeof(bool), GFP_KERNEL);
1301
1302 drm_enable_connectors(fb_helper, enabled);
1303
1304 ret = drm_target_cloned(fb_helper, modes, enabled, width, height);
1305 if (!ret) {
1306 ret = drm_target_preferred(fb_helper, modes, enabled, width, height);
1307 if (!ret)
1308 DRM_ERROR("Unable to find initial modes\n");
1309 }
1310
1311 DRM_DEBUG_KMS("picking CRTCs for %dx%d config\n", width, height);
1312
1313 drm_pick_crtcs(fb_helper, crtcs, modes, 0, width, height);
1314
1315 /* need to set the modesets up here for use later */
1316 /* fill out the connector<->crtc mappings into the modesets */
1317 for (i = 0; i < fb_helper->crtc_count; i++) {
1318 modeset = &fb_helper->crtc_info[i].mode_set;
1319 modeset->num_connectors = 0;
1320 }
1321
1322 for (i = 0; i < fb_helper->connector_count; i++) {
1323 struct drm_display_mode *mode = modes[i];
1324 struct drm_fb_helper_crtc *fb_crtc = crtcs[i];
1325 modeset = &fb_crtc->mode_set;
1326
1327 if (mode && fb_crtc) {
1328 DRM_DEBUG_KMS("desired mode %s set on crtc %d\n",
1329 mode->name, fb_crtc->mode_set.crtc->base.id);
1330 fb_crtc->desired_mode = mode;
1331 if (modeset->mode)
1332 drm_mode_destroy(dev, modeset->mode);
1333 modeset->mode = drm_mode_duplicate(dev,
1334 fb_crtc->desired_mode);
1335 modeset->connectors[modeset->num_connectors++] = fb_helper->connector_info[i]->connector;
1336 }
1337 }
1338
1339 kfree(crtcs);
1340 kfree(modes);
1341 kfree(enabled);
1342}
1343
1344/**
1345 * drm_helper_initial_config - setup a sane initial connector configuration
1346 * @dev: DRM device
1347 *
1348 * LOCKING:
1349 * Called at init time, must take mode config lock.
1350 *
1351 * Scan the CRTCs and connectors and try to put together an initial setup.
1352 * At the moment, this is a cloned configuration across all heads with
1353 * a new framebuffer object as the backing store.
1354 *
1355 * RETURNS:
1356 * Zero if everything went ok, nonzero otherwise.
1357 */
1358bool drm_fb_helper_initial_config(struct drm_fb_helper *fb_helper, int bpp_sel)
1359{
1360 struct drm_device *dev = fb_helper->dev;
1361 int count = 0;
1362
1363 /* disable all the possible outputs/crtcs before entering KMS mode */
1364 drm_helper_disable_unused_functions(fb_helper->dev);
1365
1366 drm_fb_helper_parse_command_line(fb_helper);
1367
1368 count = drm_fb_helper_probe_connector_modes(fb_helper,
1369 dev->mode_config.max_width,
1370 dev->mode_config.max_height);
1371 /*
1372 * we shouldn't end up with no modes here.
1373 */
1374 if (count == 0) {
1375 printk(KERN_INFO "No connectors reported connected with modes\n");
1376 }
1377 drm_setup_crtcs(fb_helper);
1378
1379 return drm_fb_helper_single_fb_probe(fb_helper, bpp_sel);
1380}
1381EXPORT_SYMBOL(drm_fb_helper_initial_config);
1382
1383/**
1384 * drm_fb_helper_hotplug_event - respond to a hotplug notification by
1385 * probing all the outputs attached to the fb.
1386 * @fb_helper: the drm_fb_helper
1387 *
1388 * LOCKING:
1389 * Called at runtime, must take mode config lock.
1390 *
1391 * Scan the connectors attached to the fb_helper and try to put together a
1392 * setup after *notification of a change in output configuration.
1393 *
1394 * RETURNS:
1395 * 0 on success and a non-zero error code otherwise.
1396 */
1397int drm_fb_helper_hotplug_event(struct drm_fb_helper *fb_helper)
1398{
1399 struct drm_device *dev = fb_helper->dev;
1400 int count = 0;
1401 u32 max_width, max_height, bpp_sel;
1402 bool bound = false, crtcs_bound = false;
1403 struct drm_crtc *crtc;
1404
1405 if (!fb_helper->fb)
1406 return 0;
1407
1408 mutex_lock(&dev->mode_config.mutex);
1409 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
1410 if (crtc->fb)
1411 crtcs_bound = true;
1412 if (crtc->fb == fb_helper->fb)
1413 bound = true;
1414 }
1415
1416 if (!bound && crtcs_bound) {
1417 fb_helper->delayed_hotplug = true;
1418 mutex_unlock(&dev->mode_config.mutex);
1419 return 0;
1420 }
1421 DRM_DEBUG_KMS("\n");
1422
1423 max_width = fb_helper->fb->width;
1424 max_height = fb_helper->fb->height;
1425 bpp_sel = fb_helper->fb->bits_per_pixel;
1426
1427 count = drm_fb_helper_probe_connector_modes(fb_helper, max_width,
1428 max_height);
1429 drm_setup_crtcs(fb_helper);
1430 mutex_unlock(&dev->mode_config.mutex);
1431
1432 return drm_fb_helper_single_fb_probe(fb_helper, bpp_sel);
1433}
1434EXPORT_SYMBOL(drm_fb_helper_hotplug_event);
1435
1436/* The Kconfig DRM_KMS_HELPER selects FRAMEBUFFER_CONSOLE (if !EXPERT)
1437 * but the module doesn't depend on any fb console symbols. At least
1438 * attempt to load fbcon to avoid leaving the system without a usable console.
1439 */
1440#if defined(CONFIG_FRAMEBUFFER_CONSOLE_MODULE) && !defined(CONFIG_EXPERT)
1441static int __init drm_fb_helper_modinit(void)
1442{
1443 const char *name = "fbcon";
1444 struct module *fbcon;
1445
1446 mutex_lock(&module_mutex);
1447 fbcon = find_module(name);
1448 mutex_unlock(&module_mutex);
1449
1450 if (!fbcon)
1451 request_module_nowait(name);
1452 return 0;
1453}
1454
1455module_init(drm_fb_helper_modinit);
1456#endif
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/kernel.h>
33#include <linux/sysrq.h>
34#include <linux/slab.h>
35#include <linux/fb.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
44static bool drm_fbdev_emulation = true;
45module_param_named(fbdev_emulation, drm_fbdev_emulation, bool, 0600);
46MODULE_PARM_DESC(fbdev_emulation,
47 "Enable legacy fbdev emulation [default=true]");
48
49static LIST_HEAD(kernel_fb_helper_list);
50
51/**
52 * DOC: fbdev helpers
53 *
54 * The fb helper functions are useful to provide an fbdev on top of a drm kernel
55 * mode setting driver. They can be used mostly independently from the crtc
56 * helper functions used by many drivers to implement the kernel mode setting
57 * interfaces.
58 *
59 * Initialization is done as a four-step process with drm_fb_helper_prepare(),
60 * drm_fb_helper_init(), drm_fb_helper_single_add_all_connectors() and
61 * drm_fb_helper_initial_config(). Drivers with fancier requirements than the
62 * default behaviour can override the third step with their own code.
63 * Teardown is done with drm_fb_helper_fini().
64 *
65 * At runtime drivers should restore the fbdev console by calling
66 * drm_fb_helper_restore_fbdev_mode_unlocked() from their ->lastclose callback.
67 * They should also notify the fb helper code from updates to the output
68 * configuration by calling drm_fb_helper_hotplug_event(). For easier
69 * integration with the output polling code in drm_crtc_helper.c the modeset
70 * code provides a ->output_poll_changed callback.
71 *
72 * All other functions exported by the fb helper library can be used to
73 * implement the fbdev driver interface by the driver.
74 *
75 * It is possible, though perhaps somewhat tricky, to implement race-free
76 * hotplug detection using the fbdev helpers. The drm_fb_helper_prepare()
77 * helper must be called first to initialize the minimum required to make
78 * hotplug detection work. Drivers also need to make sure to properly set up
79 * the dev->mode_config.funcs member. After calling drm_kms_helper_poll_init()
80 * it is safe to enable interrupts and start processing hotplug events. At the
81 * same time, drivers should initialize all modeset objects such as CRTCs,
82 * encoders and connectors. To finish up the fbdev helper initialization, the
83 * drm_fb_helper_init() function is called. To probe for all attached displays
84 * and set up an initial configuration using the detected hardware, drivers
85 * should call drm_fb_helper_single_add_all_connectors() followed by
86 * drm_fb_helper_initial_config().
87 */
88
89/**
90 * drm_fb_helper_single_add_all_connectors() - add all connectors to fbdev
91 * emulation helper
92 * @fb_helper: fbdev initialized with drm_fb_helper_init
93 *
94 * This functions adds all the available connectors for use with the given
95 * fb_helper. This is a separate step to allow drivers to freely assign
96 * connectors to the fbdev, e.g. if some are reserved for special purposes or
97 * not adequate to be used for the fbcon.
98 *
99 * This function is protected against concurrent connector hotadds/removals
100 * using drm_fb_helper_add_one_connector() and
101 * drm_fb_helper_remove_one_connector().
102 */
103int drm_fb_helper_single_add_all_connectors(struct drm_fb_helper *fb_helper)
104{
105 struct drm_device *dev = fb_helper->dev;
106 struct drm_connector *connector;
107 int i, ret;
108
109 if (!drm_fbdev_emulation)
110 return 0;
111
112 mutex_lock(&dev->mode_config.mutex);
113 drm_for_each_connector(connector, dev) {
114 ret = drm_fb_helper_add_one_connector(fb_helper, connector);
115
116 if (ret)
117 goto fail;
118 }
119 mutex_unlock(&dev->mode_config.mutex);
120 return 0;
121fail:
122 for (i = 0; i < fb_helper->connector_count; i++) {
123 kfree(fb_helper->connector_info[i]);
124 fb_helper->connector_info[i] = NULL;
125 }
126 fb_helper->connector_count = 0;
127 mutex_unlock(&dev->mode_config.mutex);
128
129 return ret;
130}
131EXPORT_SYMBOL(drm_fb_helper_single_add_all_connectors);
132
133int drm_fb_helper_add_one_connector(struct drm_fb_helper *fb_helper, struct drm_connector *connector)
134{
135 struct drm_fb_helper_connector **temp;
136 struct drm_fb_helper_connector *fb_helper_connector;
137
138 if (!drm_fbdev_emulation)
139 return 0;
140
141 WARN_ON(!mutex_is_locked(&fb_helper->dev->mode_config.mutex));
142 if (fb_helper->connector_count + 1 > fb_helper->connector_info_alloc_count) {
143 temp = krealloc(fb_helper->connector_info, sizeof(struct drm_fb_helper_connector *) * (fb_helper->connector_count + 1), GFP_KERNEL);
144 if (!temp)
145 return -ENOMEM;
146
147 fb_helper->connector_info_alloc_count = fb_helper->connector_count + 1;
148 fb_helper->connector_info = temp;
149 }
150
151
152 fb_helper_connector = kzalloc(sizeof(struct drm_fb_helper_connector), GFP_KERNEL);
153 if (!fb_helper_connector)
154 return -ENOMEM;
155
156 fb_helper_connector->connector = connector;
157 fb_helper->connector_info[fb_helper->connector_count++] = fb_helper_connector;
158 return 0;
159}
160EXPORT_SYMBOL(drm_fb_helper_add_one_connector);
161
162static void remove_from_modeset(struct drm_mode_set *set,
163 struct drm_connector *connector)
164{
165 int i, j;
166
167 for (i = 0; i < set->num_connectors; i++) {
168 if (set->connectors[i] == connector)
169 break;
170 }
171
172 if (i == set->num_connectors)
173 return;
174
175 for (j = i + 1; j < set->num_connectors; j++) {
176 set->connectors[j - 1] = set->connectors[j];
177 }
178 set->num_connectors--;
179
180 /*
181 * TODO maybe need to makes sure we set it back to !=NULL somewhere?
182 */
183 if (set->num_connectors == 0) {
184 set->fb = NULL;
185 drm_mode_destroy(connector->dev, set->mode);
186 set->mode = NULL;
187 }
188}
189
190int drm_fb_helper_remove_one_connector(struct drm_fb_helper *fb_helper,
191 struct drm_connector *connector)
192{
193 struct drm_fb_helper_connector *fb_helper_connector;
194 int i, j;
195
196 if (!drm_fbdev_emulation)
197 return 0;
198
199 WARN_ON(!mutex_is_locked(&fb_helper->dev->mode_config.mutex));
200
201 for (i = 0; i < fb_helper->connector_count; i++) {
202 if (fb_helper->connector_info[i]->connector == connector)
203 break;
204 }
205
206 if (i == fb_helper->connector_count)
207 return -EINVAL;
208 fb_helper_connector = fb_helper->connector_info[i];
209
210 for (j = i + 1; j < fb_helper->connector_count; j++) {
211 fb_helper->connector_info[j - 1] = fb_helper->connector_info[j];
212 }
213 fb_helper->connector_count--;
214 kfree(fb_helper_connector);
215
216 /* also cleanup dangling references to the connector: */
217 for (i = 0; i < fb_helper->crtc_count; i++)
218 remove_from_modeset(&fb_helper->crtc_info[i].mode_set, connector);
219
220 return 0;
221}
222EXPORT_SYMBOL(drm_fb_helper_remove_one_connector);
223
224static void drm_fb_helper_save_lut_atomic(struct drm_crtc *crtc, struct drm_fb_helper *helper)
225{
226 uint16_t *r_base, *g_base, *b_base;
227 int i;
228
229 if (helper->funcs->gamma_get == NULL)
230 return;
231
232 r_base = crtc->gamma_store;
233 g_base = r_base + crtc->gamma_size;
234 b_base = g_base + crtc->gamma_size;
235
236 for (i = 0; i < crtc->gamma_size; i++)
237 helper->funcs->gamma_get(crtc, &r_base[i], &g_base[i], &b_base[i], i);
238}
239
240static void drm_fb_helper_restore_lut_atomic(struct drm_crtc *crtc)
241{
242 uint16_t *r_base, *g_base, *b_base;
243
244 if (crtc->funcs->gamma_set == NULL)
245 return;
246
247 r_base = crtc->gamma_store;
248 g_base = r_base + crtc->gamma_size;
249 b_base = g_base + crtc->gamma_size;
250
251 crtc->funcs->gamma_set(crtc, r_base, g_base, b_base, 0, crtc->gamma_size);
252}
253
254/**
255 * drm_fb_helper_debug_enter - implementation for ->fb_debug_enter
256 * @info: fbdev registered by the helper
257 */
258int drm_fb_helper_debug_enter(struct fb_info *info)
259{
260 struct drm_fb_helper *helper = info->par;
261 const struct drm_crtc_helper_funcs *funcs;
262 int i;
263
264 list_for_each_entry(helper, &kernel_fb_helper_list, kernel_fb_list) {
265 for (i = 0; i < helper->crtc_count; i++) {
266 struct drm_mode_set *mode_set =
267 &helper->crtc_info[i].mode_set;
268
269 if (!mode_set->crtc->enabled)
270 continue;
271
272 funcs = mode_set->crtc->helper_private;
273 drm_fb_helper_save_lut_atomic(mode_set->crtc, helper);
274 funcs->mode_set_base_atomic(mode_set->crtc,
275 mode_set->fb,
276 mode_set->x,
277 mode_set->y,
278 ENTER_ATOMIC_MODE_SET);
279 }
280 }
281
282 return 0;
283}
284EXPORT_SYMBOL(drm_fb_helper_debug_enter);
285
286/* Find the real fb for a given fb helper CRTC */
287static struct drm_framebuffer *drm_mode_config_fb(struct drm_crtc *crtc)
288{
289 struct drm_device *dev = crtc->dev;
290 struct drm_crtc *c;
291
292 drm_for_each_crtc(c, dev) {
293 if (crtc->base.id == c->base.id)
294 return c->primary->fb;
295 }
296
297 return NULL;
298}
299
300/**
301 * drm_fb_helper_debug_leave - implementation for ->fb_debug_leave
302 * @info: fbdev registered by the helper
303 */
304int drm_fb_helper_debug_leave(struct fb_info *info)
305{
306 struct drm_fb_helper *helper = info->par;
307 struct drm_crtc *crtc;
308 const struct drm_crtc_helper_funcs *funcs;
309 struct drm_framebuffer *fb;
310 int i;
311
312 for (i = 0; i < helper->crtc_count; i++) {
313 struct drm_mode_set *mode_set = &helper->crtc_info[i].mode_set;
314 crtc = mode_set->crtc;
315 funcs = crtc->helper_private;
316 fb = drm_mode_config_fb(crtc);
317
318 if (!crtc->enabled)
319 continue;
320
321 if (!fb) {
322 DRM_ERROR("no fb to restore??\n");
323 continue;
324 }
325
326 drm_fb_helper_restore_lut_atomic(mode_set->crtc);
327 funcs->mode_set_base_atomic(mode_set->crtc, fb, crtc->x,
328 crtc->y, LEAVE_ATOMIC_MODE_SET);
329 }
330
331 return 0;
332}
333EXPORT_SYMBOL(drm_fb_helper_debug_leave);
334
335static int restore_fbdev_mode_atomic(struct drm_fb_helper *fb_helper)
336{
337 struct drm_device *dev = fb_helper->dev;
338 struct drm_plane *plane;
339 struct drm_atomic_state *state;
340 int i, ret;
341 unsigned plane_mask;
342
343 state = drm_atomic_state_alloc(dev);
344 if (!state)
345 return -ENOMEM;
346
347 state->acquire_ctx = dev->mode_config.acquire_ctx;
348retry:
349 plane_mask = 0;
350 drm_for_each_plane(plane, dev) {
351 struct drm_plane_state *plane_state;
352
353 plane_state = drm_atomic_get_plane_state(state, plane);
354 if (IS_ERR(plane_state)) {
355 ret = PTR_ERR(plane_state);
356 goto fail;
357 }
358
359 plane_state->rotation = BIT(DRM_ROTATE_0);
360
361 plane->old_fb = plane->fb;
362 plane_mask |= 1 << drm_plane_index(plane);
363
364 /* disable non-primary: */
365 if (plane->type == DRM_PLANE_TYPE_PRIMARY)
366 continue;
367
368 ret = __drm_atomic_helper_disable_plane(plane, plane_state);
369 if (ret != 0)
370 goto fail;
371 }
372
373 for(i = 0; i < fb_helper->crtc_count; i++) {
374 struct drm_mode_set *mode_set = &fb_helper->crtc_info[i].mode_set;
375
376 ret = __drm_atomic_helper_set_config(mode_set, state);
377 if (ret != 0)
378 goto fail;
379 }
380
381 ret = drm_atomic_commit(state);
382
383fail:
384 drm_atomic_clean_old_fb(dev, plane_mask, ret);
385
386 if (ret == -EDEADLK)
387 goto backoff;
388
389 if (ret != 0)
390 drm_atomic_state_free(state);
391
392 return ret;
393
394backoff:
395 drm_atomic_state_clear(state);
396 drm_atomic_legacy_backoff(state);
397
398 goto retry;
399}
400
401static int restore_fbdev_mode(struct drm_fb_helper *fb_helper)
402{
403 struct drm_device *dev = fb_helper->dev;
404 struct drm_plane *plane;
405 int i;
406
407 drm_warn_on_modeset_not_all_locked(dev);
408
409 if (fb_helper->atomic)
410 return restore_fbdev_mode_atomic(fb_helper);
411
412 drm_for_each_plane(plane, dev) {
413 if (plane->type != DRM_PLANE_TYPE_PRIMARY)
414 drm_plane_force_disable(plane);
415
416 if (dev->mode_config.rotation_property) {
417 drm_mode_plane_set_obj_prop(plane,
418 dev->mode_config.rotation_property,
419 BIT(DRM_ROTATE_0));
420 }
421 }
422
423 for (i = 0; i < fb_helper->crtc_count; i++) {
424 struct drm_mode_set *mode_set = &fb_helper->crtc_info[i].mode_set;
425 struct drm_crtc *crtc = mode_set->crtc;
426 int ret;
427
428 if (crtc->funcs->cursor_set2) {
429 ret = crtc->funcs->cursor_set2(crtc, NULL, 0, 0, 0, 0, 0);
430 if (ret)
431 return ret;
432 } else if (crtc->funcs->cursor_set) {
433 ret = crtc->funcs->cursor_set(crtc, NULL, 0, 0, 0);
434 if (ret)
435 return ret;
436 }
437
438 ret = drm_mode_set_config_internal(mode_set);
439 if (ret)
440 return ret;
441 }
442
443 return 0;
444}
445
446/**
447 * drm_fb_helper_restore_fbdev_mode_unlocked - restore fbdev configuration
448 * @fb_helper: fbcon to restore
449 *
450 * This should be called from driver's drm ->lastclose callback
451 * when implementing an fbcon on top of kms using this helper. This ensures that
452 * the user isn't greeted with a black screen when e.g. X dies.
453 *
454 * RETURNS:
455 * Zero if everything went ok, negative error code otherwise.
456 */
457int drm_fb_helper_restore_fbdev_mode_unlocked(struct drm_fb_helper *fb_helper)
458{
459 struct drm_device *dev = fb_helper->dev;
460 bool do_delayed;
461 int ret;
462
463 if (!drm_fbdev_emulation)
464 return -ENODEV;
465
466 drm_modeset_lock_all(dev);
467 ret = restore_fbdev_mode(fb_helper);
468
469 do_delayed = fb_helper->delayed_hotplug;
470 if (do_delayed)
471 fb_helper->delayed_hotplug = false;
472 drm_modeset_unlock_all(dev);
473
474 if (do_delayed)
475 drm_fb_helper_hotplug_event(fb_helper);
476 return ret;
477}
478EXPORT_SYMBOL(drm_fb_helper_restore_fbdev_mode_unlocked);
479
480static bool drm_fb_helper_is_bound(struct drm_fb_helper *fb_helper)
481{
482 struct drm_device *dev = fb_helper->dev;
483 struct drm_crtc *crtc;
484 int bound = 0, crtcs_bound = 0;
485
486 /* Sometimes user space wants everything disabled, so don't steal the
487 * display if there's a master. */
488 if (dev->primary->master)
489 return false;
490
491 drm_for_each_crtc(crtc, dev) {
492 if (crtc->primary->fb)
493 crtcs_bound++;
494 if (crtc->primary->fb == fb_helper->fb)
495 bound++;
496 }
497
498 if (bound < crtcs_bound)
499 return false;
500
501 return true;
502}
503
504#ifdef CONFIG_MAGIC_SYSRQ
505/*
506 * restore fbcon display for all kms driver's using this helper, used for sysrq
507 * and panic handling.
508 */
509static bool drm_fb_helper_force_kernel_mode(void)
510{
511 bool ret, error = false;
512 struct drm_fb_helper *helper;
513
514 if (list_empty(&kernel_fb_helper_list))
515 return false;
516
517 list_for_each_entry(helper, &kernel_fb_helper_list, kernel_fb_list) {
518 struct drm_device *dev = helper->dev;
519
520 if (dev->switch_power_state == DRM_SWITCH_POWER_OFF)
521 continue;
522
523 drm_modeset_lock_all(dev);
524 ret = restore_fbdev_mode(helper);
525 if (ret)
526 error = true;
527 drm_modeset_unlock_all(dev);
528 }
529 return error;
530}
531
532static void drm_fb_helper_restore_work_fn(struct work_struct *ignored)
533{
534 bool ret;
535 ret = drm_fb_helper_force_kernel_mode();
536 if (ret == true)
537 DRM_ERROR("Failed to restore crtc configuration\n");
538}
539static DECLARE_WORK(drm_fb_helper_restore_work, drm_fb_helper_restore_work_fn);
540
541static void drm_fb_helper_sysrq(int dummy1)
542{
543 schedule_work(&drm_fb_helper_restore_work);
544}
545
546static struct sysrq_key_op sysrq_drm_fb_helper_restore_op = {
547 .handler = drm_fb_helper_sysrq,
548 .help_msg = "force-fb(V)",
549 .action_msg = "Restore framebuffer console",
550};
551#else
552static struct sysrq_key_op sysrq_drm_fb_helper_restore_op = { };
553#endif
554
555static void drm_fb_helper_dpms(struct fb_info *info, int dpms_mode)
556{
557 struct drm_fb_helper *fb_helper = info->par;
558 struct drm_device *dev = fb_helper->dev;
559 struct drm_crtc *crtc;
560 struct drm_connector *connector;
561 int i, j;
562
563 /*
564 * For each CRTC in this fb, turn the connectors on/off.
565 */
566 drm_modeset_lock_all(dev);
567 if (!drm_fb_helper_is_bound(fb_helper)) {
568 drm_modeset_unlock_all(dev);
569 return;
570 }
571
572 for (i = 0; i < fb_helper->crtc_count; i++) {
573 crtc = fb_helper->crtc_info[i].mode_set.crtc;
574
575 if (!crtc->enabled)
576 continue;
577
578 /* Walk the connectors & encoders on this fb turning them on/off */
579 for (j = 0; j < fb_helper->connector_count; j++) {
580 connector = fb_helper->connector_info[j]->connector;
581 connector->funcs->dpms(connector, dpms_mode);
582 drm_object_property_set_value(&connector->base,
583 dev->mode_config.dpms_property, dpms_mode);
584 }
585 }
586 drm_modeset_unlock_all(dev);
587}
588
589/**
590 * drm_fb_helper_blank - implementation for ->fb_blank
591 * @blank: desired blanking state
592 * @info: fbdev registered by the helper
593 */
594int drm_fb_helper_blank(int blank, struct fb_info *info)
595{
596 if (oops_in_progress)
597 return -EBUSY;
598
599 switch (blank) {
600 /* Display: On; HSync: On, VSync: On */
601 case FB_BLANK_UNBLANK:
602 drm_fb_helper_dpms(info, DRM_MODE_DPMS_ON);
603 break;
604 /* Display: Off; HSync: On, VSync: On */
605 case FB_BLANK_NORMAL:
606 drm_fb_helper_dpms(info, DRM_MODE_DPMS_STANDBY);
607 break;
608 /* Display: Off; HSync: Off, VSync: On */
609 case FB_BLANK_HSYNC_SUSPEND:
610 drm_fb_helper_dpms(info, DRM_MODE_DPMS_STANDBY);
611 break;
612 /* Display: Off; HSync: On, VSync: Off */
613 case FB_BLANK_VSYNC_SUSPEND:
614 drm_fb_helper_dpms(info, DRM_MODE_DPMS_SUSPEND);
615 break;
616 /* Display: Off; HSync: Off, VSync: Off */
617 case FB_BLANK_POWERDOWN:
618 drm_fb_helper_dpms(info, DRM_MODE_DPMS_OFF);
619 break;
620 }
621 return 0;
622}
623EXPORT_SYMBOL(drm_fb_helper_blank);
624
625static void drm_fb_helper_crtc_free(struct drm_fb_helper *helper)
626{
627 int i;
628
629 for (i = 0; i < helper->connector_count; i++)
630 kfree(helper->connector_info[i]);
631 kfree(helper->connector_info);
632 for (i = 0; i < helper->crtc_count; i++) {
633 kfree(helper->crtc_info[i].mode_set.connectors);
634 if (helper->crtc_info[i].mode_set.mode)
635 drm_mode_destroy(helper->dev, helper->crtc_info[i].mode_set.mode);
636 }
637 kfree(helper->crtc_info);
638}
639
640/**
641 * drm_fb_helper_prepare - setup a drm_fb_helper structure
642 * @dev: DRM device
643 * @helper: driver-allocated fbdev helper structure to set up
644 * @funcs: pointer to structure of functions associate with this helper
645 *
646 * Sets up the bare minimum to make the framebuffer helper usable. This is
647 * useful to implement race-free initialization of the polling helpers.
648 */
649void drm_fb_helper_prepare(struct drm_device *dev, struct drm_fb_helper *helper,
650 const struct drm_fb_helper_funcs *funcs)
651{
652 INIT_LIST_HEAD(&helper->kernel_fb_list);
653 helper->funcs = funcs;
654 helper->dev = dev;
655}
656EXPORT_SYMBOL(drm_fb_helper_prepare);
657
658/**
659 * drm_fb_helper_init - initialize a drm_fb_helper structure
660 * @dev: drm device
661 * @fb_helper: driver-allocated fbdev helper structure to initialize
662 * @crtc_count: maximum number of crtcs to support in this fbdev emulation
663 * @max_conn_count: max connector count
664 *
665 * This allocates the structures for the fbdev helper with the given limits.
666 * Note that this won't yet touch the hardware (through the driver interfaces)
667 * nor register the fbdev. This is only done in drm_fb_helper_initial_config()
668 * to allow driver writes more control over the exact init sequence.
669 *
670 * Drivers must call drm_fb_helper_prepare() before calling this function.
671 *
672 * RETURNS:
673 * Zero if everything went ok, nonzero otherwise.
674 */
675int drm_fb_helper_init(struct drm_device *dev,
676 struct drm_fb_helper *fb_helper,
677 int crtc_count, int max_conn_count)
678{
679 struct drm_crtc *crtc;
680 int i;
681
682 if (!drm_fbdev_emulation)
683 return 0;
684
685 if (!max_conn_count)
686 return -EINVAL;
687
688 fb_helper->crtc_info = kcalloc(crtc_count, sizeof(struct drm_fb_helper_crtc), GFP_KERNEL);
689 if (!fb_helper->crtc_info)
690 return -ENOMEM;
691
692 fb_helper->crtc_count = crtc_count;
693 fb_helper->connector_info = kcalloc(dev->mode_config.num_connector, sizeof(struct drm_fb_helper_connector *), GFP_KERNEL);
694 if (!fb_helper->connector_info) {
695 kfree(fb_helper->crtc_info);
696 return -ENOMEM;
697 }
698 fb_helper->connector_info_alloc_count = dev->mode_config.num_connector;
699 fb_helper->connector_count = 0;
700
701 for (i = 0; i < crtc_count; i++) {
702 fb_helper->crtc_info[i].mode_set.connectors =
703 kcalloc(max_conn_count,
704 sizeof(struct drm_connector *),
705 GFP_KERNEL);
706
707 if (!fb_helper->crtc_info[i].mode_set.connectors)
708 goto out_free;
709 fb_helper->crtc_info[i].mode_set.num_connectors = 0;
710 }
711
712 i = 0;
713 drm_for_each_crtc(crtc, dev) {
714 fb_helper->crtc_info[i].mode_set.crtc = crtc;
715 i++;
716 }
717
718 fb_helper->atomic = !!drm_core_check_feature(dev, DRIVER_ATOMIC);
719
720 return 0;
721out_free:
722 drm_fb_helper_crtc_free(fb_helper);
723 return -ENOMEM;
724}
725EXPORT_SYMBOL(drm_fb_helper_init);
726
727/**
728 * drm_fb_helper_alloc_fbi - allocate fb_info and some of its members
729 * @fb_helper: driver-allocated fbdev helper
730 *
731 * A helper to alloc fb_info and the members cmap and apertures. Called
732 * by the driver within the fb_probe fb_helper callback function.
733 *
734 * RETURNS:
735 * fb_info pointer if things went okay, pointer containing error code
736 * otherwise
737 */
738struct fb_info *drm_fb_helper_alloc_fbi(struct drm_fb_helper *fb_helper)
739{
740 struct device *dev = fb_helper->dev->dev;
741 struct fb_info *info;
742 int ret;
743
744 info = framebuffer_alloc(0, dev);
745 if (!info)
746 return ERR_PTR(-ENOMEM);
747
748 ret = fb_alloc_cmap(&info->cmap, 256, 0);
749 if (ret)
750 goto err_release;
751
752 info->apertures = alloc_apertures(1);
753 if (!info->apertures) {
754 ret = -ENOMEM;
755 goto err_free_cmap;
756 }
757
758 fb_helper->fbdev = info;
759
760 return info;
761
762err_free_cmap:
763 fb_dealloc_cmap(&info->cmap);
764err_release:
765 framebuffer_release(info);
766 return ERR_PTR(ret);
767}
768EXPORT_SYMBOL(drm_fb_helper_alloc_fbi);
769
770/**
771 * drm_fb_helper_unregister_fbi - unregister fb_info framebuffer device
772 * @fb_helper: driver-allocated fbdev helper
773 *
774 * A wrapper around unregister_framebuffer, to release the fb_info
775 * framebuffer device
776 */
777void drm_fb_helper_unregister_fbi(struct drm_fb_helper *fb_helper)
778{
779 if (fb_helper && fb_helper->fbdev)
780 unregister_framebuffer(fb_helper->fbdev);
781}
782EXPORT_SYMBOL(drm_fb_helper_unregister_fbi);
783
784/**
785 * drm_fb_helper_release_fbi - dealloc fb_info and its members
786 * @fb_helper: driver-allocated fbdev helper
787 *
788 * A helper to free memory taken by fb_info and the members cmap and
789 * apertures
790 */
791void drm_fb_helper_release_fbi(struct drm_fb_helper *fb_helper)
792{
793 if (fb_helper) {
794 struct fb_info *info = fb_helper->fbdev;
795
796 if (info) {
797 if (info->cmap.len)
798 fb_dealloc_cmap(&info->cmap);
799 framebuffer_release(info);
800 }
801
802 fb_helper->fbdev = NULL;
803 }
804}
805EXPORT_SYMBOL(drm_fb_helper_release_fbi);
806
807void drm_fb_helper_fini(struct drm_fb_helper *fb_helper)
808{
809 if (!drm_fbdev_emulation)
810 return;
811
812 if (!list_empty(&fb_helper->kernel_fb_list)) {
813 list_del(&fb_helper->kernel_fb_list);
814 if (list_empty(&kernel_fb_helper_list)) {
815 unregister_sysrq_key('v', &sysrq_drm_fb_helper_restore_op);
816 }
817 }
818
819 drm_fb_helper_crtc_free(fb_helper);
820
821}
822EXPORT_SYMBOL(drm_fb_helper_fini);
823
824/**
825 * drm_fb_helper_unlink_fbi - wrapper around unlink_framebuffer
826 * @fb_helper: driver-allocated fbdev helper
827 *
828 * A wrapper around unlink_framebuffer implemented by fbdev core
829 */
830void drm_fb_helper_unlink_fbi(struct drm_fb_helper *fb_helper)
831{
832 if (fb_helper && fb_helper->fbdev)
833 unlink_framebuffer(fb_helper->fbdev);
834}
835EXPORT_SYMBOL(drm_fb_helper_unlink_fbi);
836
837/**
838 * drm_fb_helper_sys_read - wrapper around fb_sys_read
839 * @info: fb_info struct pointer
840 * @buf: userspace buffer to read from framebuffer memory
841 * @count: number of bytes to read from framebuffer memory
842 * @ppos: read offset within framebuffer memory
843 *
844 * A wrapper around fb_sys_read implemented by fbdev core
845 */
846ssize_t drm_fb_helper_sys_read(struct fb_info *info, char __user *buf,
847 size_t count, loff_t *ppos)
848{
849 return fb_sys_read(info, buf, count, ppos);
850}
851EXPORT_SYMBOL(drm_fb_helper_sys_read);
852
853/**
854 * drm_fb_helper_sys_write - wrapper around fb_sys_write
855 * @info: fb_info struct pointer
856 * @buf: userspace buffer to write to framebuffer memory
857 * @count: number of bytes to write to framebuffer memory
858 * @ppos: write offset within framebuffer memory
859 *
860 * A wrapper around fb_sys_write implemented by fbdev core
861 */
862ssize_t drm_fb_helper_sys_write(struct fb_info *info, const char __user *buf,
863 size_t count, loff_t *ppos)
864{
865 return fb_sys_write(info, buf, count, ppos);
866}
867EXPORT_SYMBOL(drm_fb_helper_sys_write);
868
869/**
870 * drm_fb_helper_sys_fillrect - wrapper around sys_fillrect
871 * @info: fbdev registered by the helper
872 * @rect: info about rectangle to fill
873 *
874 * A wrapper around sys_fillrect implemented by fbdev core
875 */
876void drm_fb_helper_sys_fillrect(struct fb_info *info,
877 const struct fb_fillrect *rect)
878{
879 sys_fillrect(info, rect);
880}
881EXPORT_SYMBOL(drm_fb_helper_sys_fillrect);
882
883/**
884 * drm_fb_helper_sys_copyarea - wrapper around sys_copyarea
885 * @info: fbdev registered by the helper
886 * @area: info about area to copy
887 *
888 * A wrapper around sys_copyarea implemented by fbdev core
889 */
890void drm_fb_helper_sys_copyarea(struct fb_info *info,
891 const struct fb_copyarea *area)
892{
893 sys_copyarea(info, area);
894}
895EXPORT_SYMBOL(drm_fb_helper_sys_copyarea);
896
897/**
898 * drm_fb_helper_sys_imageblit - wrapper around sys_imageblit
899 * @info: fbdev registered by the helper
900 * @image: info about image to blit
901 *
902 * A wrapper around sys_imageblit implemented by fbdev core
903 */
904void drm_fb_helper_sys_imageblit(struct fb_info *info,
905 const struct fb_image *image)
906{
907 sys_imageblit(info, image);
908}
909EXPORT_SYMBOL(drm_fb_helper_sys_imageblit);
910
911/**
912 * drm_fb_helper_cfb_fillrect - wrapper around cfb_fillrect
913 * @info: fbdev registered by the helper
914 * @rect: info about rectangle to fill
915 *
916 * A wrapper around cfb_imageblit implemented by fbdev core
917 */
918void drm_fb_helper_cfb_fillrect(struct fb_info *info,
919 const struct fb_fillrect *rect)
920{
921 cfb_fillrect(info, rect);
922}
923EXPORT_SYMBOL(drm_fb_helper_cfb_fillrect);
924
925/**
926 * drm_fb_helper_cfb_copyarea - wrapper around cfb_copyarea
927 * @info: fbdev registered by the helper
928 * @area: info about area to copy
929 *
930 * A wrapper around cfb_copyarea implemented by fbdev core
931 */
932void drm_fb_helper_cfb_copyarea(struct fb_info *info,
933 const struct fb_copyarea *area)
934{
935 cfb_copyarea(info, area);
936}
937EXPORT_SYMBOL(drm_fb_helper_cfb_copyarea);
938
939/**
940 * drm_fb_helper_cfb_imageblit - wrapper around cfb_imageblit
941 * @info: fbdev registered by the helper
942 * @image: info about image to blit
943 *
944 * A wrapper around cfb_imageblit implemented by fbdev core
945 */
946void drm_fb_helper_cfb_imageblit(struct fb_info *info,
947 const struct fb_image *image)
948{
949 cfb_imageblit(info, image);
950}
951EXPORT_SYMBOL(drm_fb_helper_cfb_imageblit);
952
953/**
954 * drm_fb_helper_set_suspend - wrapper around fb_set_suspend
955 * @fb_helper: driver-allocated fbdev helper
956 * @state: desired state, zero to resume, non-zero to suspend
957 *
958 * A wrapper around fb_set_suspend implemented by fbdev core
959 */
960void drm_fb_helper_set_suspend(struct drm_fb_helper *fb_helper, int state)
961{
962 if (fb_helper && fb_helper->fbdev)
963 fb_set_suspend(fb_helper->fbdev, state);
964}
965EXPORT_SYMBOL(drm_fb_helper_set_suspend);
966
967static int setcolreg(struct drm_crtc *crtc, u16 red, u16 green,
968 u16 blue, u16 regno, struct fb_info *info)
969{
970 struct drm_fb_helper *fb_helper = info->par;
971 struct drm_framebuffer *fb = fb_helper->fb;
972 int pindex;
973
974 if (info->fix.visual == FB_VISUAL_TRUECOLOR) {
975 u32 *palette;
976 u32 value;
977 /* place color in psuedopalette */
978 if (regno > 16)
979 return -EINVAL;
980 palette = (u32 *)info->pseudo_palette;
981 red >>= (16 - info->var.red.length);
982 green >>= (16 - info->var.green.length);
983 blue >>= (16 - info->var.blue.length);
984 value = (red << info->var.red.offset) |
985 (green << info->var.green.offset) |
986 (blue << info->var.blue.offset);
987 if (info->var.transp.length > 0) {
988 u32 mask = (1 << info->var.transp.length) - 1;
989 mask <<= info->var.transp.offset;
990 value |= mask;
991 }
992 palette[regno] = value;
993 return 0;
994 }
995
996 /*
997 * The driver really shouldn't advertise pseudo/directcolor
998 * visuals if it can't deal with the palette.
999 */
1000 if (WARN_ON(!fb_helper->funcs->gamma_set ||
1001 !fb_helper->funcs->gamma_get))
1002 return -EINVAL;
1003
1004 pindex = regno;
1005
1006 if (fb->bits_per_pixel == 16) {
1007 pindex = regno << 3;
1008
1009 if (fb->depth == 16 && regno > 63)
1010 return -EINVAL;
1011 if (fb->depth == 15 && regno > 31)
1012 return -EINVAL;
1013
1014 if (fb->depth == 16) {
1015 u16 r, g, b;
1016 int i;
1017 if (regno < 32) {
1018 for (i = 0; i < 8; i++)
1019 fb_helper->funcs->gamma_set(crtc, red,
1020 green, blue, pindex + i);
1021 }
1022
1023 fb_helper->funcs->gamma_get(crtc, &r,
1024 &g, &b,
1025 pindex >> 1);
1026
1027 for (i = 0; i < 4; i++)
1028 fb_helper->funcs->gamma_set(crtc, r,
1029 green, b,
1030 (pindex >> 1) + i);
1031 }
1032 }
1033
1034 if (fb->depth != 16)
1035 fb_helper->funcs->gamma_set(crtc, red, green, blue, pindex);
1036 return 0;
1037}
1038
1039/**
1040 * drm_fb_helper_setcmap - implementation for ->fb_setcmap
1041 * @cmap: cmap to set
1042 * @info: fbdev registered by the helper
1043 */
1044int drm_fb_helper_setcmap(struct fb_cmap *cmap, struct fb_info *info)
1045{
1046 struct drm_fb_helper *fb_helper = info->par;
1047 struct drm_device *dev = fb_helper->dev;
1048 const struct drm_crtc_helper_funcs *crtc_funcs;
1049 u16 *red, *green, *blue, *transp;
1050 struct drm_crtc *crtc;
1051 int i, j, rc = 0;
1052 int start;
1053
1054 if (oops_in_progress)
1055 return -EBUSY;
1056
1057 drm_modeset_lock_all(dev);
1058 if (!drm_fb_helper_is_bound(fb_helper)) {
1059 drm_modeset_unlock_all(dev);
1060 return -EBUSY;
1061 }
1062
1063 for (i = 0; i < fb_helper->crtc_count; i++) {
1064 crtc = fb_helper->crtc_info[i].mode_set.crtc;
1065 crtc_funcs = crtc->helper_private;
1066
1067 red = cmap->red;
1068 green = cmap->green;
1069 blue = cmap->blue;
1070 transp = cmap->transp;
1071 start = cmap->start;
1072
1073 for (j = 0; j < cmap->len; j++) {
1074 u16 hred, hgreen, hblue, htransp = 0xffff;
1075
1076 hred = *red++;
1077 hgreen = *green++;
1078 hblue = *blue++;
1079
1080 if (transp)
1081 htransp = *transp++;
1082
1083 rc = setcolreg(crtc, hred, hgreen, hblue, start++, info);
1084 if (rc)
1085 goto out;
1086 }
1087 if (crtc_funcs->load_lut)
1088 crtc_funcs->load_lut(crtc);
1089 }
1090 out:
1091 drm_modeset_unlock_all(dev);
1092 return rc;
1093}
1094EXPORT_SYMBOL(drm_fb_helper_setcmap);
1095
1096/**
1097 * drm_fb_helper_check_var - implementation for ->fb_check_var
1098 * @var: screeninfo to check
1099 * @info: fbdev registered by the helper
1100 */
1101int drm_fb_helper_check_var(struct fb_var_screeninfo *var,
1102 struct fb_info *info)
1103{
1104 struct drm_fb_helper *fb_helper = info->par;
1105 struct drm_framebuffer *fb = fb_helper->fb;
1106 int depth;
1107
1108 if (var->pixclock != 0 || in_dbg_master())
1109 return -EINVAL;
1110
1111 /* Need to resize the fb object !!! */
1112 if (var->bits_per_pixel > fb->bits_per_pixel ||
1113 var->xres > fb->width || var->yres > fb->height ||
1114 var->xres_virtual > fb->width || var->yres_virtual > fb->height) {
1115 DRM_DEBUG("fb userspace requested width/height/bpp is greater than current fb "
1116 "request %dx%d-%d (virtual %dx%d) > %dx%d-%d\n",
1117 var->xres, var->yres, var->bits_per_pixel,
1118 var->xres_virtual, var->yres_virtual,
1119 fb->width, fb->height, fb->bits_per_pixel);
1120 return -EINVAL;
1121 }
1122
1123 switch (var->bits_per_pixel) {
1124 case 16:
1125 depth = (var->green.length == 6) ? 16 : 15;
1126 break;
1127 case 32:
1128 depth = (var->transp.length > 0) ? 32 : 24;
1129 break;
1130 default:
1131 depth = var->bits_per_pixel;
1132 break;
1133 }
1134
1135 switch (depth) {
1136 case 8:
1137 var->red.offset = 0;
1138 var->green.offset = 0;
1139 var->blue.offset = 0;
1140 var->red.length = 8;
1141 var->green.length = 8;
1142 var->blue.length = 8;
1143 var->transp.length = 0;
1144 var->transp.offset = 0;
1145 break;
1146 case 15:
1147 var->red.offset = 10;
1148 var->green.offset = 5;
1149 var->blue.offset = 0;
1150 var->red.length = 5;
1151 var->green.length = 5;
1152 var->blue.length = 5;
1153 var->transp.length = 1;
1154 var->transp.offset = 15;
1155 break;
1156 case 16:
1157 var->red.offset = 11;
1158 var->green.offset = 5;
1159 var->blue.offset = 0;
1160 var->red.length = 5;
1161 var->green.length = 6;
1162 var->blue.length = 5;
1163 var->transp.length = 0;
1164 var->transp.offset = 0;
1165 break;
1166 case 24:
1167 var->red.offset = 16;
1168 var->green.offset = 8;
1169 var->blue.offset = 0;
1170 var->red.length = 8;
1171 var->green.length = 8;
1172 var->blue.length = 8;
1173 var->transp.length = 0;
1174 var->transp.offset = 0;
1175 break;
1176 case 32:
1177 var->red.offset = 16;
1178 var->green.offset = 8;
1179 var->blue.offset = 0;
1180 var->red.length = 8;
1181 var->green.length = 8;
1182 var->blue.length = 8;
1183 var->transp.length = 8;
1184 var->transp.offset = 24;
1185 break;
1186 default:
1187 return -EINVAL;
1188 }
1189 return 0;
1190}
1191EXPORT_SYMBOL(drm_fb_helper_check_var);
1192
1193/**
1194 * drm_fb_helper_set_par - implementation for ->fb_set_par
1195 * @info: fbdev registered by the helper
1196 *
1197 * This will let fbcon do the mode init and is called at initialization time by
1198 * the fbdev core when registering the driver, and later on through the hotplug
1199 * callback.
1200 */
1201int drm_fb_helper_set_par(struct fb_info *info)
1202{
1203 struct drm_fb_helper *fb_helper = info->par;
1204 struct fb_var_screeninfo *var = &info->var;
1205
1206 if (oops_in_progress)
1207 return -EBUSY;
1208
1209 if (var->pixclock != 0) {
1210 DRM_ERROR("PIXEL CLOCK SET\n");
1211 return -EINVAL;
1212 }
1213
1214 drm_fb_helper_restore_fbdev_mode_unlocked(fb_helper);
1215
1216 return 0;
1217}
1218EXPORT_SYMBOL(drm_fb_helper_set_par);
1219
1220static int pan_display_atomic(struct fb_var_screeninfo *var,
1221 struct fb_info *info)
1222{
1223 struct drm_fb_helper *fb_helper = info->par;
1224 struct drm_device *dev = fb_helper->dev;
1225 struct drm_atomic_state *state;
1226 struct drm_plane *plane;
1227 int i, ret;
1228 unsigned plane_mask;
1229
1230 state = drm_atomic_state_alloc(dev);
1231 if (!state)
1232 return -ENOMEM;
1233
1234 state->acquire_ctx = dev->mode_config.acquire_ctx;
1235retry:
1236 plane_mask = 0;
1237 for(i = 0; i < fb_helper->crtc_count; i++) {
1238 struct drm_mode_set *mode_set;
1239
1240 mode_set = &fb_helper->crtc_info[i].mode_set;
1241
1242 mode_set->x = var->xoffset;
1243 mode_set->y = var->yoffset;
1244
1245 ret = __drm_atomic_helper_set_config(mode_set, state);
1246 if (ret != 0)
1247 goto fail;
1248
1249 plane = mode_set->crtc->primary;
1250 plane_mask |= (1 << drm_plane_index(plane));
1251 plane->old_fb = plane->fb;
1252 }
1253
1254 ret = drm_atomic_commit(state);
1255 if (ret != 0)
1256 goto fail;
1257
1258 info->var.xoffset = var->xoffset;
1259 info->var.yoffset = var->yoffset;
1260
1261
1262fail:
1263 drm_atomic_clean_old_fb(dev, plane_mask, ret);
1264
1265 if (ret == -EDEADLK)
1266 goto backoff;
1267
1268 if (ret != 0)
1269 drm_atomic_state_free(state);
1270
1271 return ret;
1272
1273backoff:
1274 drm_atomic_state_clear(state);
1275 drm_atomic_legacy_backoff(state);
1276
1277 goto retry;
1278}
1279
1280/**
1281 * drm_fb_helper_pan_display - implementation for ->fb_pan_display
1282 * @var: updated screen information
1283 * @info: fbdev registered by the helper
1284 */
1285int drm_fb_helper_pan_display(struct fb_var_screeninfo *var,
1286 struct fb_info *info)
1287{
1288 struct drm_fb_helper *fb_helper = info->par;
1289 struct drm_device *dev = fb_helper->dev;
1290 struct drm_mode_set *modeset;
1291 int ret = 0;
1292 int i;
1293
1294 if (oops_in_progress)
1295 return -EBUSY;
1296
1297 drm_modeset_lock_all(dev);
1298 if (!drm_fb_helper_is_bound(fb_helper)) {
1299 drm_modeset_unlock_all(dev);
1300 return -EBUSY;
1301 }
1302
1303 if (fb_helper->atomic) {
1304 ret = pan_display_atomic(var, info);
1305 goto unlock;
1306 }
1307
1308 for (i = 0; i < fb_helper->crtc_count; i++) {
1309 modeset = &fb_helper->crtc_info[i].mode_set;
1310
1311 modeset->x = var->xoffset;
1312 modeset->y = var->yoffset;
1313
1314 if (modeset->num_connectors) {
1315 ret = drm_mode_set_config_internal(modeset);
1316 if (!ret) {
1317 info->var.xoffset = var->xoffset;
1318 info->var.yoffset = var->yoffset;
1319 }
1320 }
1321 }
1322unlock:
1323 drm_modeset_unlock_all(dev);
1324 return ret;
1325}
1326EXPORT_SYMBOL(drm_fb_helper_pan_display);
1327
1328/*
1329 * Allocates the backing storage and sets up the fbdev info structure through
1330 * the ->fb_probe callback and then registers the fbdev and sets up the panic
1331 * notifier.
1332 */
1333static int drm_fb_helper_single_fb_probe(struct drm_fb_helper *fb_helper,
1334 int preferred_bpp)
1335{
1336 int ret = 0;
1337 int crtc_count = 0;
1338 int i;
1339 struct fb_info *info;
1340 struct drm_fb_helper_surface_size sizes;
1341 int gamma_size = 0;
1342
1343 memset(&sizes, 0, sizeof(struct drm_fb_helper_surface_size));
1344 sizes.surface_depth = 24;
1345 sizes.surface_bpp = 32;
1346 sizes.fb_width = (unsigned)-1;
1347 sizes.fb_height = (unsigned)-1;
1348
1349 /* if driver picks 8 or 16 by default use that
1350 for both depth/bpp */
1351 if (preferred_bpp != sizes.surface_bpp)
1352 sizes.surface_depth = sizes.surface_bpp = preferred_bpp;
1353
1354 /* first up get a count of crtcs now in use and new min/maxes width/heights */
1355 for (i = 0; i < fb_helper->connector_count; i++) {
1356 struct drm_fb_helper_connector *fb_helper_conn = fb_helper->connector_info[i];
1357 struct drm_cmdline_mode *cmdline_mode;
1358
1359 cmdline_mode = &fb_helper_conn->connector->cmdline_mode;
1360
1361 if (cmdline_mode->bpp_specified) {
1362 switch (cmdline_mode->bpp) {
1363 case 8:
1364 sizes.surface_depth = sizes.surface_bpp = 8;
1365 break;
1366 case 15:
1367 sizes.surface_depth = 15;
1368 sizes.surface_bpp = 16;
1369 break;
1370 case 16:
1371 sizes.surface_depth = sizes.surface_bpp = 16;
1372 break;
1373 case 24:
1374 sizes.surface_depth = sizes.surface_bpp = 24;
1375 break;
1376 case 32:
1377 sizes.surface_depth = 24;
1378 sizes.surface_bpp = 32;
1379 break;
1380 }
1381 break;
1382 }
1383 }
1384
1385 crtc_count = 0;
1386 for (i = 0; i < fb_helper->crtc_count; i++) {
1387 struct drm_display_mode *desired_mode;
1388 struct drm_mode_set *mode_set;
1389 int x, y, j;
1390 /* in case of tile group, are we the last tile vert or horiz?
1391 * If no tile group you are always the last one both vertically
1392 * and horizontally
1393 */
1394 bool lastv = true, lasth = true;
1395
1396 desired_mode = fb_helper->crtc_info[i].desired_mode;
1397 mode_set = &fb_helper->crtc_info[i].mode_set;
1398
1399 if (!desired_mode)
1400 continue;
1401
1402 crtc_count++;
1403
1404 x = fb_helper->crtc_info[i].x;
1405 y = fb_helper->crtc_info[i].y;
1406
1407 if (gamma_size == 0)
1408 gamma_size = fb_helper->crtc_info[i].mode_set.crtc->gamma_size;
1409
1410 sizes.surface_width = max_t(u32, desired_mode->hdisplay + x, sizes.surface_width);
1411 sizes.surface_height = max_t(u32, desired_mode->vdisplay + y, sizes.surface_height);
1412
1413 for (j = 0; j < mode_set->num_connectors; j++) {
1414 struct drm_connector *connector = mode_set->connectors[j];
1415 if (connector->has_tile) {
1416 lasth = (connector->tile_h_loc == (connector->num_h_tile - 1));
1417 lastv = (connector->tile_v_loc == (connector->num_v_tile - 1));
1418 /* cloning to multiple tiles is just crazy-talk, so: */
1419 break;
1420 }
1421 }
1422
1423 if (lasth)
1424 sizes.fb_width = min_t(u32, desired_mode->hdisplay + x, sizes.fb_width);
1425 if (lastv)
1426 sizes.fb_height = min_t(u32, desired_mode->vdisplay + y, sizes.fb_height);
1427 }
1428
1429 if (crtc_count == 0 || sizes.fb_width == -1 || sizes.fb_height == -1) {
1430 /* hmm everyone went away - assume VGA cable just fell out
1431 and will come back later. */
1432 DRM_INFO("Cannot find any crtc or sizes - going 1024x768\n");
1433 sizes.fb_width = sizes.surface_width = 1024;
1434 sizes.fb_height = sizes.surface_height = 768;
1435 }
1436
1437 /* push down into drivers */
1438 ret = (*fb_helper->funcs->fb_probe)(fb_helper, &sizes);
1439 if (ret < 0)
1440 return ret;
1441
1442 info = fb_helper->fbdev;
1443
1444 /*
1445 * Set the fb pointer - usually drm_setup_crtcs does this for hotplug
1446 * events, but at init time drm_setup_crtcs needs to be called before
1447 * the fb is allocated (since we need to figure out the desired size of
1448 * the fb before we can allocate it ...). Hence we need to fix things up
1449 * here again.
1450 */
1451 for (i = 0; i < fb_helper->crtc_count; i++)
1452 if (fb_helper->crtc_info[i].mode_set.num_connectors)
1453 fb_helper->crtc_info[i].mode_set.fb = fb_helper->fb;
1454
1455
1456 info->var.pixclock = 0;
1457 if (register_framebuffer(info) < 0)
1458 return -EINVAL;
1459
1460 dev_info(fb_helper->dev->dev, "fb%d: %s frame buffer device\n",
1461 info->node, info->fix.id);
1462
1463 if (list_empty(&kernel_fb_helper_list)) {
1464 register_sysrq_key('v', &sysrq_drm_fb_helper_restore_op);
1465 }
1466
1467 list_add(&fb_helper->kernel_fb_list, &kernel_fb_helper_list);
1468
1469 return 0;
1470}
1471
1472/**
1473 * drm_fb_helper_fill_fix - initializes fixed fbdev information
1474 * @info: fbdev registered by the helper
1475 * @pitch: desired pitch
1476 * @depth: desired depth
1477 *
1478 * Helper to fill in the fixed fbdev information useful for a non-accelerated
1479 * fbdev emulations. Drivers which support acceleration methods which impose
1480 * additional constraints need to set up their own limits.
1481 *
1482 * Drivers should call this (or their equivalent setup code) from their
1483 * ->fb_probe callback.
1484 */
1485void drm_fb_helper_fill_fix(struct fb_info *info, uint32_t pitch,
1486 uint32_t depth)
1487{
1488 info->fix.type = FB_TYPE_PACKED_PIXELS;
1489 info->fix.visual = depth == 8 ? FB_VISUAL_PSEUDOCOLOR :
1490 FB_VISUAL_TRUECOLOR;
1491 info->fix.mmio_start = 0;
1492 info->fix.mmio_len = 0;
1493 info->fix.type_aux = 0;
1494 info->fix.xpanstep = 1; /* doing it in hw */
1495 info->fix.ypanstep = 1; /* doing it in hw */
1496 info->fix.ywrapstep = 0;
1497 info->fix.accel = FB_ACCEL_NONE;
1498
1499 info->fix.line_length = pitch;
1500 return;
1501}
1502EXPORT_SYMBOL(drm_fb_helper_fill_fix);
1503
1504/**
1505 * drm_fb_helper_fill_var - initalizes variable fbdev information
1506 * @info: fbdev instance to set up
1507 * @fb_helper: fb helper instance to use as template
1508 * @fb_width: desired fb width
1509 * @fb_height: desired fb height
1510 *
1511 * Sets up the variable fbdev metainformation from the given fb helper instance
1512 * and the drm framebuffer allocated in fb_helper->fb.
1513 *
1514 * Drivers should call this (or their equivalent setup code) from their
1515 * ->fb_probe callback after having allocated the fbdev backing
1516 * storage framebuffer.
1517 */
1518void drm_fb_helper_fill_var(struct fb_info *info, struct drm_fb_helper *fb_helper,
1519 uint32_t fb_width, uint32_t fb_height)
1520{
1521 struct drm_framebuffer *fb = fb_helper->fb;
1522 info->pseudo_palette = fb_helper->pseudo_palette;
1523 info->var.xres_virtual = fb->width;
1524 info->var.yres_virtual = fb->height;
1525 info->var.bits_per_pixel = fb->bits_per_pixel;
1526 info->var.accel_flags = FB_ACCELF_TEXT;
1527 info->var.xoffset = 0;
1528 info->var.yoffset = 0;
1529 info->var.activate = FB_ACTIVATE_NOW;
1530 info->var.height = -1;
1531 info->var.width = -1;
1532
1533 switch (fb->depth) {
1534 case 8:
1535 info->var.red.offset = 0;
1536 info->var.green.offset = 0;
1537 info->var.blue.offset = 0;
1538 info->var.red.length = 8; /* 8bit DAC */
1539 info->var.green.length = 8;
1540 info->var.blue.length = 8;
1541 info->var.transp.offset = 0;
1542 info->var.transp.length = 0;
1543 break;
1544 case 15:
1545 info->var.red.offset = 10;
1546 info->var.green.offset = 5;
1547 info->var.blue.offset = 0;
1548 info->var.red.length = 5;
1549 info->var.green.length = 5;
1550 info->var.blue.length = 5;
1551 info->var.transp.offset = 15;
1552 info->var.transp.length = 1;
1553 break;
1554 case 16:
1555 info->var.red.offset = 11;
1556 info->var.green.offset = 5;
1557 info->var.blue.offset = 0;
1558 info->var.red.length = 5;
1559 info->var.green.length = 6;
1560 info->var.blue.length = 5;
1561 info->var.transp.offset = 0;
1562 break;
1563 case 24:
1564 info->var.red.offset = 16;
1565 info->var.green.offset = 8;
1566 info->var.blue.offset = 0;
1567 info->var.red.length = 8;
1568 info->var.green.length = 8;
1569 info->var.blue.length = 8;
1570 info->var.transp.offset = 0;
1571 info->var.transp.length = 0;
1572 break;
1573 case 32:
1574 info->var.red.offset = 16;
1575 info->var.green.offset = 8;
1576 info->var.blue.offset = 0;
1577 info->var.red.length = 8;
1578 info->var.green.length = 8;
1579 info->var.blue.length = 8;
1580 info->var.transp.offset = 24;
1581 info->var.transp.length = 8;
1582 break;
1583 default:
1584 break;
1585 }
1586
1587 info->var.xres = fb_width;
1588 info->var.yres = fb_height;
1589}
1590EXPORT_SYMBOL(drm_fb_helper_fill_var);
1591
1592static int drm_fb_helper_probe_connector_modes(struct drm_fb_helper *fb_helper,
1593 uint32_t maxX,
1594 uint32_t maxY)
1595{
1596 struct drm_connector *connector;
1597 int count = 0;
1598 int i;
1599
1600 for (i = 0; i < fb_helper->connector_count; i++) {
1601 connector = fb_helper->connector_info[i]->connector;
1602 count += connector->funcs->fill_modes(connector, maxX, maxY);
1603 }
1604
1605 return count;
1606}
1607
1608struct drm_display_mode *drm_has_preferred_mode(struct drm_fb_helper_connector *fb_connector, int width, int height)
1609{
1610 struct drm_display_mode *mode;
1611
1612 list_for_each_entry(mode, &fb_connector->connector->modes, head) {
1613 if (mode->hdisplay > width ||
1614 mode->vdisplay > height)
1615 continue;
1616 if (mode->type & DRM_MODE_TYPE_PREFERRED)
1617 return mode;
1618 }
1619 return NULL;
1620}
1621EXPORT_SYMBOL(drm_has_preferred_mode);
1622
1623static bool drm_has_cmdline_mode(struct drm_fb_helper_connector *fb_connector)
1624{
1625 return fb_connector->connector->cmdline_mode.specified;
1626}
1627
1628struct drm_display_mode *drm_pick_cmdline_mode(struct drm_fb_helper_connector *fb_helper_conn,
1629 int width, int height)
1630{
1631 struct drm_cmdline_mode *cmdline_mode;
1632 struct drm_display_mode *mode;
1633 bool prefer_non_interlace;
1634
1635 cmdline_mode = &fb_helper_conn->connector->cmdline_mode;
1636 if (cmdline_mode->specified == false)
1637 return NULL;
1638
1639 /* attempt to find a matching mode in the list of modes
1640 * we have gotten so far, if not add a CVT mode that conforms
1641 */
1642 if (cmdline_mode->rb || cmdline_mode->margins)
1643 goto create_mode;
1644
1645 prefer_non_interlace = !cmdline_mode->interlace;
1646again:
1647 list_for_each_entry(mode, &fb_helper_conn->connector->modes, head) {
1648 /* check width/height */
1649 if (mode->hdisplay != cmdline_mode->xres ||
1650 mode->vdisplay != cmdline_mode->yres)
1651 continue;
1652
1653 if (cmdline_mode->refresh_specified) {
1654 if (mode->vrefresh != cmdline_mode->refresh)
1655 continue;
1656 }
1657
1658 if (cmdline_mode->interlace) {
1659 if (!(mode->flags & DRM_MODE_FLAG_INTERLACE))
1660 continue;
1661 } else if (prefer_non_interlace) {
1662 if (mode->flags & DRM_MODE_FLAG_INTERLACE)
1663 continue;
1664 }
1665 return mode;
1666 }
1667
1668 if (prefer_non_interlace) {
1669 prefer_non_interlace = false;
1670 goto again;
1671 }
1672
1673create_mode:
1674 mode = drm_mode_create_from_cmdline_mode(fb_helper_conn->connector->dev,
1675 cmdline_mode);
1676 list_add(&mode->head, &fb_helper_conn->connector->modes);
1677 return mode;
1678}
1679EXPORT_SYMBOL(drm_pick_cmdline_mode);
1680
1681static bool drm_connector_enabled(struct drm_connector *connector, bool strict)
1682{
1683 bool enable;
1684
1685 if (strict)
1686 enable = connector->status == connector_status_connected;
1687 else
1688 enable = connector->status != connector_status_disconnected;
1689
1690 return enable;
1691}
1692
1693static void drm_enable_connectors(struct drm_fb_helper *fb_helper,
1694 bool *enabled)
1695{
1696 bool any_enabled = false;
1697 struct drm_connector *connector;
1698 int i = 0;
1699
1700 for (i = 0; i < fb_helper->connector_count; i++) {
1701 connector = fb_helper->connector_info[i]->connector;
1702 enabled[i] = drm_connector_enabled(connector, true);
1703 DRM_DEBUG_KMS("connector %d enabled? %s\n", connector->base.id,
1704 enabled[i] ? "yes" : "no");
1705 any_enabled |= enabled[i];
1706 }
1707
1708 if (any_enabled)
1709 return;
1710
1711 for (i = 0; i < fb_helper->connector_count; i++) {
1712 connector = fb_helper->connector_info[i]->connector;
1713 enabled[i] = drm_connector_enabled(connector, false);
1714 }
1715}
1716
1717static bool drm_target_cloned(struct drm_fb_helper *fb_helper,
1718 struct drm_display_mode **modes,
1719 struct drm_fb_offset *offsets,
1720 bool *enabled, int width, int height)
1721{
1722 int count, i, j;
1723 bool can_clone = false;
1724 struct drm_fb_helper_connector *fb_helper_conn;
1725 struct drm_display_mode *dmt_mode, *mode;
1726
1727 /* only contemplate cloning in the single crtc case */
1728 if (fb_helper->crtc_count > 1)
1729 return false;
1730
1731 count = 0;
1732 for (i = 0; i < fb_helper->connector_count; i++) {
1733 if (enabled[i])
1734 count++;
1735 }
1736
1737 /* only contemplate cloning if more than one connector is enabled */
1738 if (count <= 1)
1739 return false;
1740
1741 /* check the command line or if nothing common pick 1024x768 */
1742 can_clone = true;
1743 for (i = 0; i < fb_helper->connector_count; i++) {
1744 if (!enabled[i])
1745 continue;
1746 fb_helper_conn = fb_helper->connector_info[i];
1747 modes[i] = drm_pick_cmdline_mode(fb_helper_conn, width, height);
1748 if (!modes[i]) {
1749 can_clone = false;
1750 break;
1751 }
1752 for (j = 0; j < i; j++) {
1753 if (!enabled[j])
1754 continue;
1755 if (!drm_mode_equal(modes[j], modes[i]))
1756 can_clone = false;
1757 }
1758 }
1759
1760 if (can_clone) {
1761 DRM_DEBUG_KMS("can clone using command line\n");
1762 return true;
1763 }
1764
1765 /* try and find a 1024x768 mode on each connector */
1766 can_clone = true;
1767 dmt_mode = drm_mode_find_dmt(fb_helper->dev, 1024, 768, 60, false);
1768
1769 for (i = 0; i < fb_helper->connector_count; i++) {
1770
1771 if (!enabled[i])
1772 continue;
1773
1774 fb_helper_conn = fb_helper->connector_info[i];
1775 list_for_each_entry(mode, &fb_helper_conn->connector->modes, head) {
1776 if (drm_mode_equal(mode, dmt_mode))
1777 modes[i] = mode;
1778 }
1779 if (!modes[i])
1780 can_clone = false;
1781 }
1782
1783 if (can_clone) {
1784 DRM_DEBUG_KMS("can clone using 1024x768\n");
1785 return true;
1786 }
1787 DRM_INFO("kms: can't enable cloning when we probably wanted to.\n");
1788 return false;
1789}
1790
1791static int drm_get_tile_offsets(struct drm_fb_helper *fb_helper,
1792 struct drm_display_mode **modes,
1793 struct drm_fb_offset *offsets,
1794 int idx,
1795 int h_idx, int v_idx)
1796{
1797 struct drm_fb_helper_connector *fb_helper_conn;
1798 int i;
1799 int hoffset = 0, voffset = 0;
1800
1801 for (i = 0; i < fb_helper->connector_count; i++) {
1802 fb_helper_conn = fb_helper->connector_info[i];
1803 if (!fb_helper_conn->connector->has_tile)
1804 continue;
1805
1806 if (!modes[i] && (h_idx || v_idx)) {
1807 DRM_DEBUG_KMS("no modes for connector tiled %d %d\n", i,
1808 fb_helper_conn->connector->base.id);
1809 continue;
1810 }
1811 if (fb_helper_conn->connector->tile_h_loc < h_idx)
1812 hoffset += modes[i]->hdisplay;
1813
1814 if (fb_helper_conn->connector->tile_v_loc < v_idx)
1815 voffset += modes[i]->vdisplay;
1816 }
1817 offsets[idx].x = hoffset;
1818 offsets[idx].y = voffset;
1819 DRM_DEBUG_KMS("returned %d %d for %d %d\n", hoffset, voffset, h_idx, v_idx);
1820 return 0;
1821}
1822
1823static bool drm_target_preferred(struct drm_fb_helper *fb_helper,
1824 struct drm_display_mode **modes,
1825 struct drm_fb_offset *offsets,
1826 bool *enabled, int width, int height)
1827{
1828 struct drm_fb_helper_connector *fb_helper_conn;
1829 int i;
1830 uint64_t conn_configured = 0, mask;
1831 int tile_pass = 0;
1832 mask = (1 << fb_helper->connector_count) - 1;
1833retry:
1834 for (i = 0; i < fb_helper->connector_count; i++) {
1835 fb_helper_conn = fb_helper->connector_info[i];
1836
1837 if (conn_configured & (1 << i))
1838 continue;
1839
1840 if (enabled[i] == false) {
1841 conn_configured |= (1 << i);
1842 continue;
1843 }
1844
1845 /* first pass over all the untiled connectors */
1846 if (tile_pass == 0 && fb_helper_conn->connector->has_tile)
1847 continue;
1848
1849 if (tile_pass == 1) {
1850 if (fb_helper_conn->connector->tile_h_loc != 0 ||
1851 fb_helper_conn->connector->tile_v_loc != 0)
1852 continue;
1853
1854 } else {
1855 if (fb_helper_conn->connector->tile_h_loc != tile_pass -1 &&
1856 fb_helper_conn->connector->tile_v_loc != tile_pass - 1)
1857 /* if this tile_pass doesn't cover any of the tiles - keep going */
1858 continue;
1859
1860 /* find the tile offsets for this pass - need
1861 to find all tiles left and above */
1862 drm_get_tile_offsets(fb_helper, modes, offsets,
1863 i, fb_helper_conn->connector->tile_h_loc, fb_helper_conn->connector->tile_v_loc);
1864 }
1865 DRM_DEBUG_KMS("looking for cmdline mode on connector %d\n",
1866 fb_helper_conn->connector->base.id);
1867
1868 /* got for command line mode first */
1869 modes[i] = drm_pick_cmdline_mode(fb_helper_conn, width, height);
1870 if (!modes[i]) {
1871 DRM_DEBUG_KMS("looking for preferred mode on connector %d %d\n",
1872 fb_helper_conn->connector->base.id, fb_helper_conn->connector->tile_group ? fb_helper_conn->connector->tile_group->id : 0);
1873 modes[i] = drm_has_preferred_mode(fb_helper_conn, width, height);
1874 }
1875 /* No preferred modes, pick one off the list */
1876 if (!modes[i] && !list_empty(&fb_helper_conn->connector->modes)) {
1877 list_for_each_entry(modes[i], &fb_helper_conn->connector->modes, head)
1878 break;
1879 }
1880 DRM_DEBUG_KMS("found mode %s\n", modes[i] ? modes[i]->name :
1881 "none");
1882 conn_configured |= (1 << i);
1883 }
1884
1885 if ((conn_configured & mask) != mask) {
1886 tile_pass++;
1887 goto retry;
1888 }
1889 return true;
1890}
1891
1892static int drm_pick_crtcs(struct drm_fb_helper *fb_helper,
1893 struct drm_fb_helper_crtc **best_crtcs,
1894 struct drm_display_mode **modes,
1895 int n, int width, int height)
1896{
1897 int c, o;
1898 struct drm_device *dev = fb_helper->dev;
1899 struct drm_connector *connector;
1900 const struct drm_connector_helper_funcs *connector_funcs;
1901 struct drm_encoder *encoder;
1902 int my_score, best_score, score;
1903 struct drm_fb_helper_crtc **crtcs, *crtc;
1904 struct drm_fb_helper_connector *fb_helper_conn;
1905
1906 if (n == fb_helper->connector_count)
1907 return 0;
1908
1909 fb_helper_conn = fb_helper->connector_info[n];
1910 connector = fb_helper_conn->connector;
1911
1912 best_crtcs[n] = NULL;
1913 best_score = drm_pick_crtcs(fb_helper, best_crtcs, modes, n+1, width, height);
1914 if (modes[n] == NULL)
1915 return best_score;
1916
1917 crtcs = kzalloc(dev->mode_config.num_connector *
1918 sizeof(struct drm_fb_helper_crtc *), GFP_KERNEL);
1919 if (!crtcs)
1920 return best_score;
1921
1922 my_score = 1;
1923 if (connector->status == connector_status_connected)
1924 my_score++;
1925 if (drm_has_cmdline_mode(fb_helper_conn))
1926 my_score++;
1927 if (drm_has_preferred_mode(fb_helper_conn, width, height))
1928 my_score++;
1929
1930 connector_funcs = connector->helper_private;
1931 encoder = connector_funcs->best_encoder(connector);
1932 if (!encoder)
1933 goto out;
1934
1935 /* select a crtc for this connector and then attempt to configure
1936 remaining connectors */
1937 for (c = 0; c < fb_helper->crtc_count; c++) {
1938 crtc = &fb_helper->crtc_info[c];
1939
1940 if ((encoder->possible_crtcs & (1 << c)) == 0)
1941 continue;
1942
1943 for (o = 0; o < n; o++)
1944 if (best_crtcs[o] == crtc)
1945 break;
1946
1947 if (o < n) {
1948 /* ignore cloning unless only a single crtc */
1949 if (fb_helper->crtc_count > 1)
1950 continue;
1951
1952 if (!drm_mode_equal(modes[o], modes[n]))
1953 continue;
1954 }
1955
1956 crtcs[n] = crtc;
1957 memcpy(crtcs, best_crtcs, n * sizeof(struct drm_fb_helper_crtc *));
1958 score = my_score + drm_pick_crtcs(fb_helper, crtcs, modes, n + 1,
1959 width, height);
1960 if (score > best_score) {
1961 best_score = score;
1962 memcpy(best_crtcs, crtcs,
1963 dev->mode_config.num_connector *
1964 sizeof(struct drm_fb_helper_crtc *));
1965 }
1966 }
1967out:
1968 kfree(crtcs);
1969 return best_score;
1970}
1971
1972static void drm_setup_crtcs(struct drm_fb_helper *fb_helper)
1973{
1974 struct drm_device *dev = fb_helper->dev;
1975 struct drm_fb_helper_crtc **crtcs;
1976 struct drm_display_mode **modes;
1977 struct drm_fb_offset *offsets;
1978 struct drm_mode_set *modeset;
1979 bool *enabled;
1980 int width, height;
1981 int i;
1982
1983 DRM_DEBUG_KMS("\n");
1984
1985 width = dev->mode_config.max_width;
1986 height = dev->mode_config.max_height;
1987
1988 crtcs = kcalloc(fb_helper->connector_count,
1989 sizeof(struct drm_fb_helper_crtc *), GFP_KERNEL);
1990 modes = kcalloc(fb_helper->connector_count,
1991 sizeof(struct drm_display_mode *), GFP_KERNEL);
1992 offsets = kcalloc(fb_helper->connector_count,
1993 sizeof(struct drm_fb_offset), GFP_KERNEL);
1994 enabled = kcalloc(fb_helper->connector_count,
1995 sizeof(bool), GFP_KERNEL);
1996 if (!crtcs || !modes || !enabled || !offsets) {
1997 DRM_ERROR("Memory allocation failed\n");
1998 goto out;
1999 }
2000
2001
2002 drm_enable_connectors(fb_helper, enabled);
2003
2004 if (!(fb_helper->funcs->initial_config &&
2005 fb_helper->funcs->initial_config(fb_helper, crtcs, modes,
2006 offsets,
2007 enabled, width, height))) {
2008 memset(modes, 0, fb_helper->connector_count*sizeof(modes[0]));
2009 memset(crtcs, 0, fb_helper->connector_count*sizeof(crtcs[0]));
2010 memset(offsets, 0, fb_helper->connector_count*sizeof(offsets[0]));
2011
2012 if (!drm_target_cloned(fb_helper, modes, offsets,
2013 enabled, width, height) &&
2014 !drm_target_preferred(fb_helper, modes, offsets,
2015 enabled, width, height))
2016 DRM_ERROR("Unable to find initial modes\n");
2017
2018 DRM_DEBUG_KMS("picking CRTCs for %dx%d config\n",
2019 width, height);
2020
2021 drm_pick_crtcs(fb_helper, crtcs, modes, 0, width, height);
2022 }
2023
2024 /* need to set the modesets up here for use later */
2025 /* fill out the connector<->crtc mappings into the modesets */
2026 for (i = 0; i < fb_helper->crtc_count; i++) {
2027 modeset = &fb_helper->crtc_info[i].mode_set;
2028 modeset->num_connectors = 0;
2029 modeset->fb = NULL;
2030 }
2031
2032 for (i = 0; i < fb_helper->connector_count; i++) {
2033 struct drm_display_mode *mode = modes[i];
2034 struct drm_fb_helper_crtc *fb_crtc = crtcs[i];
2035 struct drm_fb_offset *offset = &offsets[i];
2036 modeset = &fb_crtc->mode_set;
2037
2038 if (mode && fb_crtc) {
2039 DRM_DEBUG_KMS("desired mode %s set on crtc %d (%d,%d)\n",
2040 mode->name, fb_crtc->mode_set.crtc->base.id, offset->x, offset->y);
2041 fb_crtc->desired_mode = mode;
2042 fb_crtc->x = offset->x;
2043 fb_crtc->y = offset->y;
2044 if (modeset->mode)
2045 drm_mode_destroy(dev, modeset->mode);
2046 modeset->mode = drm_mode_duplicate(dev,
2047 fb_crtc->desired_mode);
2048 modeset->connectors[modeset->num_connectors++] = fb_helper->connector_info[i]->connector;
2049 modeset->fb = fb_helper->fb;
2050 modeset->x = offset->x;
2051 modeset->y = offset->y;
2052 }
2053 }
2054
2055 /* Clear out any old modes if there are no more connected outputs. */
2056 for (i = 0; i < fb_helper->crtc_count; i++) {
2057 modeset = &fb_helper->crtc_info[i].mode_set;
2058 if (modeset->num_connectors == 0) {
2059 BUG_ON(modeset->fb);
2060 if (modeset->mode)
2061 drm_mode_destroy(dev, modeset->mode);
2062 modeset->mode = NULL;
2063 }
2064 }
2065out:
2066 kfree(crtcs);
2067 kfree(modes);
2068 kfree(offsets);
2069 kfree(enabled);
2070}
2071
2072/**
2073 * drm_fb_helper_initial_config - setup a sane initial connector configuration
2074 * @fb_helper: fb_helper device struct
2075 * @bpp_sel: bpp value to use for the framebuffer configuration
2076 *
2077 * Scans the CRTCs and connectors and tries to put together an initial setup.
2078 * At the moment, this is a cloned configuration across all heads with
2079 * a new framebuffer object as the backing store.
2080 *
2081 * Note that this also registers the fbdev and so allows userspace to call into
2082 * the driver through the fbdev interfaces.
2083 *
2084 * This function will call down into the ->fb_probe callback to let
2085 * the driver allocate and initialize the fbdev info structure and the drm
2086 * framebuffer used to back the fbdev. drm_fb_helper_fill_var() and
2087 * drm_fb_helper_fill_fix() are provided as helpers to setup simple default
2088 * values for the fbdev info structure.
2089 *
2090 * HANG DEBUGGING:
2091 *
2092 * When you have fbcon support built-in or already loaded, this function will do
2093 * a full modeset to setup the fbdev console. Due to locking misdesign in the
2094 * VT/fbdev subsystem that entire modeset sequence has to be done while holding
2095 * console_lock. Until console_unlock is called no dmesg lines will be sent out
2096 * to consoles, not even serial console. This means when your driver crashes,
2097 * you will see absolutely nothing else but a system stuck in this function,
2098 * with no further output. Any kind of printk() you place within your own driver
2099 * or in the drm core modeset code will also never show up.
2100 *
2101 * Standard debug practice is to run the fbcon setup without taking the
2102 * console_lock as a hack, to be able to see backtraces and crashes on the
2103 * serial line. This can be done by setting the fb.lockless_register_fb=1 kernel
2104 * cmdline option.
2105 *
2106 * The other option is to just disable fbdev emulation since very likely the
2107 * first modest from userspace will crash in the same way, and is even easier to
2108 * debug. This can be done by setting the drm_kms_helper.fbdev_emulation=0
2109 * kernel cmdline option.
2110 *
2111 * RETURNS:
2112 * Zero if everything went ok, nonzero otherwise.
2113 */
2114int drm_fb_helper_initial_config(struct drm_fb_helper *fb_helper, int bpp_sel)
2115{
2116 struct drm_device *dev = fb_helper->dev;
2117 int count = 0;
2118
2119 if (!drm_fbdev_emulation)
2120 return 0;
2121
2122 mutex_lock(&dev->mode_config.mutex);
2123 count = drm_fb_helper_probe_connector_modes(fb_helper,
2124 dev->mode_config.max_width,
2125 dev->mode_config.max_height);
2126 mutex_unlock(&dev->mode_config.mutex);
2127 /*
2128 * we shouldn't end up with no modes here.
2129 */
2130 if (count == 0)
2131 dev_info(fb_helper->dev->dev, "No connectors reported connected with modes\n");
2132
2133 drm_setup_crtcs(fb_helper);
2134
2135 return drm_fb_helper_single_fb_probe(fb_helper, bpp_sel);
2136}
2137EXPORT_SYMBOL(drm_fb_helper_initial_config);
2138
2139/**
2140 * drm_fb_helper_hotplug_event - respond to a hotplug notification by
2141 * probing all the outputs attached to the fb
2142 * @fb_helper: the drm_fb_helper
2143 *
2144 * Scan the connectors attached to the fb_helper and try to put together a
2145 * setup after *notification of a change in output configuration.
2146 *
2147 * Called at runtime, takes the mode config locks to be able to check/change the
2148 * modeset configuration. Must be run from process context (which usually means
2149 * either the output polling work or a work item launched from the driver's
2150 * hotplug interrupt).
2151 *
2152 * Note that drivers may call this even before calling
2153 * drm_fb_helper_initial_config but only aftert drm_fb_helper_init. This allows
2154 * for a race-free fbcon setup and will make sure that the fbdev emulation will
2155 * not miss any hotplug events.
2156 *
2157 * RETURNS:
2158 * 0 on success and a non-zero error code otherwise.
2159 */
2160int drm_fb_helper_hotplug_event(struct drm_fb_helper *fb_helper)
2161{
2162 struct drm_device *dev = fb_helper->dev;
2163 u32 max_width, max_height;
2164
2165 if (!drm_fbdev_emulation)
2166 return 0;
2167
2168 mutex_lock(&fb_helper->dev->mode_config.mutex);
2169 if (!fb_helper->fb || !drm_fb_helper_is_bound(fb_helper)) {
2170 fb_helper->delayed_hotplug = true;
2171 mutex_unlock(&fb_helper->dev->mode_config.mutex);
2172 return 0;
2173 }
2174 DRM_DEBUG_KMS("\n");
2175
2176 max_width = fb_helper->fb->width;
2177 max_height = fb_helper->fb->height;
2178
2179 drm_fb_helper_probe_connector_modes(fb_helper, max_width, max_height);
2180 mutex_unlock(&fb_helper->dev->mode_config.mutex);
2181
2182 drm_modeset_lock_all(dev);
2183 drm_setup_crtcs(fb_helper);
2184 drm_modeset_unlock_all(dev);
2185 drm_fb_helper_set_par(fb_helper->fbdev);
2186
2187 return 0;
2188}
2189EXPORT_SYMBOL(drm_fb_helper_hotplug_event);
2190
2191/* The Kconfig DRM_KMS_HELPER selects FRAMEBUFFER_CONSOLE (if !EXPERT)
2192 * but the module doesn't depend on any fb console symbols. At least
2193 * attempt to load fbcon to avoid leaving the system without a usable console.
2194 */
2195int __init drm_fb_helper_modinit(void)
2196{
2197#if defined(CONFIG_FRAMEBUFFER_CONSOLE_MODULE) && !defined(CONFIG_EXPERT)
2198 const char *name = "fbcon";
2199 struct module *fbcon;
2200
2201 mutex_lock(&module_mutex);
2202 fbcon = find_module(name);
2203 mutex_unlock(&module_mutex);
2204
2205 if (!fbcon)
2206 request_module_nowait(name);
2207#endif
2208 return 0;
2209}
2210EXPORT_SYMBOL(drm_fb_helper_modinit);