2 * linux/drivers/video/fbmon.c
4 * Copyright (C) 2002 James Simmons <jsimmons@users.sf.net>
8 * The EDID Parser is a conglomeration from the following sources:
10 * 1. SciTech SNAP Graphics Architecture
11 * Copyright (C) 1991-2002 SciTech Software, Inc. All rights reserved.
13 * 2. XFree86 4.3.0, interpret_edid.c
14 * Copyright 1998 by Egbert Eich <Egbert.Eich@Physik.TU-Darmstadt.DE>
16 * 3. John Fremlin <vii@users.sourceforge.net> and
17 * Ani Joshi <ajoshi@unixbox.com>
19 * Generalized Timing Formula is derived from:
21 * GTF Spreadsheet by Andy Morrish (1/5/97)
22 * available at http://www.vesa.org
24 * This file is subject to the terms and conditions of the GNU General Public
25 * License. See the file COPYING in the main directory of this archive
29 #include <linux/tty.h>
31 #include <linux/module.h>
32 #include <linux/pci.h>
33 #include <video/edid.h>
36 #include <asm/pci-bridge.h>
44 #undef DEBUG /* define this for verbose EDID parsing output */
47 #define DPRINTK(fmt, args...) printk(fmt,## args)
49 #define DPRINTK(fmt, args...)
52 #define FBMON_FIX_HEADER 1
53 #define FBMON_FIX_INPUT 2
55 #ifdef CONFIG_FB_MODE_HELPERS
62 static struct broken_edid brokendb
[] = {
65 .manufacturer
= "DEC",
67 .fix
= FBMON_FIX_HEADER
,
69 /* ViewSonic PF775a */
71 .manufacturer
= "VSC",
73 .fix
= FBMON_FIX_INPUT
,
77 static const unsigned char edid_v1_header
[] = { 0x00, 0xff, 0xff, 0xff,
78 0xff, 0xff, 0xff, 0x00
81 static void copy_string(unsigned char *c
, unsigned char *s
)
85 for (i
= 0; (i
< 13 && *c
!= 0x0A); i
++)
88 while (i
-- && (*--s
== 0x20)) *s
= 0;
91 static int check_edid(unsigned char *edid
)
93 unsigned char *block
= edid
+ ID_MANUFACTURER_NAME
, manufacturer
[4];
96 int i
, fix
= 0, ret
= 0;
98 manufacturer
[0] = ((block
[0] & 0x7c) >> 2) + '@';
99 manufacturer
[1] = ((block
[0] & 0x03) << 3) +
100 ((block
[1] & 0xe0) >> 5) + '@';
101 manufacturer
[2] = (block
[1] & 0x1f) + '@';
103 model
= block
[2] + (block
[3] << 8);
105 for (i
= 0; i
< ARRAY_SIZE(brokendb
); i
++) {
106 if (!strncmp(manufacturer
, brokendb
[i
].manufacturer
, 4) &&
107 brokendb
[i
].model
== model
) {
108 printk("fbmon: The EDID Block of "
109 "Manufacturer: %s Model: 0x%x is known to "
110 "be broken,\n", manufacturer
, model
);
111 fix
= brokendb
[i
].fix
;
117 case FBMON_FIX_HEADER
:
118 for (i
= 0; i
< 8; i
++) {
119 if (edid
[i
] != edid_v1_header
[i
])
123 case FBMON_FIX_INPUT
:
124 b
= edid
+ EDID_STRUCT_DISPLAY
;
125 /* Only if display is GTF capable will
126 the input type be reset to analog */
127 if (b
[4] & 0x01 && b
[0] & 0x80)
135 static void fix_edid(unsigned char *edid
, int fix
)
140 case FBMON_FIX_HEADER
:
141 printk("fbmon: trying a header reconstruct\n");
142 memcpy(edid
, edid_v1_header
, 8);
144 case FBMON_FIX_INPUT
:
145 printk("fbmon: trying to fix input type\n");
146 b
= edid
+ EDID_STRUCT_DISPLAY
;
152 static int edid_checksum(unsigned char *edid
)
154 unsigned char i
, csum
= 0, all_null
= 0;
155 int err
= 0, fix
= check_edid(edid
);
160 for (i
= 0; i
< EDID_LENGTH
; i
++) {
165 if (csum
== 0x00 && all_null
) {
166 /* checksum passed, everything's good */
173 static int edid_check_header(unsigned char *edid
)
175 int i
, err
= 1, fix
= check_edid(edid
);
180 for (i
= 0; i
< 8; i
++) {
181 if (edid
[i
] != edid_v1_header
[i
])
188 static void parse_vendor_block(unsigned char *block
, struct fb_monspecs
*specs
)
190 specs
->manufacturer
[0] = ((block
[0] & 0x7c) >> 2) + '@';
191 specs
->manufacturer
[1] = ((block
[0] & 0x03) << 3) +
192 ((block
[1] & 0xe0) >> 5) + '@';
193 specs
->manufacturer
[2] = (block
[1] & 0x1f) + '@';
194 specs
->manufacturer
[3] = 0;
195 specs
->model
= block
[2] + (block
[3] << 8);
196 specs
->serial
= block
[4] + (block
[5] << 8) +
197 (block
[6] << 16) + (block
[7] << 24);
198 specs
->year
= block
[9] + 1990;
199 specs
->week
= block
[8];
200 DPRINTK(" Manufacturer: %s\n", specs
->manufacturer
);
201 DPRINTK(" Model: %x\n", specs
->model
);
202 DPRINTK(" Serial#: %u\n", specs
->serial
);
203 DPRINTK(" Year: %u Week %u\n", specs
->year
, specs
->week
);
206 static void get_dpms_capabilities(unsigned char flags
,
207 struct fb_monspecs
*specs
)
210 if (flags
& DPMS_ACTIVE_OFF
)
211 specs
->dpms
|= FB_DPMS_ACTIVE_OFF
;
212 if (flags
& DPMS_SUSPEND
)
213 specs
->dpms
|= FB_DPMS_SUSPEND
;
214 if (flags
& DPMS_STANDBY
)
215 specs
->dpms
|= FB_DPMS_STANDBY
;
216 DPRINTK(" DPMS: Active %s, Suspend %s, Standby %s\n",
217 (flags
& DPMS_ACTIVE_OFF
) ? "yes" : "no",
218 (flags
& DPMS_SUSPEND
) ? "yes" : "no",
219 (flags
& DPMS_STANDBY
) ? "yes" : "no");
222 static void get_chroma(unsigned char *block
, struct fb_monspecs
*specs
)
226 DPRINTK(" Chroma\n");
227 /* Chromaticity data */
228 tmp
= ((block
[5] & (3 << 6)) >> 6) | (block
[0x7] << 2);
231 specs
->chroma
.redx
= tmp
/1024;
232 DPRINTK(" RedX: 0.%03d ", specs
->chroma
.redx
);
234 tmp
= ((block
[5] & (3 << 4)) >> 4) | (block
[0x8] << 2);
237 specs
->chroma
.redy
= tmp
/1024;
238 DPRINTK("RedY: 0.%03d\n", specs
->chroma
.redy
);
240 tmp
= ((block
[5] & (3 << 2)) >> 2) | (block
[0x9] << 2);
243 specs
->chroma
.greenx
= tmp
/1024;
244 DPRINTK(" GreenX: 0.%03d ", specs
->chroma
.greenx
);
246 tmp
= (block
[5] & 3) | (block
[0xa] << 2);
249 specs
->chroma
.greeny
= tmp
/1024;
250 DPRINTK("GreenY: 0.%03d\n", specs
->chroma
.greeny
);
252 tmp
= ((block
[6] & (3 << 6)) >> 6) | (block
[0xb] << 2);
255 specs
->chroma
.bluex
= tmp
/1024;
256 DPRINTK(" BlueX: 0.%03d ", specs
->chroma
.bluex
);
258 tmp
= ((block
[6] & (3 << 4)) >> 4) | (block
[0xc] << 2);
261 specs
->chroma
.bluey
= tmp
/1024;
262 DPRINTK("BlueY: 0.%03d\n", specs
->chroma
.bluey
);
264 tmp
= ((block
[6] & (3 << 2)) >> 2) | (block
[0xd] << 2);
267 specs
->chroma
.whitex
= tmp
/1024;
268 DPRINTK(" WhiteX: 0.%03d ", specs
->chroma
.whitex
);
270 tmp
= (block
[6] & 3) | (block
[0xe] << 2);
273 specs
->chroma
.whitey
= tmp
/1024;
274 DPRINTK("WhiteY: 0.%03d\n", specs
->chroma
.whitey
);
277 static int edid_is_serial_block(unsigned char *block
)
279 if ((block
[0] == 0x00) && (block
[1] == 0x00) &&
280 (block
[2] == 0x00) && (block
[3] == 0xff) &&
287 static int edid_is_ascii_block(unsigned char *block
)
289 if ((block
[0] == 0x00) && (block
[1] == 0x00) &&
290 (block
[2] == 0x00) && (block
[3] == 0xfe) &&
297 static int edid_is_limits_block(unsigned char *block
)
299 if ((block
[0] == 0x00) && (block
[1] == 0x00) &&
300 (block
[2] == 0x00) && (block
[3] == 0xfd) &&
307 static int edid_is_monitor_block(unsigned char *block
)
309 if ((block
[0] == 0x00) && (block
[1] == 0x00) &&
310 (block
[2] == 0x00) && (block
[3] == 0xfc) &&
317 static void calc_mode_timings(int xres
, int yres
, int refresh
,
318 struct fb_videomode
*mode
)
320 struct fb_var_screeninfo
*var
;
322 var
= kzalloc(sizeof(struct fb_var_screeninfo
), GFP_KERNEL
);
327 fb_get_mode(FB_VSYNCTIMINGS
| FB_IGNOREMON
,
331 mode
->pixclock
= var
->pixclock
;
332 mode
->refresh
= refresh
;
333 mode
->left_margin
= var
->left_margin
;
334 mode
->right_margin
= var
->right_margin
;
335 mode
->upper_margin
= var
->upper_margin
;
336 mode
->lower_margin
= var
->lower_margin
;
337 mode
->hsync_len
= var
->hsync_len
;
338 mode
->vsync_len
= var
->vsync_len
;
345 static int get_est_timing(unsigned char *block
, struct fb_videomode
*mode
)
352 calc_mode_timings(720, 400, 70, &mode
[num
]);
353 mode
[num
++].flag
= FB_MODE_IS_CALCULATED
;
354 DPRINTK(" 720x400@70Hz\n");
357 calc_mode_timings(720, 400, 88, &mode
[num
]);
358 mode
[num
++].flag
= FB_MODE_IS_CALCULATED
;
359 DPRINTK(" 720x400@88Hz\n");
362 mode
[num
++] = vesa_modes
[3];
363 DPRINTK(" 640x480@60Hz\n");
366 calc_mode_timings(640, 480, 67, &mode
[num
]);
367 mode
[num
++].flag
= FB_MODE_IS_CALCULATED
;
368 DPRINTK(" 640x480@67Hz\n");
371 mode
[num
++] = vesa_modes
[4];
372 DPRINTK(" 640x480@72Hz\n");
375 mode
[num
++] = vesa_modes
[5];
376 DPRINTK(" 640x480@75Hz\n");
379 mode
[num
++] = vesa_modes
[7];
380 DPRINTK(" 800x600@56Hz\n");
383 mode
[num
++] = vesa_modes
[8];
384 DPRINTK(" 800x600@60Hz\n");
389 mode
[num
++] = vesa_modes
[9];
390 DPRINTK(" 800x600@72Hz\n");
393 mode
[num
++] = vesa_modes
[10];
394 DPRINTK(" 800x600@75Hz\n");
397 calc_mode_timings(832, 624, 75, &mode
[num
]);
398 mode
[num
++].flag
= FB_MODE_IS_CALCULATED
;
399 DPRINTK(" 832x624@75Hz\n");
402 mode
[num
++] = vesa_modes
[12];
403 DPRINTK(" 1024x768@87Hz Interlaced\n");
406 mode
[num
++] = vesa_modes
[13];
407 DPRINTK(" 1024x768@60Hz\n");
410 mode
[num
++] = vesa_modes
[14];
411 DPRINTK(" 1024x768@70Hz\n");
414 mode
[num
++] = vesa_modes
[15];
415 DPRINTK(" 1024x768@75Hz\n");
418 mode
[num
++] = vesa_modes
[21];
419 DPRINTK(" 1280x1024@75Hz\n");
423 mode
[num
++] = vesa_modes
[17];
424 DPRINTK(" 1152x870@75Hz\n");
426 DPRINTK(" Manufacturer's mask: %x\n",c
&0x7F);
430 static int get_std_timing(unsigned char *block
, struct fb_videomode
*mode
)
432 int xres
, yres
= 0, refresh
, ratio
, i
;
434 xres
= (block
[0] + 31) * 8;
438 ratio
= (block
[1] & 0xc0) >> 6;
450 yres
= (xres
* 9)/16;
453 refresh
= (block
[1] & 0x3f) + 60;
455 DPRINTK(" %dx%d@%dHz\n", xres
, yres
, refresh
);
456 for (i
= 0; i
< VESA_MODEDB_SIZE
; i
++) {
457 if (vesa_modes
[i
].xres
== xres
&&
458 vesa_modes
[i
].yres
== yres
&&
459 vesa_modes
[i
].refresh
== refresh
) {
460 *mode
= vesa_modes
[i
];
461 mode
->flag
|= FB_MODE_IS_STANDARD
;
465 calc_mode_timings(xres
, yres
, refresh
, mode
);
469 static int get_dst_timing(unsigned char *block
,
470 struct fb_videomode
*mode
)
474 for (j
= 0; j
< 6; j
++, block
+= STD_TIMING_DESCRIPTION_SIZE
)
475 num
+= get_std_timing(block
, &mode
[num
]);
480 static void get_detailed_timing(unsigned char *block
,
481 struct fb_videomode
*mode
)
483 mode
->xres
= H_ACTIVE
;
484 mode
->yres
= V_ACTIVE
;
485 mode
->pixclock
= PIXEL_CLOCK
;
486 mode
->pixclock
/= 1000;
487 mode
->pixclock
= KHZ2PICOS(mode
->pixclock
);
488 mode
->right_margin
= H_SYNC_OFFSET
;
489 mode
->left_margin
= (H_ACTIVE
+ H_BLANKING
) -
490 (H_ACTIVE
+ H_SYNC_OFFSET
+ H_SYNC_WIDTH
);
491 mode
->upper_margin
= V_BLANKING
- V_SYNC_OFFSET
-
493 mode
->lower_margin
= V_SYNC_OFFSET
;
494 mode
->hsync_len
= H_SYNC_WIDTH
;
495 mode
->vsync_len
= V_SYNC_WIDTH
;
497 mode
->sync
|= FB_SYNC_HOR_HIGH_ACT
;
499 mode
->sync
|= FB_SYNC_VERT_HIGH_ACT
;
500 mode
->refresh
= PIXEL_CLOCK
/((H_ACTIVE
+ H_BLANKING
) *
501 (V_ACTIVE
+ V_BLANKING
));
503 mode
->flag
= FB_MODE_IS_DETAILED
;
505 DPRINTK(" %d MHz ", PIXEL_CLOCK
/1000000);
506 DPRINTK("%d %d %d %d ", H_ACTIVE
, H_ACTIVE
+ H_SYNC_OFFSET
,
507 H_ACTIVE
+ H_SYNC_OFFSET
+ H_SYNC_WIDTH
, H_ACTIVE
+ H_BLANKING
);
508 DPRINTK("%d %d %d %d ", V_ACTIVE
, V_ACTIVE
+ V_SYNC_OFFSET
,
509 V_ACTIVE
+ V_SYNC_OFFSET
+ V_SYNC_WIDTH
, V_ACTIVE
+ V_BLANKING
);
510 DPRINTK("%sHSync %sVSync\n\n", (HSYNC_POSITIVE
) ? "+" : "-",
511 (VSYNC_POSITIVE
) ? "+" : "-");
515 * fb_create_modedb - create video mode database
517 * @dbsize: database size
519 * RETURNS: struct fb_videomode, @dbsize contains length of database
522 * This function builds a mode database using the contents of the EDID
525 static struct fb_videomode
*fb_create_modedb(unsigned char *edid
, int *dbsize
)
527 struct fb_videomode
*mode
, *m
;
528 unsigned char *block
;
531 mode
= kzalloc(50 * sizeof(struct fb_videomode
), GFP_KERNEL
);
535 if (edid
== NULL
|| !edid_checksum(edid
) ||
536 !edid_check_header(edid
)) {
543 DPRINTK(" Detailed Timings\n");
544 block
= edid
+ DETAILED_TIMING_DESCRIPTIONS_START
;
545 for (i
= 0; i
< 4; i
++, block
+= DETAILED_TIMING_DESCRIPTION_SIZE
) {
548 if (!(block
[0] == 0x00 && block
[1] == 0x00)) {
549 get_detailed_timing(block
, &mode
[num
]);
551 mode
[num
].flag
|= FB_MODE_IS_FIRST
;
558 DPRINTK(" Supported VESA Modes\n");
559 block
= edid
+ ESTABLISHED_TIMING_1
;
560 num
+= get_est_timing(block
, &mode
[num
]);
562 DPRINTK(" Standard Timings\n");
563 block
= edid
+ STD_TIMING_DESCRIPTIONS_START
;
564 for (i
= 0; i
< STD_TIMING
; i
++, block
+= STD_TIMING_DESCRIPTION_SIZE
)
565 num
+= get_std_timing(block
, &mode
[num
]);
567 block
= edid
+ DETAILED_TIMING_DESCRIPTIONS_START
;
568 for (i
= 0; i
< 4; i
++, block
+= DETAILED_TIMING_DESCRIPTION_SIZE
) {
569 if (block
[0] == 0x00 && block
[1] == 0x00 && block
[3] == 0xfa)
570 num
+= get_dst_timing(block
+ 5, &mode
[num
]);
573 /* Yikes, EDID data is totally useless */
580 m
= kmalloc(num
* sizeof(struct fb_videomode
), GFP_KERNEL
);
583 memmove(m
, mode
, num
* sizeof(struct fb_videomode
));
589 * fb_destroy_modedb - destroys mode database
590 * @modedb: mode database to destroy
593 * Destroy mode database created by fb_create_modedb
595 void fb_destroy_modedb(struct fb_videomode
*modedb
)
600 static int fb_get_monitor_limits(unsigned char *edid
, struct fb_monspecs
*specs
)
603 unsigned char *block
;
605 block
= edid
+ DETAILED_TIMING_DESCRIPTIONS_START
;
607 DPRINTK(" Monitor Operating Limits: ");
609 for (i
= 0; i
< 4; i
++, block
+= DETAILED_TIMING_DESCRIPTION_SIZE
) {
610 if (edid_is_limits_block(block
)) {
611 specs
->hfmin
= H_MIN_RATE
* 1000;
612 specs
->hfmax
= H_MAX_RATE
* 1000;
613 specs
->vfmin
= V_MIN_RATE
;
614 specs
->vfmax
= V_MAX_RATE
;
615 specs
->dclkmax
= MAX_PIXEL_CLOCK
* 1000000;
616 specs
->gtf
= (GTF_SUPPORT
) ? 1 : 0;
618 DPRINTK("From EDID\n");
623 /* estimate monitor limits based on modes supported */
625 struct fb_videomode
*modes
, *mode
;
626 int num_modes
, i
, hz
, hscan
, pixclock
;
629 modes
= fb_create_modedb(edid
, &num_modes
);
631 DPRINTK("None Available\n");
636 for (i
= 0; i
< num_modes
; i
++) {
638 pixclock
= PICOS2KHZ(modes
[i
].pixclock
) * 1000;
639 htotal
= mode
->xres
+ mode
->right_margin
+ mode
->hsync_len
641 vtotal
= mode
->yres
+ mode
->lower_margin
+ mode
->vsync_len
642 + mode
->upper_margin
;
644 if (mode
->vmode
& FB_VMODE_INTERLACED
)
647 if (mode
->vmode
& FB_VMODE_DOUBLE
)
650 hscan
= (pixclock
+ htotal
/ 2) / htotal
;
651 hscan
= (hscan
+ 500) / 1000 * 1000;
652 hz
= (hscan
+ vtotal
/ 2) / vtotal
;
654 if (specs
->dclkmax
== 0 || specs
->dclkmax
< pixclock
)
655 specs
->dclkmax
= pixclock
;
657 if (specs
->dclkmin
== 0 || specs
->dclkmin
> pixclock
)
658 specs
->dclkmin
= pixclock
;
660 if (specs
->hfmax
== 0 || specs
->hfmax
< hscan
)
661 specs
->hfmax
= hscan
;
663 if (specs
->hfmin
== 0 || specs
->hfmin
> hscan
)
664 specs
->hfmin
= hscan
;
666 if (specs
->vfmax
== 0 || specs
->vfmax
< hz
)
669 if (specs
->vfmin
== 0 || specs
->vfmin
> hz
)
672 DPRINTK("Extrapolated\n");
673 fb_destroy_modedb(modes
);
675 DPRINTK(" H: %d-%dKHz V: %d-%dHz DCLK: %dMHz\n",
676 specs
->hfmin
/1000, specs
->hfmax
/1000, specs
->vfmin
,
677 specs
->vfmax
, specs
->dclkmax
/1000000);
681 static void get_monspecs(unsigned char *edid
, struct fb_monspecs
*specs
)
683 unsigned char c
, *block
;
685 block
= edid
+ EDID_STRUCT_DISPLAY
;
687 fb_get_monitor_limits(edid
, specs
);
692 specs
->input
|= FB_DISP_DDI
;
693 DPRINTK(" Digital Display Input");
695 DPRINTK(" Analog Display Input: Input Voltage - ");
696 switch ((block
[0] & 0x60) >> 5) {
698 DPRINTK("0.700V/0.300V");
699 specs
->input
|= FB_DISP_ANA_700_300
;
702 DPRINTK("0.714V/0.286V");
703 specs
->input
|= FB_DISP_ANA_714_286
;
706 DPRINTK("1.000V/0.400V");
707 specs
->input
|= FB_DISP_ANA_1000_400
;
710 DPRINTK("0.700V/0.000V");
711 specs
->input
|= FB_DISP_ANA_700_000
;
715 DPRINTK("\n Sync: ");
718 DPRINTK(" Configurable signal level\n");
722 DPRINTK("Blank to Blank ");
723 specs
->signal
|= FB_SIGNAL_BLANK_BLANK
;
726 DPRINTK("Separate ");
727 specs
->signal
|= FB_SIGNAL_SEPARATE
;
730 DPRINTK("Composite ");
731 specs
->signal
|= FB_SIGNAL_COMPOSITE
;
734 DPRINTK("Sync on Green ");
735 specs
->signal
|= FB_SIGNAL_SYNC_ON_GREEN
;
738 DPRINTK("Serration on ");
739 specs
->signal
|= FB_SIGNAL_SERRATION_ON
;
742 specs
->max_x
= block
[1];
743 specs
->max_y
= block
[2];
744 DPRINTK(" Max H-size in cm: ");
746 DPRINTK("%d\n", specs
->max_x
);
748 DPRINTK("variable\n");
749 DPRINTK(" Max V-size in cm: ");
751 DPRINTK("%d\n", specs
->max_y
);
753 DPRINTK("variable\n");
756 specs
->gamma
= c
+100;
758 DPRINTK("%d.%d\n", specs
->gamma
/100, specs
->gamma
% 100);
760 get_dpms_capabilities(block
[4], specs
);
762 switch ((block
[4] & 0x18) >> 3) {
764 DPRINTK(" Monochrome/Grayscale\n");
765 specs
->input
|= FB_DISP_MONO
;
768 DPRINTK(" RGB Color Display\n");
769 specs
->input
|= FB_DISP_RGB
;
772 DPRINTK(" Non-RGB Multicolor Display\n");
773 specs
->input
|= FB_DISP_MULTI
;
776 DPRINTK(" Unknown\n");
777 specs
->input
|= FB_DISP_UNKNOWN
;
781 get_chroma(block
, specs
);
786 DPRINTK(" Default color format is primary\n");
787 specs
->misc
|= FB_MISC_PRIM_COLOR
;
790 DPRINTK(" First DETAILED Timing is preferred\n");
791 specs
->misc
|= FB_MISC_1ST_DETAIL
;
794 printk(" Display is GTF capable\n");
799 static int edid_is_timing_block(unsigned char *block
)
801 if ((block
[0] != 0x00) || (block
[1] != 0x00) ||
802 (block
[2] != 0x00) || (block
[4] != 0x00))
808 int fb_parse_edid(unsigned char *edid
, struct fb_var_screeninfo
*var
)
811 unsigned char *block
;
813 if (edid
== NULL
|| var
== NULL
)
816 if (!(edid_checksum(edid
)))
819 if (!(edid_check_header(edid
)))
822 block
= edid
+ DETAILED_TIMING_DESCRIPTIONS_START
;
824 for (i
= 0; i
< 4; i
++, block
+= DETAILED_TIMING_DESCRIPTION_SIZE
) {
825 if (edid_is_timing_block(block
)) {
826 var
->xres
= var
->xres_virtual
= H_ACTIVE
;
827 var
->yres
= var
->yres_virtual
= V_ACTIVE
;
828 var
->height
= var
->width
= -1;
829 var
->right_margin
= H_SYNC_OFFSET
;
830 var
->left_margin
= (H_ACTIVE
+ H_BLANKING
) -
831 (H_ACTIVE
+ H_SYNC_OFFSET
+ H_SYNC_WIDTH
);
832 var
->upper_margin
= V_BLANKING
- V_SYNC_OFFSET
-
834 var
->lower_margin
= V_SYNC_OFFSET
;
835 var
->hsync_len
= H_SYNC_WIDTH
;
836 var
->vsync_len
= V_SYNC_WIDTH
;
837 var
->pixclock
= PIXEL_CLOCK
;
838 var
->pixclock
/= 1000;
839 var
->pixclock
= KHZ2PICOS(var
->pixclock
);
842 var
->sync
|= FB_SYNC_HOR_HIGH_ACT
;
844 var
->sync
|= FB_SYNC_VERT_HIGH_ACT
;
851 void fb_edid_to_monspecs(unsigned char *edid
, struct fb_monspecs
*specs
)
853 unsigned char *block
;
859 if (!(edid_checksum(edid
)))
862 if (!(edid_check_header(edid
)))
865 memset(specs
, 0, sizeof(struct fb_monspecs
));
867 specs
->version
= edid
[EDID_STRUCT_VERSION
];
868 specs
->revision
= edid
[EDID_STRUCT_REVISION
];
870 DPRINTK("========================================\n");
871 DPRINTK("Display Information (EDID)\n");
872 DPRINTK("========================================\n");
873 DPRINTK(" EDID Version %d.%d\n", (int) specs
->version
,
874 (int) specs
->revision
);
876 parse_vendor_block(edid
+ ID_MANUFACTURER_NAME
, specs
);
878 block
= edid
+ DETAILED_TIMING_DESCRIPTIONS_START
;
879 for (i
= 0; i
< 4; i
++, block
+= DETAILED_TIMING_DESCRIPTION_SIZE
) {
880 if (edid_is_serial_block(block
)) {
881 copy_string(block
, specs
->serial_no
);
882 DPRINTK(" Serial Number: %s\n", specs
->serial_no
);
883 } else if (edid_is_ascii_block(block
)) {
884 copy_string(block
, specs
->ascii
);
885 DPRINTK(" ASCII Block: %s\n", specs
->ascii
);
886 } else if (edid_is_monitor_block(block
)) {
887 copy_string(block
, specs
->monitor
);
888 DPRINTK(" Monitor Name: %s\n", specs
->monitor
);
892 DPRINTK(" Display Characteristics:\n");
893 get_monspecs(edid
, specs
);
895 specs
->modedb
= fb_create_modedb(edid
, &specs
->modedb_len
);
898 * Workaround for buggy EDIDs that sets that the first
899 * detailed timing is preferred but has not detailed
902 for (i
= 0; i
< specs
->modedb_len
; i
++) {
903 if (specs
->modedb
[i
].flag
& FB_MODE_IS_DETAILED
) {
910 specs
->misc
&= ~FB_MISC_1ST_DETAIL
;
912 DPRINTK("========================================\n");
916 * VESA Generalized Timing Formula (GTF)
920 #define V_FRONTPORCH 1
922 #define H_SCALEFACTOR 20
923 #define H_BLANKSCALE 128
924 #define H_GRADIENT 600
928 struct __fb_timings
{
941 * fb_get_vblank - get vertical blank time
942 * @hfreq: horizontal freq
945 * vblank = right_margin + vsync_len + left_margin
947 * given: right_margin = 1 (V_FRONTPORCH)
952 * left_margin = --------------- - vsync_len
955 static u32
fb_get_vblank(u32 hfreq
)
959 vblank
= (hfreq
* FLYBACK
)/1000;
960 vblank
= (vblank
+ 500)/1000;
961 return (vblank
+ V_FRONTPORCH
);
965 * fb_get_hblank_by_freq - get horizontal blank time given hfreq
966 * @hfreq: horizontal freq
967 * @xres: horizontal resolution in pixels
972 * hblank = ------------------
975 * duty cycle = percent of htotal assigned to inactive display
976 * duty cycle = C - (M/Hfreq)
978 * where: C = ((offset - scale factor) * blank_scale)
979 * -------------------------------------- + scale factor
981 * M = blank_scale * gradient
984 static u32
fb_get_hblank_by_hfreq(u32 hfreq
, u32 xres
)
986 u32 c_val
, m_val
, duty_cycle
, hblank
;
988 c_val
= (((H_OFFSET
- H_SCALEFACTOR
) * H_BLANKSCALE
)/256 +
989 H_SCALEFACTOR
) * 1000;
990 m_val
= (H_BLANKSCALE
* H_GRADIENT
)/256;
991 m_val
= (m_val
* 1000000)/hfreq
;
992 duty_cycle
= c_val
- m_val
;
993 hblank
= (xres
* duty_cycle
)/(100000 - duty_cycle
);
998 * fb_get_hblank_by_dclk - get horizontal blank time given pixelclock
999 * @dclk: pixelclock in Hz
1000 * @xres: horizontal resolution in pixels
1005 * hblank = ------------------
1008 * duty cycle = percent of htotal assigned to inactive display
1009 * duty cycle = C - (M * h_period)
1011 * where: h_period = SQRT(100 - C + (0.4 * xres * M)/dclk) + C - 100
1012 * -----------------------------------------------
1018 static u32
fb_get_hblank_by_dclk(u32 dclk
, u32 xres
)
1020 u32 duty_cycle
, h_period
, hblank
;
1023 h_period
= 100 - C_VAL
;
1024 h_period
*= h_period
;
1025 h_period
+= (M_VAL
* xres
* 2 * 1000)/(5 * dclk
);
1028 h_period
= int_sqrt(h_period
);
1029 h_period
-= (100 - C_VAL
) * 100;
1031 h_period
/= 2 * M_VAL
;
1033 duty_cycle
= C_VAL
* 1000 - (M_VAL
* h_period
)/100;
1034 hblank
= (xres
* duty_cycle
)/(100000 - duty_cycle
) + 8;
1040 * fb_get_hfreq - estimate hsync
1041 * @vfreq: vertical refresh rate
1042 * @yres: vertical resolution
1046 * (yres + front_port) * vfreq * 1000000
1047 * hfreq = -------------------------------------
1048 * (1000000 - (vfreq * FLYBACK)
1052 static u32
fb_get_hfreq(u32 vfreq
, u32 yres
)
1056 divisor
= (1000000 - (vfreq
* FLYBACK
))/1000;
1057 hfreq
= (yres
+ V_FRONTPORCH
) * vfreq
* 1000;
1058 return (hfreq
/divisor
);
1061 static void fb_timings_vfreq(struct __fb_timings
*timings
)
1063 timings
->hfreq
= fb_get_hfreq(timings
->vfreq
, timings
->vactive
);
1064 timings
->vblank
= fb_get_vblank(timings
->hfreq
);
1065 timings
->vtotal
= timings
->vactive
+ timings
->vblank
;
1066 timings
->hblank
= fb_get_hblank_by_hfreq(timings
->hfreq
,
1068 timings
->htotal
= timings
->hactive
+ timings
->hblank
;
1069 timings
->dclk
= timings
->htotal
* timings
->hfreq
;
1072 static void fb_timings_hfreq(struct __fb_timings
*timings
)
1074 timings
->vblank
= fb_get_vblank(timings
->hfreq
);
1075 timings
->vtotal
= timings
->vactive
+ timings
->vblank
;
1076 timings
->vfreq
= timings
->hfreq
/timings
->vtotal
;
1077 timings
->hblank
= fb_get_hblank_by_hfreq(timings
->hfreq
,
1079 timings
->htotal
= timings
->hactive
+ timings
->hblank
;
1080 timings
->dclk
= timings
->htotal
* timings
->hfreq
;
1083 static void fb_timings_dclk(struct __fb_timings
*timings
)
1085 timings
->hblank
= fb_get_hblank_by_dclk(timings
->dclk
,
1087 timings
->htotal
= timings
->hactive
+ timings
->hblank
;
1088 timings
->hfreq
= timings
->dclk
/timings
->htotal
;
1089 timings
->vblank
= fb_get_vblank(timings
->hfreq
);
1090 timings
->vtotal
= timings
->vactive
+ timings
->vblank
;
1091 timings
->vfreq
= timings
->hfreq
/timings
->vtotal
;
1095 * fb_get_mode - calculates video mode using VESA GTF
1096 * @flags: if: 0 - maximize vertical refresh rate
1097 * 1 - vrefresh-driven calculation;
1098 * 2 - hscan-driven calculation;
1099 * 3 - pixelclock-driven calculation;
1100 * @val: depending on @flags, ignored, vrefresh, hsync or pixelclock
1101 * @var: pointer to fb_var_screeninfo
1102 * @info: pointer to fb_info
1105 * Calculates video mode based on monitor specs using VESA GTF.
1106 * The GTF is best for VESA GTF compliant monitors but is
1107 * specifically formulated to work for older monitors as well.
1109 * If @flag==0, the function will attempt to maximize the
1110 * refresh rate. Otherwise, it will calculate timings based on
1111 * the flag and accompanying value.
1113 * If FB_IGNOREMON bit is set in @flags, monitor specs will be
1114 * ignored and @var will be filled with the calculated timings.
1116 * All calculations are based on the VESA GTF Spreadsheet
1117 * available at VESA's public ftp (http://www.vesa.org).
1120 * The timings generated by the GTF will be different from VESA
1121 * DMT. It might be a good idea to keep a table of standard
1122 * VESA modes as well. The GTF may also not work for some displays,
1123 * such as, and especially, analog TV.
1126 * A valid info->monspecs, otherwise 'safe numbers' will be used.
1128 int fb_get_mode(int flags
, u32 val
, struct fb_var_screeninfo
*var
, struct fb_info
*info
)
1130 struct __fb_timings
*timings
;
1131 u32 interlace
= 1, dscan
= 1;
1132 u32 hfmin
, hfmax
, vfmin
, vfmax
, dclkmin
, dclkmax
, err
= 0;
1135 timings
= kzalloc(sizeof(struct __fb_timings
), GFP_KERNEL
);
1141 * If monspecs are invalid, use values that are enough
1144 if (!info
|| !info
->monspecs
.hfmax
|| !info
->monspecs
.vfmax
||
1145 !info
->monspecs
.dclkmax
||
1146 info
->monspecs
.hfmax
< info
->monspecs
.hfmin
||
1147 info
->monspecs
.vfmax
< info
->monspecs
.vfmin
||
1148 info
->monspecs
.dclkmax
< info
->monspecs
.dclkmin
) {
1149 hfmin
= 29000; hfmax
= 30000;
1150 vfmin
= 60; vfmax
= 60;
1151 dclkmin
= 0; dclkmax
= 25000000;
1153 hfmin
= info
->monspecs
.hfmin
;
1154 hfmax
= info
->monspecs
.hfmax
;
1155 vfmin
= info
->monspecs
.vfmin
;
1156 vfmax
= info
->monspecs
.vfmax
;
1157 dclkmin
= info
->monspecs
.dclkmin
;
1158 dclkmax
= info
->monspecs
.dclkmax
;
1161 timings
->hactive
= var
->xres
;
1162 timings
->vactive
= var
->yres
;
1163 if (var
->vmode
& FB_VMODE_INTERLACED
) {
1164 timings
->vactive
/= 2;
1167 if (var
->vmode
& FB_VMODE_DOUBLE
) {
1168 timings
->vactive
*= 2;
1172 switch (flags
& ~FB_IGNOREMON
) {
1173 case FB_MAXTIMINGS
: /* maximize refresh rate */
1174 timings
->hfreq
= hfmax
;
1175 fb_timings_hfreq(timings
);
1176 if (timings
->vfreq
> vfmax
) {
1177 timings
->vfreq
= vfmax
;
1178 fb_timings_vfreq(timings
);
1180 if (timings
->dclk
> dclkmax
) {
1181 timings
->dclk
= dclkmax
;
1182 fb_timings_dclk(timings
);
1185 case FB_VSYNCTIMINGS
: /* vrefresh driven */
1186 timings
->vfreq
= val
;
1187 fb_timings_vfreq(timings
);
1189 case FB_HSYNCTIMINGS
: /* hsync driven */
1190 timings
->hfreq
= val
;
1191 fb_timings_hfreq(timings
);
1193 case FB_DCLKTIMINGS
: /* pixelclock driven */
1194 timings
->dclk
= PICOS2KHZ(val
) * 1000;
1195 fb_timings_dclk(timings
);
1202 if (err
|| (!(flags
& FB_IGNOREMON
) &&
1203 (timings
->vfreq
< vfmin
|| timings
->vfreq
> vfmax
||
1204 timings
->hfreq
< hfmin
|| timings
->hfreq
> hfmax
||
1205 timings
->dclk
< dclkmin
|| timings
->dclk
> dclkmax
))) {
1208 var
->pixclock
= KHZ2PICOS(timings
->dclk
/1000);
1209 var
->hsync_len
= (timings
->htotal
* 8)/100;
1210 var
->right_margin
= (timings
->hblank
/2) - var
->hsync_len
;
1211 var
->left_margin
= timings
->hblank
- var
->right_margin
-
1213 var
->vsync_len
= (3 * interlace
)/dscan
;
1214 var
->lower_margin
= (1 * interlace
)/dscan
;
1215 var
->upper_margin
= (timings
->vblank
* interlace
)/dscan
-
1216 (var
->vsync_len
+ var
->lower_margin
);
1223 int fb_parse_edid(unsigned char *edid
, struct fb_var_screeninfo
*var
)
1227 void fb_edid_to_monspecs(unsigned char *edid
, struct fb_monspecs
*specs
)
1231 void fb_destroy_modedb(struct fb_videomode
*modedb
)
1234 int fb_get_mode(int flags
, u32 val
, struct fb_var_screeninfo
*var
,
1235 struct fb_info
*info
)
1239 #endif /* CONFIG_FB_MODE_HELPERS */
1242 * fb_validate_mode - validates var against monitor capabilities
1243 * @var: pointer to fb_var_screeninfo
1244 * @info: pointer to fb_info
1247 * Validates video mode against monitor capabilities specified in
1251 * A valid info->monspecs.
1253 int fb_validate_mode(const struct fb_var_screeninfo
*var
, struct fb_info
*info
)
1255 u32 hfreq
, vfreq
, htotal
, vtotal
, pixclock
;
1256 u32 hfmin
, hfmax
, vfmin
, vfmax
, dclkmin
, dclkmax
;
1259 * If monspecs are invalid, use values that are enough
1262 if (!info
->monspecs
.hfmax
|| !info
->monspecs
.vfmax
||
1263 !info
->monspecs
.dclkmax
||
1264 info
->monspecs
.hfmax
< info
->monspecs
.hfmin
||
1265 info
->monspecs
.vfmax
< info
->monspecs
.vfmin
||
1266 info
->monspecs
.dclkmax
< info
->monspecs
.dclkmin
) {
1267 hfmin
= 29000; hfmax
= 30000;
1268 vfmin
= 60; vfmax
= 60;
1269 dclkmin
= 0; dclkmax
= 25000000;
1271 hfmin
= info
->monspecs
.hfmin
;
1272 hfmax
= info
->monspecs
.hfmax
;
1273 vfmin
= info
->monspecs
.vfmin
;
1274 vfmax
= info
->monspecs
.vfmax
;
1275 dclkmin
= info
->monspecs
.dclkmin
;
1276 dclkmax
= info
->monspecs
.dclkmax
;
1281 pixclock
= PICOS2KHZ(var
->pixclock
) * 1000;
1283 htotal
= var
->xres
+ var
->right_margin
+ var
->hsync_len
+
1285 vtotal
= var
->yres
+ var
->lower_margin
+ var
->vsync_len
+
1288 if (var
->vmode
& FB_VMODE_INTERLACED
)
1290 if (var
->vmode
& FB_VMODE_DOUBLE
)
1293 hfreq
= pixclock
/htotal
;
1294 hfreq
= (hfreq
+ 500) / 1000 * 1000;
1296 vfreq
= hfreq
/vtotal
;
1298 return (vfreq
< vfmin
|| vfreq
> vfmax
||
1299 hfreq
< hfmin
|| hfreq
> hfmax
||
1300 pixclock
< dclkmin
|| pixclock
> dclkmax
) ?
1304 #if defined(CONFIG_FIRMWARE_EDID) && defined(CONFIG_X86)
1307 * We need to ensure that the EDID block is only returned for
1308 * the primary graphics adapter.
1311 const unsigned char *fb_firmware_edid(struct device
*device
)
1313 struct pci_dev
*dev
= NULL
;
1314 struct resource
*res
= NULL
;
1315 unsigned char *edid
= NULL
;
1318 dev
= to_pci_dev(device
);
1321 res
= &dev
->resource
[PCI_ROM_RESOURCE
];
1323 if (res
&& res
->flags
& IORESOURCE_ROM_SHADOW
)
1324 edid
= edid_info
.dummy
;
1329 const unsigned char *fb_firmware_edid(struct device
*device
)
1334 EXPORT_SYMBOL(fb_firmware_edid
);
1336 EXPORT_SYMBOL(fb_parse_edid
);
1337 EXPORT_SYMBOL(fb_edid_to_monspecs
);
1338 EXPORT_SYMBOL(fb_get_mode
);
1339 EXPORT_SYMBOL(fb_validate_mode
);
1340 EXPORT_SYMBOL(fb_destroy_modedb
);