]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blame - drivers/gpu/drm/drm_fb_helper.c
projects / mirror_ubuntu-bionic-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
drm/fb: add setcmap and fix 8-bit support.
[mirror_ubuntu-bionic-kernel.git] / drivers / gpu / drm / drm_fb_helper.c
CommitLineData
785b93ef
DA		 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/sysrq.h>
31#include <linux/fb.h>
32#include "drmP.h"
33#include "drm_crtc.h"
34#include "drm_fb_helper.h"
35#include "drm_crtc_helper.h"
36
6fcefd56
DA		 37MODULE_AUTHOR("David Airlie, Jesse Barnes");
38MODULE_DESCRIPTION("DRM KMS helper");
39MODULE_LICENSE("GPL and additional rights");
40
785b93ef
DA		 41static LIST_HEAD(kernel_fb_helper_list);
42
d50ba256
DA		 43int drm_fb_helper_add_connector(struct drm_connector *connector)
44{
45 connector->fb_helper_private = kzalloc(sizeof(struct drm_fb_helper_connector), GFP_KERNEL);
46 if (!connector->fb_helper_private)
47 return -ENOMEM;
48
49 return 0;
d50ba256
DA		 50}
51EXPORT_SYMBOL(drm_fb_helper_add_connector);
52
53static int my_atoi(const char *name)
54{
55 int val = 0;
56
57 for (;; name++) {
58 switch (*name) {
59 case '0' ... '9':
60 val = 10*val+(*name-'0');
61 break;
62 default:
63 return val;
64 }
65 }
66}
67
68/**
69 * drm_fb_helper_connector_parse_command_line - parse command line for connector
70 * @connector - connector to parse line for
71 * @mode_option - per connector mode option
72 *
73 * This parses the connector specific then generic command lines for
74 * modes and options to configure the connector.
75 *
76 * This uses the same parameters as the fb modedb.c, except for extra
77 * <xres>x<yres>[M][R][-<bpp>][@<refresh>][i][m][eDd]
78 *
79 * enable/enable Digital/disable bit at the end
80 */
81static bool drm_fb_helper_connector_parse_command_line(struct drm_connector *connector,
82 const char *mode_option)
83{
84 const char *name;
85 unsigned int namelen;
86 int res_specified = 0, bpp_specified = 0, refresh_specified = 0;
87 unsigned int xres = 0, yres = 0, bpp = 32, refresh = 0;
88 int yres_specified = 0, cvt = 0, rb = 0, interlace = 0, margins = 0;
89 int i;
90 enum drm_connector_force force = DRM_FORCE_UNSPECIFIED;
91 struct drm_fb_helper_connector *fb_help_conn = connector->fb_helper_private;
8ef8678c 92 struct drm_fb_helper_cmdline_mode *cmdline_mode;
d50ba256 93
8ef8678c
DA		 94 if (!fb_help_conn)
95 return false;
96
97 cmdline_mode = &fb_help_conn->cmdline_mode;
d50ba256
DA		 98 if (!mode_option)
99 mode_option = fb_mode_option;
100
101 if (!mode_option) {
102 cmdline_mode->specified = false;
103 return false;
104 }
105
106 name = mode_option;
107 namelen = strlen(name);
108 for (i = namelen-1; i >= 0; i--) {
109 switch (name[i]) {
110 case '@':
111 namelen = i;
112 if (!refresh_specified && !bpp_specified &&
113 !yres_specified) {
114 refresh = my_atoi(&name[i+1]);
115 refresh_specified = 1;
116 if (cvt || rb)
117 cvt = 0;
118 } else
119 goto done;
120 break;
121 case '-':
122 namelen = i;
123 if (!bpp_specified && !yres_specified) {
124 bpp = my_atoi(&name[i+1]);
125 bpp_specified = 1;
126 if (cvt || rb)
127 cvt = 0;
128 } else
129 goto done;
130 break;
131 case 'x':
132 if (!yres_specified) {
133 yres = my_atoi(&name[i+1]);
134 yres_specified = 1;
135 } else
136 goto done;
137 case '0' ... '9':
138 break;
139 case 'M':
140 if (!yres_specified)
141 cvt = 1;
142 break;
143 case 'R':
144 if (!cvt)
145 rb = 1;
146 break;
147 case 'm':
148 if (!cvt)
149 margins = 1;
150 break;
151 case 'i':
152 if (!cvt)
153 interlace = 1;
154 break;
155 case 'e':
156 force = DRM_FORCE_ON;
157 break;
158 case 'D':
159 if ((connector->connector_type != DRM_MODE_CONNECTOR_DVII) ||
160 (connector->connector_type != DRM_MODE_CONNECTOR_HDMIB))
161 force = DRM_FORCE_ON;
162 else
163 force = DRM_FORCE_ON_DIGITAL;
164 break;
165 case 'd':
166 force = DRM_FORCE_OFF;
167 break;
168 default:
169 goto done;
170 }
171 }
172 if (i < 0 && yres_specified) {
173 xres = my_atoi(name);
174 res_specified = 1;
175 }
176done:
177
178 DRM_DEBUG_KMS("cmdline mode for connector %s %dx%d@%dHz%s%s%s\n",
179 drm_get_connector_name(connector), xres, yres,
180 (refresh) ? refresh : 60, (rb) ? " reduced blanking" :
181 "", (margins) ? " with margins" : "", (interlace) ?
182 " interlaced" : "");
183
184 if (force) {
185 const char *s;
186 switch (force) {
187 case DRM_FORCE_OFF: s = "OFF"; break;
188 case DRM_FORCE_ON_DIGITAL: s = "ON - dig"; break;
189 default:
190 case DRM_FORCE_ON: s = "ON"; break;
191 }
192
193 DRM_INFO("forcing %s connector %s\n",
194 drm_get_connector_name(connector), s);
195 connector->force = force;
196 }
197
198 if (res_specified) {
199 cmdline_mode->specified = true;
200 cmdline_mode->xres = xres;
201 cmdline_mode->yres = yres;
202 }
203
204 if (refresh_specified) {
205 cmdline_mode->refresh_specified = true;
206 cmdline_mode->refresh = refresh;
207 }
208
209 if (bpp_specified) {
210 cmdline_mode->bpp_specified = true;
211 cmdline_mode->bpp = bpp;
212 }
213 cmdline_mode->rb = rb ? true : false;
214 cmdline_mode->cvt = cvt ? true : false;
215 cmdline_mode->interlace = interlace ? true : false;
216
217 return true;
218}
219
220int drm_fb_helper_parse_command_line(struct drm_device *dev)
221{
222 struct drm_connector *connector;
223
224 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
225 char *option = NULL;
226
227 /* do something on return - turn off connector maybe */
228 if (fb_get_options(drm_get_connector_name(connector), &option))
229 continue;
230
231 drm_fb_helper_connector_parse_command_line(connector, option);
232 }
233 return 0;
234}
235
785b93ef
DA		 236bool drm_fb_helper_force_kernel_mode(void)
237{
238 int i = 0;
239 bool ret, error = false;
240 struct drm_fb_helper *helper;
241
242 if (list_empty(&kernel_fb_helper_list))
243 return false;
244
245 list_for_each_entry(helper, &kernel_fb_helper_list, kernel_fb_list) {
246 for (i = 0; i < helper->crtc_count; i++) {
247 struct drm_mode_set *mode_set = &helper->crtc_info[i].mode_set;
248 ret = drm_crtc_helper_set_config(mode_set);
249 if (ret)
250 error = true;
251 }
252 }
253 return error;
254}
255
256int drm_fb_helper_panic(struct notifier_block *n, unsigned long ununsed,
257 void *panic_str)
258{
259 DRM_ERROR("panic occurred, switching back to text console\n");
260 return drm_fb_helper_force_kernel_mode();
261 return 0;
262}
263EXPORT_SYMBOL(drm_fb_helper_panic);
264
265static struct notifier_block paniced = {
266 .notifier_call = drm_fb_helper_panic,
267};
268
269/**
270 * drm_fb_helper_restore - restore the framebuffer console (kernel) config
271 *
272 * Restore's the kernel's fbcon mode, used for lastclose & panic paths.
273 */
274void drm_fb_helper_restore(void)
275{
276 bool ret;
277 ret = drm_fb_helper_force_kernel_mode();
278 if (ret == true)
279 DRM_ERROR("Failed to restore crtc configuration\n");
280}
281EXPORT_SYMBOL(drm_fb_helper_restore);
282
bea1d35b 283#ifdef CONFIG_MAGIC_SYSRQ
785b93ef
DA		 284static void drm_fb_helper_restore_work_fn(struct work_struct *ignored)
285{
286 drm_fb_helper_restore();
287}
288static DECLARE_WORK(drm_fb_helper_restore_work, drm_fb_helper_restore_work_fn);
289
290static void drm_fb_helper_sysrq(int dummy1, struct tty_struct *dummy3)
291{
292 schedule_work(&drm_fb_helper_restore_work);
293}
294
295static struct sysrq_key_op sysrq_drm_fb_helper_restore_op = {
296 .handler = drm_fb_helper_sysrq,
297 .help_msg = "force-fb(V)",
298 .action_msg = "Restore framebuffer console",
299};
bea1d35b 300#endif
785b93ef
DA		 301
302static void drm_fb_helper_on(struct fb_info *info)
303{
304 struct drm_fb_helper *fb_helper = info->par;
305 struct drm_device *dev = fb_helper->dev;
306 struct drm_crtc *crtc;
307 struct drm_encoder *encoder;
308 int i;
309
310 /*
311 * For each CRTC in this fb, turn the crtc on then,
312 * find all associated encoders and turn them on.
313 */
e87b2c42
JB		 314 for (i = 0; i < fb_helper->crtc_count; i++) {
315 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
316 struct drm_crtc_helper_funcs *crtc_funcs =
317 crtc->helper_private;
785b93ef 318
e87b2c42
JB		 319 /* Only mess with CRTCs in this fb */
320 if (crtc->base.id != fb_helper->crtc_info[i].crtc_id ||
321 !crtc->enabled)
322 continue;
785b93ef 323
e87b2c42
JB		 324 mutex_lock(&dev->mode_config.mutex);
325 crtc_funcs->dpms(crtc, DRM_MODE_DPMS_ON);
326 mutex_unlock(&dev->mode_config.mutex);
785b93ef 327
e87b2c42
JB		 328 /* Found a CRTC on this fb, now find encoders */
329 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
330 if (encoder->crtc == crtc) {
331 struct drm_encoder_helper_funcs *encoder_funcs;
785b93ef 332
e87b2c42
JB		 333 encoder_funcs = encoder->helper_private;
334 mutex_lock(&dev->mode_config.mutex);
335 encoder_funcs->dpms(encoder, DRM_MODE_DPMS_ON);
336 mutex_unlock(&dev->mode_config.mutex);
337 }
785b93ef
DA		 338 }
339 }
340 }
341}
342
343static void drm_fb_helper_off(struct fb_info *info, int dpms_mode)
344{
345 struct drm_fb_helper *fb_helper = info->par;
346 struct drm_device *dev = fb_helper->dev;
347 struct drm_crtc *crtc;
348 struct drm_encoder *encoder;
349 int i;
350
351 /*
352 * For each CRTC in this fb, find all associated encoders
353 * and turn them off, then turn off the CRTC.
354 */
e87b2c42
JB		 355 for (i = 0; i < fb_helper->crtc_count; i++) {
356 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
357 struct drm_crtc_helper_funcs *crtc_funcs =
358 crtc->helper_private;
359
360 /* Only mess with CRTCs in this fb */
361 if (crtc->base.id != fb_helper->crtc_info[i].crtc_id ||
362 !crtc->enabled)
363 continue;
364
365 /* Found a CRTC on this fb, now find encoders */
366 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
367 if (encoder->crtc == crtc) {
368 struct drm_encoder_helper_funcs *encoder_funcs;
369
370 encoder_funcs = encoder->helper_private;
371 mutex_lock(&dev->mode_config.mutex);
372 encoder_funcs->dpms(encoder, dpms_mode);
373 mutex_unlock(&dev->mode_config.mutex);
374 }
375 }
376 if (dpms_mode == DRM_MODE_DPMS_OFF) {
785b93ef 377 mutex_lock(&dev->mode_config.mutex);
e87b2c42 378 crtc_funcs->dpms(crtc, dpms_mode);
785b93ef
DA		 379 mutex_unlock(&dev->mode_config.mutex);
380 }
381 }
785b93ef
DA		 382 }
383}
384
385int drm_fb_helper_blank(int blank, struct fb_info *info)
386{
387 switch (blank) {
388 case FB_BLANK_UNBLANK:
389 drm_fb_helper_on(info);
390 break;
391 case FB_BLANK_NORMAL:
392 drm_fb_helper_off(info, DRM_MODE_DPMS_STANDBY);
393 break;
394 case FB_BLANK_HSYNC_SUSPEND:
395 drm_fb_helper_off(info, DRM_MODE_DPMS_STANDBY);
396 break;
397 case FB_BLANK_VSYNC_SUSPEND:
398 drm_fb_helper_off(info, DRM_MODE_DPMS_SUSPEND);
399 break;
400 case FB_BLANK_POWERDOWN:
401 drm_fb_helper_off(info, DRM_MODE_DPMS_OFF);
402 break;
403 }
404 return 0;
405}
406EXPORT_SYMBOL(drm_fb_helper_blank);
407
408static void drm_fb_helper_crtc_free(struct drm_fb_helper *helper)
409{
410 int i;
411
412 for (i = 0; i < helper->crtc_count; i++)
413 kfree(helper->crtc_info[i].mode_set.connectors);
414 kfree(helper->crtc_info);
415}
416
417int drm_fb_helper_init_crtc_count(struct drm_fb_helper *helper, int crtc_count, int max_conn_count)
418{
419 struct drm_device *dev = helper->dev;
420 struct drm_crtc *crtc;
421 int ret = 0;
422 int i;
423
424 helper->crtc_info = kcalloc(crtc_count, sizeof(struct drm_fb_helper_crtc), GFP_KERNEL);
425 if (!helper->crtc_info)
426 return -ENOMEM;
427
428 helper->crtc_count = crtc_count;
429
430 for (i = 0; i < crtc_count; i++) {
431 helper->crtc_info[i].mode_set.connectors =
432 kcalloc(max_conn_count,
433 sizeof(struct drm_connector *),
434 GFP_KERNEL);
435
436 if (!helper->crtc_info[i].mode_set.connectors) {
437 ret = -ENOMEM;
438 goto out_free;
439 }
440 helper->crtc_info[i].mode_set.num_connectors = 0;
441 }
442
443 i = 0;
444 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
445 helper->crtc_info[i].crtc_id = crtc->base.id;
446 helper->crtc_info[i].mode_set.crtc = crtc;
447 i++;
448 }
449 helper->conn_limit = max_conn_count;
450 return 0;
451out_free:
452 drm_fb_helper_crtc_free(helper);
453 return -ENOMEM;
454}
455EXPORT_SYMBOL(drm_fb_helper_init_crtc_count);
456
068143d3
DA		 457int drm_fb_helper_setcmap(struct fb_cmap *cmap, struct fb_info *info)
458{
459 struct drm_fb_helper *fb_helper = info->par;
460 struct drm_device *dev = fb_helper->dev;
461 u16 *red, *green, *blue, *transp;
462 struct drm_crtc *crtc;
463 int i, rc = 0;
464 int start;
465
466 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
467 struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
468 for (i = 0; i < fb_helper->crtc_count; i++) {
469 if (crtc->base.id == fb_helper->crtc_info[i].crtc_id)
470 break;
471 }
472 if (i == fb_helper->crtc_count)
473 continue;
474
475 red = cmap->red;
476 green = cmap->green;
477 blue = cmap->blue;
478 transp = cmap->transp;
479 start = cmap->start;
480
481 for (i = 0; i < cmap->len; i++) {
482 u16 hred, hgreen, hblue, htransp = 0xffff;
483
484 hred = *red++;
485 hgreen = *green++;
486 hblue = *blue++;
487
488 if (transp)
489 htransp = *transp++;
490
491 fb_helper->funcs->gamma_set(crtc, hred, hgreen, hblue, start++);
492 }
493 crtc_funcs->load_lut(crtc);
494 }
495 return rc;
496}
497EXPORT_SYMBOL(drm_fb_helper_setcmap);
498
785b93ef
DA		 499int drm_fb_helper_setcolreg(unsigned regno,
500 unsigned red,
501 unsigned green,
502 unsigned blue,
503 unsigned transp,
504 struct fb_info *info)
505{
506 struct drm_fb_helper *fb_helper = info->par;
507 struct drm_device *dev = fb_helper->dev;
508 struct drm_crtc *crtc;
509 int i;
510
511 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
512 struct drm_framebuffer *fb = fb_helper->fb;
513
514 for (i = 0; i < fb_helper->crtc_count; i++) {
515 if (crtc->base.id == fb_helper->crtc_info[i].crtc_id)
516 break;
517 }
518 if (i == fb_helper->crtc_count)
519 continue;
520
521 if (regno > 255)
522 return 1;
523
524 if (fb->depth == 8) {
525 fb_helper->funcs->gamma_set(crtc, red, green, blue, regno);
526 return 0;
527 }
528
529 if (regno < 16) {
068143d3 530 u32 *pal = fb->pseudo_palette;
785b93ef
DA		 531 switch (fb->depth) {
532 case 15:
068143d3 533 pal[regno] = ((red & 0xf800) >> 1) |
785b93ef
DA		 534 ((green & 0xf800) >> 6) |
535 ((blue & 0xf800) >> 11);
536 break;
537 case 16:
068143d3 538 pal[regno] = (red & 0xf800) |
785b93ef
DA		 539 ((green & 0xfc00) >> 5) |
540 ((blue & 0xf800) >> 11);
541 break;
542 case 24:
543 case 32:
068143d3 544 pal[regno] =
785b93ef
DA		 545 (((red >> 8) & 0xff) << info->var.red.offset) |
546 (((green >> 8) & 0xff) << info->var.green.offset) |
547 (((blue >> 8) & 0xff) << info->var.blue.offset);
548 break;
549 }
550 }
551 }
552 return 0;
553}
554EXPORT_SYMBOL(drm_fb_helper_setcolreg);
555
556int drm_fb_helper_check_var(struct fb_var_screeninfo *var,
557 struct fb_info *info)
558{
559 struct drm_fb_helper *fb_helper = info->par;
560 struct drm_framebuffer *fb = fb_helper->fb;
561 int depth;
562
563 if (var->pixclock == -1 || !var->pixclock)
564 return -EINVAL;
565
566 /* Need to resize the fb object !!! */
567 if (var->xres > fb->width || var->yres > fb->height) {
568 DRM_ERROR("Requested width/height is greater than current fb "
569 "object %dx%d > %dx%d\n", var->xres, var->yres,
570 fb->width, fb->height);
571 DRM_ERROR("Need resizing code.\n");
572 return -EINVAL;
573 }
574
575 switch (var->bits_per_pixel) {
576 case 16:
577 depth = (var->green.length == 6) ? 16 : 15;
578 break;
579 case 32:
580 depth = (var->transp.length > 0) ? 32 : 24;
581 break;
582 default:
583 depth = var->bits_per_pixel;
584 break;
585 }
586
587 switch (depth) {
588 case 8:
589 var->red.offset = 0;
590 var->green.offset = 0;
591 var->blue.offset = 0;
592 var->red.length = 8;
593 var->green.length = 8;
594 var->blue.length = 8;
595 var->transp.length = 0;
596 var->transp.offset = 0;
597 break;
598 case 15:
599 var->red.offset = 10;
600 var->green.offset = 5;
601 var->blue.offset = 0;
602 var->red.length = 5;
603 var->green.length = 5;
604 var->blue.length = 5;
605 var->transp.length = 1;
606 var->transp.offset = 15;
607 break;
608 case 16:
609 var->red.offset = 11;
610 var->green.offset = 5;
611 var->blue.offset = 0;
612 var->red.length = 5;
613 var->green.length = 6;
614 var->blue.length = 5;
615 var->transp.length = 0;
616 var->transp.offset = 0;
617 break;
618 case 24:
619 var->red.offset = 16;
620 var->green.offset = 8;
621 var->blue.offset = 0;
622 var->red.length = 8;
623 var->green.length = 8;
624 var->blue.length = 8;
625 var->transp.length = 0;
626 var->transp.offset = 0;
627 break;
628 case 32:
629 var->red.offset = 16;
630 var->green.offset = 8;
631 var->blue.offset = 0;
632 var->red.length = 8;
633 var->green.length = 8;
634 var->blue.length = 8;
635 var->transp.length = 8;
636 var->transp.offset = 24;
637 break;
638 default:
639 return -EINVAL;
640 }
641 return 0;
642}
643EXPORT_SYMBOL(drm_fb_helper_check_var);
644
645/* this will let fbcon do the mode init */
646int drm_fb_helper_set_par(struct fb_info *info)
647{
648 struct drm_fb_helper *fb_helper = info->par;
649 struct drm_device *dev = fb_helper->dev;
650 struct fb_var_screeninfo *var = &info->var;
651 struct drm_crtc *crtc;
652 int ret;
653 int i;
654
655 if (var->pixclock != -1) {
656 DRM_ERROR("PIXEL CLCOK SET\n");
657 return -EINVAL;
658 }
659
660 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
661
662 for (i = 0; i < fb_helper->crtc_count; i++) {
663 if (crtc->base.id == fb_helper->crtc_info[i].crtc_id)
664 break;
665 }
666 if (i == fb_helper->crtc_count)
667 continue;
668
669 if (crtc->fb == fb_helper->crtc_info[i].mode_set.fb) {
670 mutex_lock(&dev->mode_config.mutex);
671 ret = crtc->funcs->set_config(&fb_helper->crtc_info->mode_set);
672 mutex_unlock(&dev->mode_config.mutex);
673 if (ret)
674 return ret;
675 }
676 }
677 return 0;
678}
679EXPORT_SYMBOL(drm_fb_helper_set_par);
680
681int drm_fb_helper_pan_display(struct fb_var_screeninfo *var,
682 struct fb_info *info)
683{
684 struct drm_fb_helper *fb_helper = info->par;
685 struct drm_device *dev = fb_helper->dev;
686 struct drm_mode_set *modeset;
687 struct drm_crtc *crtc;
688 int ret = 0;
689 int i;
690
691 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
692 for (i = 0; i < fb_helper->crtc_count; i++) {
693 if (crtc->base.id == fb_helper->crtc_info[i].crtc_id)
694 break;
695 }
696
697 if (i == fb_helper->crtc_count)
698 continue;
699
700 modeset = &fb_helper->crtc_info[i].mode_set;
701
702 modeset->x = var->xoffset;
703 modeset->y = var->yoffset;
704
705 if (modeset->num_connectors) {
706 mutex_lock(&dev->mode_config.mutex);
707 ret = crtc->funcs->set_config(modeset);
708 mutex_unlock(&dev->mode_config.mutex);
709 if (!ret) {
710 info->var.xoffset = var->xoffset;
711 info->var.yoffset = var->yoffset;
712 }
713 }
714 }
715 return ret;
716}
717EXPORT_SYMBOL(drm_fb_helper_pan_display);
718
719int drm_fb_helper_single_fb_probe(struct drm_device *dev,
720 int (*fb_create)(struct drm_device *dev,
721 uint32_t fb_width,
722 uint32_t fb_height,
723 uint32_t surface_width,
724 uint32_t surface_height,
d50ba256
DA		 725 uint32_t surface_depth,
726 uint32_t surface_bpp,
785b93ef
DA		 727 struct drm_framebuffer **fb_ptr))
728{
729 struct drm_crtc *crtc;
730 struct drm_connector *connector;
731 unsigned int fb_width = (unsigned)-1, fb_height = (unsigned)-1;
732 unsigned int surface_width = 0, surface_height = 0;
733 int new_fb = 0;
734 int crtc_count = 0;
735 int ret, i, conn_count = 0;
736 struct fb_info *info;
737 struct drm_framebuffer *fb;
738 struct drm_mode_set *modeset = NULL;
739 struct drm_fb_helper *fb_helper;
d50ba256 740 uint32_t surface_depth = 24, surface_bpp = 32;
785b93ef
DA		 741
742 /* first up get a count of crtcs now in use and new min/maxes width/heights */
d50ba256
DA		 743 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
744 struct drm_fb_helper_connector *fb_help_conn = connector->fb_helper_private;
8ef8678c
DA		 745
746 struct drm_fb_helper_cmdline_mode *cmdline_mode;
747
748 if (!fb_help_conn)
749 continue;
750
751 cmdline_mode = &fb_help_conn->cmdline_mode;
d50ba256
DA		 752
753 if (cmdline_mode->bpp_specified) {
754 switch (cmdline_mode->bpp) {
755 case 8:
756 surface_depth = surface_bpp = 8;
757 break;
758 case 15:
759 surface_depth = 15;
760 surface_bpp = 16;
761 break;
762 case 16:
763 surface_depth = surface_bpp = 16;
764 break;
765 case 24:
766 surface_depth = surface_bpp = 24;
767 break;
768 case 32:
769 surface_depth = 24;
770 surface_bpp = 32;
771 break;
772 }
773 break;
774 }
775 }
776
785b93ef
DA		 777 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
778 if (drm_helper_crtc_in_use(crtc)) {
779 if (crtc->desired_mode) {
780 if (crtc->desired_mode->hdisplay < fb_width)
781 fb_width = crtc->desired_mode->hdisplay;
782
783 if (crtc->desired_mode->vdisplay < fb_height)
784 fb_height = crtc->desired_mode->vdisplay;
785
786 if (crtc->desired_mode->hdisplay > surface_width)
787 surface_width = crtc->desired_mode->hdisplay;
788
789 if (crtc->desired_mode->vdisplay > surface_height)
790 surface_height = crtc->desired_mode->vdisplay;
791 }
792 crtc_count++;
793 }
794 }
795
796 if (crtc_count == 0 || fb_width == -1 || fb_height == -1) {
797 /* hmm everyone went away - assume VGA cable just fell out
798 and will come back later. */
799 return 0;
800 }
801
802 /* do we have an fb already? */
803 if (list_empty(&dev->mode_config.fb_kernel_list)) {
804 ret = (*fb_create)(dev, fb_width, fb_height, surface_width,
d50ba256
DA		 805 surface_height, surface_depth, surface_bpp,
806 &fb);
785b93ef
DA		 807 if (ret)
808 return -EINVAL;
809 new_fb = 1;
810 } else {
811 fb = list_first_entry(&dev->mode_config.fb_kernel_list,
812 struct drm_framebuffer, filp_head);
813
814 /* if someone hotplugs something bigger than we have already allocated, we are pwned.
815 As really we can't resize an fbdev that is in the wild currently due to fbdev
816 not really being designed for the lower layers moving stuff around under it.
817 - so in the grand style of things - punt. */
818 if ((fb->width < surface_width) ||
819 (fb->height < surface_height)) {
820 DRM_ERROR("Framebuffer not large enough to scale console onto.\n");
821 return -EINVAL;
822 }
823 }
824
825 info = fb->fbdev;
826 fb_helper = info->par;
827
828 crtc_count = 0;
829 /* okay we need to setup new connector sets in the crtcs */
830 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
831 modeset = &fb_helper->crtc_info[crtc_count].mode_set;
832 modeset->fb = fb;
833 conn_count = 0;
834 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
835 if (connector->encoder)
836 if (connector->encoder->crtc == modeset->crtc) {
837 modeset->connectors[conn_count] = connector;
838 conn_count++;
839 if (conn_count > fb_helper->conn_limit)
840 BUG();
841 }
842 }
843
844 for (i = conn_count; i < fb_helper->conn_limit; i++)
845 modeset->connectors[i] = NULL;
846
847 modeset->crtc = crtc;
848 crtc_count++;
849
850 modeset->num_connectors = conn_count;
851 if (modeset->crtc->desired_mode) {
852 if (modeset->mode)
853 drm_mode_destroy(dev, modeset->mode);
854 modeset->mode = drm_mode_duplicate(dev,
855 modeset->crtc->desired_mode);
856 }
857 }
858 fb_helper->crtc_count = crtc_count;
859 fb_helper->fb = fb;
860
861 if (new_fb) {
862 info->var.pixclock = -1;
863 if (register_framebuffer(info) < 0)
864 return -EINVAL;
865 } else {
866 drm_fb_helper_set_par(info);
867 }
868 printk(KERN_INFO "fb%d: %s frame buffer device\n", info->node,
869 info->fix.id);
870
871 /* Switch back to kernel console on panic */
872 /* multi card linked list maybe */
873 if (list_empty(&kernel_fb_helper_list)) {
874 printk(KERN_INFO "registered panic notifier\n");
875 atomic_notifier_chain_register(&panic_notifier_list,
876 &paniced);
877 register_sysrq_key('v', &sysrq_drm_fb_helper_restore_op);
878 }
879 list_add(&fb_helper->kernel_fb_list, &kernel_fb_helper_list);
880 return 0;
881}
882EXPORT_SYMBOL(drm_fb_helper_single_fb_probe);
883
884void drm_fb_helper_free(struct drm_fb_helper *helper)
885{
886 list_del(&helper->kernel_fb_list);
887 if (list_empty(&kernel_fb_helper_list)) {
888 printk(KERN_INFO "unregistered panic notifier\n");
889 atomic_notifier_chain_unregister(&panic_notifier_list,
890 &paniced);
891 unregister_sysrq_key('v', &sysrq_drm_fb_helper_restore_op);
892 }
893 drm_fb_helper_crtc_free(helper);
894}
895EXPORT_SYMBOL(drm_fb_helper_free);
896
068143d3
DA		 897void drm_fb_helper_fill_fix(struct fb_info *info, uint32_t pitch,
898 uint32_t depth)
785b93ef
DA		 899{
900 info->fix.type = FB_TYPE_PACKED_PIXELS;
068143d3
DA		 901 info->fix.visual = depth == 8 ? FB_VISUAL_PSEUDOCOLOR :
902 FB_VISUAL_TRUECOLOR;
785b93ef
DA		 903 info->fix.type_aux = 0;
904 info->fix.xpanstep = 1; /* doing it in hw */
905 info->fix.ypanstep = 1; /* doing it in hw */
906 info->fix.ywrapstep = 0;
3420e742 907 info->fix.accel = FB_ACCEL_NONE;
785b93ef
DA		 908 info->fix.type_aux = 0;
909
910 info->fix.line_length = pitch;
911 return;
912}
913EXPORT_SYMBOL(drm_fb_helper_fill_fix);
914
915void drm_fb_helper_fill_var(struct fb_info *info, struct drm_framebuffer *fb,
916 uint32_t fb_width, uint32_t fb_height)
917{
918 info->pseudo_palette = fb->pseudo_palette;
919 info->var.xres_virtual = fb->width;
920 info->var.yres_virtual = fb->height;
921 info->var.bits_per_pixel = fb->bits_per_pixel;
922 info->var.xoffset = 0;
923 info->var.yoffset = 0;
924 info->var.activate = FB_ACTIVATE_NOW;
925 info->var.height = -1;
926 info->var.width = -1;
927
928 switch (fb->depth) {
929 case 8:
930 info->var.red.offset = 0;
931 info->var.green.offset = 0;
932 info->var.blue.offset = 0;
933 info->var.red.length = 8; /* 8bit DAC */
934 info->var.green.length = 8;
935 info->var.blue.length = 8;
936 info->var.transp.offset = 0;
937 info->var.transp.length = 0;
938 break;
939 case 15:
940 info->var.red.offset = 10;
941 info->var.green.offset = 5;
942 info->var.blue.offset = 0;
943 info->var.red.length = 5;
944 info->var.green.length = 5;
945 info->var.blue.length = 5;
946 info->var.transp.offset = 15;
947 info->var.transp.length = 1;
948 break;
949 case 16:
950 info->var.red.offset = 11;
951 info->var.green.offset = 5;
952 info->var.blue.offset = 0;
953 info->var.red.length = 5;
954 info->var.green.length = 6;
955 info->var.blue.length = 5;
956 info->var.transp.offset = 0;
957 break;
958 case 24:
959 info->var.red.offset = 16;
960 info->var.green.offset = 8;
961 info->var.blue.offset = 0;
962 info->var.red.length = 8;
963 info->var.green.length = 8;
964 info->var.blue.length = 8;
965 info->var.transp.offset = 0;
966 info->var.transp.length = 0;
967 break;
968 case 32:
969 info->var.red.offset = 16;
970 info->var.green.offset = 8;
971 info->var.blue.offset = 0;
972 info->var.red.length = 8;
973 info->var.green.length = 8;
974 info->var.blue.length = 8;
975 info->var.transp.offset = 24;
976 info->var.transp.length = 8;
977 break;
978 default:
979 break;
980 }
981
982 info->var.xres = fb_width;
983 info->var.yres = fb_height;
984}
985EXPORT_SYMBOL(drm_fb_helper_fill_var);
ubuntu-bionic-kernel mirror