?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 2.6.33-rc6
[cris-mirror.git] / drivers / gpu / drm / drm_fb_helper.c
blob0f9e90552dc44098589e8bf20a1154266c25db67
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
37 MODULE_AUTHOR("David Airlie, Jesse Barnes");
38 MODULE_DESCRIPTION("DRM KMS helper");
39 MODULE_LICENSE("GPL and additional rights");
40
41 static LIST_HEAD(kernel_fb_helper_list);
42
43 int 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;
50 }
51 EXPORT_SYMBOL(drm_fb_helper_add_connector);
52
53 static 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 */
81 static 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;
92 struct drm_fb_helper_cmdline_mode *cmdline_mode;
93
94 if (!fb_help_conn)
95 return false;
96
97 cmdline_mode = &fb_help_conn->cmdline_mode;
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 }
176 done:
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
220 int 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
236 bool 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
256 int 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 }
263 EXPORT_SYMBOL(drm_fb_helper_panic);
264
265 static 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 */
274 void 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 }
281 EXPORT_SYMBOL(drm_fb_helper_restore);
282
283 #ifdef CONFIG_MAGIC_SYSRQ
284 static void drm_fb_helper_restore_work_fn(struct work_struct *ignored)
285 {
286 drm_fb_helper_restore();
287 }
288 static DECLARE_WORK(drm_fb_helper_restore_work, drm_fb_helper_restore_work_fn);
289
290 static void drm_fb_helper_sysrq(int dummy1, struct tty_struct *dummy3)
291 {
292 schedule_work(&drm_fb_helper_restore_work);
293 }
294
295 static 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 };
300 #endif
301
302 static 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 */
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;
318
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;
323
324 mutex_lock(&dev->mode_config.mutex);
325 crtc_funcs->dpms(crtc, DRM_MODE_DPMS_ON);
326 mutex_unlock(&dev->mode_config.mutex);
327
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;
332
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 }
338 }
339 }
340 }
341 }
342
343 static 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 */
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 mutex_lock(&dev->mode_config.mutex);
377 crtc_funcs->dpms(crtc, DRM_MODE_DPMS_OFF);
378 mutex_unlock(&dev->mode_config.mutex);
379 }
380 }
381 }
382
383 int drm_fb_helper_blank(int blank, struct fb_info *info)
384 {
385 switch (blank) {
386 /* Display: On; HSync: On, VSync: On */
387 case FB_BLANK_UNBLANK:
388 drm_fb_helper_on(info);
389 break;
390 /* Display: Off; HSync: On, VSync: On */
391 case FB_BLANK_NORMAL:
392 drm_fb_helper_off(info, DRM_MODE_DPMS_STANDBY);
393 break;
394 /* Display: Off; HSync: Off, VSync: On */
395 case FB_BLANK_HSYNC_SUSPEND:
396 drm_fb_helper_off(info, DRM_MODE_DPMS_STANDBY);
397 break;
398 /* Display: Off; HSync: On, VSync: Off */
399 case FB_BLANK_VSYNC_SUSPEND:
400 drm_fb_helper_off(info, DRM_MODE_DPMS_SUSPEND);
401 break;
402 /* Display: Off; HSync: Off, VSync: Off */
403 case FB_BLANK_POWERDOWN:
404 drm_fb_helper_off(info, DRM_MODE_DPMS_OFF);
405 break;
406 }
407 return 0;
408 }
409 EXPORT_SYMBOL(drm_fb_helper_blank);
410
411 static void drm_fb_helper_crtc_free(struct drm_fb_helper *helper)
412 {
413 int i;
414
415 for (i = 0; i < helper->crtc_count; i++)
416 kfree(helper->crtc_info[i].mode_set.connectors);
417 kfree(helper->crtc_info);
418 }
419
420 int drm_fb_helper_init_crtc_count(struct drm_fb_helper *helper, int crtc_count, int max_conn_count)
421 {
422 struct drm_device *dev = helper->dev;
423 struct drm_crtc *crtc;
424 int ret = 0;
425 int i;
426
427 helper->crtc_info = kcalloc(crtc_count, sizeof(struct drm_fb_helper_crtc), GFP_KERNEL);
428 if (!helper->crtc_info)
429 return -ENOMEM;
430
431 helper->crtc_count = crtc_count;
432
433 for (i = 0; i < crtc_count; i++) {
434 helper->crtc_info[i].mode_set.connectors =
435 kcalloc(max_conn_count,
436 sizeof(struct drm_connector *),
437 GFP_KERNEL);
438
439 if (!helper->crtc_info[i].mode_set.connectors) {
440 ret = -ENOMEM;
441 goto out_free;
442 }
443 helper->crtc_info[i].mode_set.num_connectors = 0;
444 }
445
446 i = 0;
447 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
448 helper->crtc_info[i].crtc_id = crtc->base.id;
449 helper->crtc_info[i].mode_set.crtc = crtc;
450 i++;
451 }
452 helper->conn_limit = max_conn_count;
453 return 0;
454 out_free:
455 drm_fb_helper_crtc_free(helper);
456 return -ENOMEM;
457 }
458 EXPORT_SYMBOL(drm_fb_helper_init_crtc_count);
459
460 static int setcolreg(struct drm_crtc *crtc, u16 red, u16 green,
461 u16 blue, u16 regno, struct fb_info *info)
462 {
463 struct drm_fb_helper *fb_helper = info->par;
464 struct drm_framebuffer *fb = fb_helper->fb;
465 int pindex;
466
467 if (info->fix.visual == FB_VISUAL_TRUECOLOR) {
468 u32 *palette;
469 u32 value;
470 /* place color in psuedopalette */
471 if (regno > 16)
472 return -EINVAL;
473 palette = (u32 *)info->pseudo_palette;
474 red >>= (16 - info->var.red.length);
475 green >>= (16 - info->var.green.length);
476 blue >>= (16 - info->var.blue.length);
477 value = (red << info->var.red.offset) |
478 (green << info->var.green.offset) |
479 (blue << info->var.blue.offset);
480 palette[regno] = value;
481 return 0;
482 }
483
484 pindex = regno;
485
486 if (fb->bits_per_pixel == 16) {
487 pindex = regno << 3;
488
489 if (fb->depth == 16 && regno > 63)
490 return -EINVAL;
491 if (fb->depth == 15 && regno > 31)
492 return -EINVAL;
493
494 if (fb->depth == 16) {
495 u16 r, g, b;
496 int i;
497 if (regno < 32) {
498 for (i = 0; i < 8; i++)
499 fb_helper->funcs->gamma_set(crtc, red,
500 green, blue, pindex + i);
501 }
502
503 fb_helper->funcs->gamma_get(crtc, &r,
504 &g, &b,
505 pindex >> 1);
506
507 for (i = 0; i < 4; i++)
508 fb_helper->funcs->gamma_set(crtc, r,
509 green, b,
510 (pindex >> 1) + i);
511 }
512 }
513
514 if (fb->depth != 16)
515 fb_helper->funcs->gamma_set(crtc, red, green, blue, pindex);
516 return 0;
517 }
518
519 int drm_fb_helper_setcmap(struct fb_cmap *cmap, struct fb_info *info)
520 {
521 struct drm_fb_helper *fb_helper = info->par;
522 struct drm_device *dev = fb_helper->dev;
523 u16 *red, *green, *blue, *transp;
524 struct drm_crtc *crtc;
525 int i, rc = 0;
526 int start;
527
528 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
529 struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
530 for (i = 0; i < fb_helper->crtc_count; i++) {
531 if (crtc->base.id == fb_helper->crtc_info[i].crtc_id)
532 break;
533 }
534 if (i == fb_helper->crtc_count)
535 continue;
536
537 red = cmap->red;
538 green = cmap->green;
539 blue = cmap->blue;
540 transp = cmap->transp;
541 start = cmap->start;
542
543 for (i = 0; i < cmap->len; i++) {
544 u16 hred, hgreen, hblue, htransp = 0xffff;
545
546 hred = *red++;
547 hgreen = *green++;
548 hblue = *blue++;
549
550 if (transp)
551 htransp = *transp++;
552
553 rc = setcolreg(crtc, hred, hgreen, hblue, start++, info);
554 if (rc)
555 return rc;
556 }
557 crtc_funcs->load_lut(crtc);
558 }
559 return rc;
560 }
561 EXPORT_SYMBOL(drm_fb_helper_setcmap);
562
563 int drm_fb_helper_setcolreg(unsigned regno,
564 unsigned red,
565 unsigned green,
566 unsigned blue,
567 unsigned transp,
568 struct fb_info *info)
569 {
570 struct drm_fb_helper *fb_helper = info->par;
571 struct drm_device *dev = fb_helper->dev;
572 struct drm_crtc *crtc;
573 int i;
574 int ret;
575
576 if (regno > 255)
577 return 1;
578
579 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
580 struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
581 for (i = 0; i < fb_helper->crtc_count; i++) {
582 if (crtc->base.id == fb_helper->crtc_info[i].crtc_id)
583 break;
584 }
585 if (i == fb_helper->crtc_count)
586 continue;
587
588 ret = setcolreg(crtc, red, green, blue, regno, info);
589 if (ret)
590 return ret;
591
592 crtc_funcs->load_lut(crtc);
593 }
594 return 0;
595 }
596 EXPORT_SYMBOL(drm_fb_helper_setcolreg);
597
598 int drm_fb_helper_check_var(struct fb_var_screeninfo *var,
599 struct fb_info *info)
600 {
601 struct drm_fb_helper *fb_helper = info->par;
602 struct drm_framebuffer *fb = fb_helper->fb;
603 int depth;
604
605 if (var->pixclock != 0)
606 return -EINVAL;
607
608 /* Need to resize the fb object !!! */
609 if (var->bits_per_pixel > fb->bits_per_pixel || var->xres > fb->width || var->yres > fb->height) {
610 DRM_DEBUG("fb userspace requested width/height/bpp is greater than current fb "
611 "object %dx%d-%d > %dx%d-%d\n", var->xres, var->yres, var->bits_per_pixel,
612 fb->width, fb->height, fb->bits_per_pixel);
613 return -EINVAL;
614 }
615
616 switch (var->bits_per_pixel) {
617 case 16:
618 depth = (var->green.length == 6) ? 16 : 15;
619 break;
620 case 32:
621 depth = (var->transp.length > 0) ? 32 : 24;
622 break;
623 default:
624 depth = var->bits_per_pixel;
625 break;
626 }
627
628 switch (depth) {
629 case 8:
630 var->red.offset = 0;
631 var->green.offset = 0;
632 var->blue.offset = 0;
633 var->red.length = 8;
634 var->green.length = 8;
635 var->blue.length = 8;
636 var->transp.length = 0;
637 var->transp.offset = 0;
638 break;
639 case 15:
640 var->red.offset = 10;
641 var->green.offset = 5;
642 var->blue.offset = 0;
643 var->red.length = 5;
644 var->green.length = 5;
645 var->blue.length = 5;
646 var->transp.length = 1;
647 var->transp.offset = 15;
648 break;
649 case 16:
650 var->red.offset = 11;
651 var->green.offset = 5;
652 var->blue.offset = 0;
653 var->red.length = 5;
654 var->green.length = 6;
655 var->blue.length = 5;
656 var->transp.length = 0;
657 var->transp.offset = 0;
658 break;
659 case 24:
660 var->red.offset = 16;
661 var->green.offset = 8;
662 var->blue.offset = 0;
663 var->red.length = 8;
664 var->green.length = 8;
665 var->blue.length = 8;
666 var->transp.length = 0;
667 var->transp.offset = 0;
668 break;
669 case 32:
670 var->red.offset = 16;
671 var->green.offset = 8;
672 var->blue.offset = 0;
673 var->red.length = 8;
674 var->green.length = 8;
675 var->blue.length = 8;
676 var->transp.length = 8;
677 var->transp.offset = 24;
678 break;
679 default:
680 return -EINVAL;
681 }
682 return 0;
683 }
684 EXPORT_SYMBOL(drm_fb_helper_check_var);
685
686 /* this will let fbcon do the mode init */
687 int drm_fb_helper_set_par(struct fb_info *info)
688 {
689 struct drm_fb_helper *fb_helper = info->par;
690 struct drm_device *dev = fb_helper->dev;
691 struct fb_var_screeninfo *var = &info->var;
692 struct drm_crtc *crtc;
693 int ret;
694 int i;
695
696 if (var->pixclock != 0) {
697 DRM_ERROR("PIXEL CLCOK SET\n");
698 return -EINVAL;
699 }
700
701 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
702
703 for (i = 0; i < fb_helper->crtc_count; i++) {
704 if (crtc->base.id == fb_helper->crtc_info[i].crtc_id)
705 break;
706 }
707 if (i == fb_helper->crtc_count)
708 continue;
709
710 if (crtc->fb == fb_helper->crtc_info[i].mode_set.fb) {
711 mutex_lock(&dev->mode_config.mutex);
712 ret = crtc->funcs->set_config(&fb_helper->crtc_info[i].mode_set);
713 mutex_unlock(&dev->mode_config.mutex);
714 if (ret)
715 return ret;
716 }
717 }
718 return 0;
719 }
720 EXPORT_SYMBOL(drm_fb_helper_set_par);
721
722 int drm_fb_helper_pan_display(struct fb_var_screeninfo *var,
723 struct fb_info *info)
724 {
725 struct drm_fb_helper *fb_helper = info->par;
726 struct drm_device *dev = fb_helper->dev;
727 struct drm_mode_set *modeset;
728 struct drm_crtc *crtc;
729 int ret = 0;
730 int i;
731
732 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
733 for (i = 0; i < fb_helper->crtc_count; i++) {
734 if (crtc->base.id == fb_helper->crtc_info[i].crtc_id)
735 break;
736 }
737
738 if (i == fb_helper->crtc_count)
739 continue;
740
741 modeset = &fb_helper->crtc_info[i].mode_set;
742
743 modeset->x = var->xoffset;
744 modeset->y = var->yoffset;
745
746 if (modeset->num_connectors) {
747 mutex_lock(&dev->mode_config.mutex);
748 ret = crtc->funcs->set_config(modeset);
749 mutex_unlock(&dev->mode_config.mutex);
750 if (!ret) {
751 info->var.xoffset = var->xoffset;
752 info->var.yoffset = var->yoffset;
753 }
754 }
755 }
756 return ret;
757 }
758 EXPORT_SYMBOL(drm_fb_helper_pan_display);
759
760 int drm_fb_helper_single_fb_probe(struct drm_device *dev,
761 int preferred_bpp,
762 int (*fb_create)(struct drm_device *dev,
763 uint32_t fb_width,
764 uint32_t fb_height,
765 uint32_t surface_width,
766 uint32_t surface_height,
767 uint32_t surface_depth,
768 uint32_t surface_bpp,
769 struct drm_framebuffer **fb_ptr))
770 {
771 struct drm_crtc *crtc;
772 struct drm_connector *connector;
773 unsigned int fb_width = (unsigned)-1, fb_height = (unsigned)-1;
774 unsigned int surface_width = 0, surface_height = 0;
775 int new_fb = 0;
776 int crtc_count = 0;
777 int ret, i, conn_count = 0;
778 struct fb_info *info;
779 struct drm_framebuffer *fb;
780 struct drm_mode_set *modeset = NULL;
781 struct drm_fb_helper *fb_helper;
782 uint32_t surface_depth = 24, surface_bpp = 32;
783
784 /* if driver picks 8 or 16 by default use that
785 for both depth/bpp */
786 if (preferred_bpp != surface_bpp) {
787 surface_depth = surface_bpp = preferred_bpp;
788 }
789 /* first up get a count of crtcs now in use and new min/maxes width/heights */
790 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
791 struct drm_fb_helper_connector *fb_help_conn = connector->fb_helper_private;
792
793 struct drm_fb_helper_cmdline_mode *cmdline_mode;
794
795 if (!fb_help_conn)
796 continue;
797
798 cmdline_mode = &fb_help_conn->cmdline_mode;
799
800 if (cmdline_mode->bpp_specified) {
801 switch (cmdline_mode->bpp) {
802 case 8:
803 surface_depth = surface_bpp = 8;
804 break;
805 case 15:
806 surface_depth = 15;
807 surface_bpp = 16;
808 break;
809 case 16:
810 surface_depth = surface_bpp = 16;
811 break;
812 case 24:
813 surface_depth = surface_bpp = 24;
814 break;
815 case 32:
816 surface_depth = 24;
817 surface_bpp = 32;
818 break;
819 }
820 break;
821 }
822 }
823
824 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
825 if (drm_helper_crtc_in_use(crtc)) {
826 if (crtc->desired_mode) {
827 if (crtc->desired_mode->hdisplay < fb_width)
828 fb_width = crtc->desired_mode->hdisplay;
829
830 if (crtc->desired_mode->vdisplay < fb_height)
831 fb_height = crtc->desired_mode->vdisplay;
832
833 if (crtc->desired_mode->hdisplay > surface_width)
834 surface_width = crtc->desired_mode->hdisplay;
835
836 if (crtc->desired_mode->vdisplay > surface_height)
837 surface_height = crtc->desired_mode->vdisplay;
838 }
839 crtc_count++;
840 }
841 }
842
843 if (crtc_count == 0 || fb_width == -1 || fb_height == -1) {
844 /* hmm everyone went away - assume VGA cable just fell out
845 and will come back later. */
846 return 0;
847 }
848
849 /* do we have an fb already? */
850 if (list_empty(&dev->mode_config.fb_kernel_list)) {
851 ret = (*fb_create)(dev, fb_width, fb_height, surface_width,
852 surface_height, surface_depth, surface_bpp,
853 &fb);
854 if (ret)
855 return -EINVAL;
856 new_fb = 1;
857 } else {
858 fb = list_first_entry(&dev->mode_config.fb_kernel_list,
859 struct drm_framebuffer, filp_head);
860
861 /* if someone hotplugs something bigger than we have already allocated, we are pwned.
862 As really we can't resize an fbdev that is in the wild currently due to fbdev
863 not really being designed for the lower layers moving stuff around under it.
864 - so in the grand style of things - punt. */
865 if ((fb->width < surface_width) ||
866 (fb->height < surface_height)) {
867 DRM_ERROR("Framebuffer not large enough to scale console onto.\n");
868 return -EINVAL;
869 }
870 }
871
872 info = fb->fbdev;
873 fb_helper = info->par;
874
875 crtc_count = 0;
876 /* okay we need to setup new connector sets in the crtcs */
877 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
878 modeset = &fb_helper->crtc_info[crtc_count].mode_set;
879 modeset->fb = fb;
880 conn_count = 0;
881 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
882 if (connector->encoder)
883 if (connector->encoder->crtc == modeset->crtc) {
884 modeset->connectors[conn_count] = connector;
885 conn_count++;
886 if (conn_count > fb_helper->conn_limit)
887 BUG();
888 }
889 }
890
891 for (i = conn_count; i < fb_helper->conn_limit; i++)
892 modeset->connectors[i] = NULL;
893
894 modeset->crtc = crtc;
895 crtc_count++;
896
897 modeset->num_connectors = conn_count;
898 if (modeset->crtc->desired_mode) {
899 if (modeset->mode)
900 drm_mode_destroy(dev, modeset->mode);
901 modeset->mode = drm_mode_duplicate(dev,
902 modeset->crtc->desired_mode);
903 }
904 }
905 fb_helper->crtc_count = crtc_count;
906 fb_helper->fb = fb;
907
908 if (new_fb) {
909 info->var.pixclock = 0;
910 ret = fb_alloc_cmap(&info->cmap, modeset->crtc->gamma_size, 0);
911 if (ret)
912 return ret;
913 if (register_framebuffer(info) < 0) {
914 fb_dealloc_cmap(&info->cmap);
915 return -EINVAL;
916 }
917 } else {
918 drm_fb_helper_set_par(info);
919 }
920 printk(KERN_INFO "fb%d: %s frame buffer device\n", info->node,
921 info->fix.id);
922
923 /* Switch back to kernel console on panic */
924 /* multi card linked list maybe */
925 if (list_empty(&kernel_fb_helper_list)) {
926 printk(KERN_INFO "registered panic notifier\n");
927 atomic_notifier_chain_register(&panic_notifier_list,
928 &paniced);
929 register_sysrq_key('v', &sysrq_drm_fb_helper_restore_op);
930 }
931 list_add(&fb_helper->kernel_fb_list, &kernel_fb_helper_list);
932 return 0;
933 }
934 EXPORT_SYMBOL(drm_fb_helper_single_fb_probe);
935
936 void drm_fb_helper_free(struct drm_fb_helper *helper)
937 {
938 list_del(&helper->kernel_fb_list);
939 if (list_empty(&kernel_fb_helper_list)) {
940 printk(KERN_INFO "unregistered panic notifier\n");
941 atomic_notifier_chain_unregister(&panic_notifier_list,
942 &paniced);
943 unregister_sysrq_key('v', &sysrq_drm_fb_helper_restore_op);
944 }
945 drm_fb_helper_crtc_free(helper);
946 fb_dealloc_cmap(&helper->fb->fbdev->cmap);
947 }
948 EXPORT_SYMBOL(drm_fb_helper_free);
949
950 void drm_fb_helper_fill_fix(struct fb_info *info, uint32_t pitch,
951 uint32_t depth)
952 {
953 info->fix.type = FB_TYPE_PACKED_PIXELS;
954 info->fix.visual = depth == 8 ? FB_VISUAL_PSEUDOCOLOR :
955 FB_VISUAL_TRUECOLOR;
956 info->fix.type_aux = 0;
957 info->fix.xpanstep = 1; /* doing it in hw */
958 info->fix.ypanstep = 1; /* doing it in hw */
959 info->fix.ywrapstep = 0;
960 info->fix.accel = FB_ACCEL_NONE;
961 info->fix.type_aux = 0;
962
963 info->fix.line_length = pitch;
964 return;
965 }
966 EXPORT_SYMBOL(drm_fb_helper_fill_fix);
967
968 void drm_fb_helper_fill_var(struct fb_info *info, struct drm_framebuffer *fb,
969 uint32_t fb_width, uint32_t fb_height)
970 {
971 info->pseudo_palette = fb->pseudo_palette;
972 info->var.xres_virtual = fb->width;
973 info->var.yres_virtual = fb->height;
974 info->var.bits_per_pixel = fb->bits_per_pixel;
975 info->var.xoffset = 0;
976 info->var.yoffset = 0;
977 info->var.activate = FB_ACTIVATE_NOW;
978 info->var.height = -1;
979 info->var.width = -1;
980
981 switch (fb->depth) {
982 case 8:
983 info->var.red.offset = 0;
984 info->var.green.offset = 0;
985 info->var.blue.offset = 0;
986 info->var.red.length = 8; /* 8bit DAC */
987 info->var.green.length = 8;
988 info->var.blue.length = 8;
989 info->var.transp.offset = 0;
990 info->var.transp.length = 0;
991 break;
992 case 15:
993 info->var.red.offset = 10;
994 info->var.green.offset = 5;
995 info->var.blue.offset = 0;
996 info->var.red.length = 5;
997 info->var.green.length = 5;
998 info->var.blue.length = 5;
999 info->var.transp.offset = 15;
1000 info->var.transp.length = 1;
1001 break;
1002 case 16:
1003 info->var.red.offset = 11;
1004 info->var.green.offset = 5;
1005 info->var.blue.offset = 0;
1006 info->var.red.length = 5;
1007 info->var.green.length = 6;
1008 info->var.blue.length = 5;
1009 info->var.transp.offset = 0;
1010 break;
1011 case 24:
1012 info->var.red.offset = 16;
1013 info->var.green.offset = 8;
1014 info->var.blue.offset = 0;
1015 info->var.red.length = 8;
1016 info->var.green.length = 8;
1017 info->var.blue.length = 8;
1018 info->var.transp.offset = 0;
1019 info->var.transp.length = 0;
1020 break;
1021 case 32:
1022 info->var.red.offset = 16;
1023 info->var.green.offset = 8;
1024 info->var.blue.offset = 0;
1025 info->var.red.length = 8;
1026 info->var.green.length = 8;
1027 info->var.blue.length = 8;
1028 info->var.transp.offset = 24;
1029 info->var.transp.length = 8;
1030 break;
1031 default:
1032 break;
1033 }
1034
1035 info->var.xres = fb_width;
1036 info->var.yres = fb_height;
1037 }
1038 EXPORT_SYMBOL(drm_fb_helper_fill_var);
CRIS linux kernel tree