1 | /* |
2 | * linux/drivers/video/fbcvt.c - VESA(TM) Coordinated Video Timings |
3 | * |
4 | * Copyright (C) 2005 Antonino Daplas <adaplas@pol.net> |
5 | * |
6 | * Based from the VESA(TM) Coordinated Video Timing Generator by |
7 | * Graham Loveridge April 9, 2003 available at |
8 | * http://www.elo.utfsm.cl/~elo212/docs/CVTd6r1.xls |
9 | * |
10 | * This file is subject to the terms and conditions of the GNU General Public |
11 | * License. See the file COPYING in the main directory of this archive |
12 | * for more details. |
13 | * |
14 | */ |
15 | #include <linux/fb.h> |
16 | #include <linux/slab.h> |
17 | |
18 | #define FB_CVT_CELLSIZE 8 |
19 | #define FB_CVT_GTF_C 40 |
20 | #define FB_CVT_GTF_J 20 |
21 | #define FB_CVT_GTF_K 128 |
22 | #define FB_CVT_GTF_M 600 |
23 | #define FB_CVT_MIN_VSYNC_BP 550 |
24 | #define FB_CVT_MIN_VPORCH 3 |
25 | #define FB_CVT_MIN_BPORCH 6 |
26 | |
27 | #define FB_CVT_RB_MIN_VBLANK 460 |
28 | #define FB_CVT_RB_HBLANK 160 |
29 | #define FB_CVT_RB_V_FPORCH 3 |
30 | |
31 | #define FB_CVT_FLAG_REDUCED_BLANK 1 |
32 | #define FB_CVT_FLAG_MARGINS 2 |
33 | #define FB_CVT_FLAG_INTERLACED 4 |
34 | |
35 | struct fb_cvt_data { |
36 | u32 xres; |
37 | u32 yres; |
38 | u32 refresh; |
39 | u32 f_refresh; |
40 | u32 pixclock; |
41 | u32 hperiod; |
42 | u32 hblank; |
43 | u32 hfreq; |
44 | u32 htotal; |
45 | u32 vtotal; |
46 | u32 vsync; |
47 | u32 hsync; |
48 | u32 h_front_porch; |
49 | u32 h_back_porch; |
50 | u32 v_front_porch; |
51 | u32 v_back_porch; |
52 | u32 h_margin; |
53 | u32 v_margin; |
54 | u32 interlace; |
55 | u32 aspect_ratio; |
56 | u32 active_pixels; |
57 | u32 flags; |
58 | u32 status; |
59 | }; |
60 | |
61 | static const unsigned char fb_cvt_vbi_tab[] = { |
62 | 4, /* 4:3 */ |
63 | 5, /* 16:9 */ |
64 | 6, /* 16:10 */ |
65 | 7, /* 5:4 */ |
66 | 7, /* 15:9 */ |
67 | 8, /* reserved */ |
68 | 9, /* reserved */ |
69 | 10 /* custom */ |
70 | }; |
71 | |
72 | /* returns hperiod * 1000 */ |
73 | static u32 fb_cvt_hperiod(struct fb_cvt_data *cvt) |
74 | { |
75 | u32 num = 1000000000/cvt->f_refresh; |
76 | u32 den; |
77 | |
78 | if (cvt->flags & FB_CVT_FLAG_REDUCED_BLANK) { |
79 | num -= FB_CVT_RB_MIN_VBLANK * 1000; |
80 | den = 2 * (cvt->yres/cvt->interlace + 2 * cvt->v_margin); |
81 | } else { |
82 | num -= FB_CVT_MIN_VSYNC_BP * 1000; |
83 | den = 2 * (cvt->yres/cvt->interlace + cvt->v_margin * 2 |
84 | + FB_CVT_MIN_VPORCH + cvt->interlace/2); |
85 | } |
86 | |
87 | return 2 * (num/den); |
88 | } |
89 | |
90 | /* returns ideal duty cycle * 1000 */ |
91 | static u32 fb_cvt_ideal_duty_cycle(struct fb_cvt_data *cvt) |
92 | { |
93 | u32 c_prime = (FB_CVT_GTF_C - FB_CVT_GTF_J) * |
94 | (FB_CVT_GTF_K) + 256 * FB_CVT_GTF_J; |
95 | u32 m_prime = (FB_CVT_GTF_K * FB_CVT_GTF_M); |
96 | u32 h_period_est = cvt->hperiod; |
97 | |
98 | return (1000 * c_prime - ((m_prime * h_period_est)/1000))/256; |
99 | } |
100 | |
101 | static u32 fb_cvt_hblank(struct fb_cvt_data *cvt) |
102 | { |
103 | u32 hblank = 0; |
104 | |
105 | if (cvt->flags & FB_CVT_FLAG_REDUCED_BLANK) |
106 | hblank = FB_CVT_RB_HBLANK; |
107 | else { |
108 | u32 ideal_duty_cycle = fb_cvt_ideal_duty_cycle(cvt); |
109 | u32 active_pixels = cvt->active_pixels; |
110 | |
111 | if (ideal_duty_cycle < 20000) |
112 | hblank = (active_pixels * 20000)/ |
113 | (100000 - 20000); |
114 | else { |
115 | hblank = (active_pixels * ideal_duty_cycle)/ |
116 | (100000 - ideal_duty_cycle); |
117 | } |
118 | } |
119 | |
120 | hblank &= ~((2 * FB_CVT_CELLSIZE) - 1); |
121 | |
122 | return hblank; |
123 | } |
124 | |
125 | static u32 fb_cvt_hsync(struct fb_cvt_data *cvt) |
126 | { |
127 | u32 hsync; |
128 | |
129 | if (cvt->flags & FB_CVT_FLAG_REDUCED_BLANK) |
130 | hsync = 32; |
131 | else |
132 | hsync = (FB_CVT_CELLSIZE * cvt->htotal)/100; |
133 | |
134 | hsync &= ~(FB_CVT_CELLSIZE - 1); |
135 | return hsync; |
136 | } |
137 | |
138 | static u32 fb_cvt_vbi_lines(struct fb_cvt_data *cvt) |
139 | { |
140 | u32 vbi_lines, min_vbi_lines, act_vbi_lines; |
141 | |
142 | if (cvt->flags & FB_CVT_FLAG_REDUCED_BLANK) { |
143 | vbi_lines = (1000 * FB_CVT_RB_MIN_VBLANK)/cvt->hperiod + 1; |
144 | min_vbi_lines = FB_CVT_RB_V_FPORCH + cvt->vsync + |
145 | FB_CVT_MIN_BPORCH; |
146 | |
147 | } else { |
148 | vbi_lines = (FB_CVT_MIN_VSYNC_BP * 1000)/cvt->hperiod + 1 + |
149 | FB_CVT_MIN_VPORCH; |
150 | min_vbi_lines = cvt->vsync + FB_CVT_MIN_BPORCH + |
151 | FB_CVT_MIN_VPORCH; |
152 | } |
153 | |
154 | if (vbi_lines < min_vbi_lines) |
155 | act_vbi_lines = min_vbi_lines; |
156 | else |
157 | act_vbi_lines = vbi_lines; |
158 | |
159 | return act_vbi_lines; |
160 | } |
161 | |
162 | static u32 fb_cvt_vtotal(struct fb_cvt_data *cvt) |
163 | { |
164 | u32 vtotal = cvt->yres/cvt->interlace; |
165 | |
166 | vtotal += 2 * cvt->v_margin + cvt->interlace/2 + fb_cvt_vbi_lines(cvt); |
167 | vtotal |= cvt->interlace/2; |
168 | |
169 | return vtotal; |
170 | } |
171 | |
172 | static u32 fb_cvt_pixclock(struct fb_cvt_data *cvt) |
173 | { |
174 | u32 pixclock; |
175 | |
176 | if (cvt->flags & FB_CVT_FLAG_REDUCED_BLANK) |
177 | pixclock = (cvt->f_refresh * cvt->vtotal * cvt->htotal)/1000; |
178 | else |
179 | pixclock = (cvt->htotal * 1000000)/cvt->hperiod; |
180 | |
181 | pixclock /= 250; |
182 | pixclock *= 250; |
183 | pixclock *= 1000; |
184 | |
185 | return pixclock; |
186 | } |
187 | |
188 | static u32 fb_cvt_aspect_ratio(struct fb_cvt_data *cvt) |
189 | { |
190 | u32 xres = cvt->xres; |
191 | u32 yres = cvt->yres; |
192 | u32 aspect = -1; |
193 | |
194 | if (xres == (yres * 4)/3 && !((yres * 4) % 3)) |
195 | aspect = 0; |
196 | else if (xres == (yres * 16)/9 && !((yres * 16) % 9)) |
197 | aspect = 1; |
198 | else if (xres == (yres * 16)/10 && !((yres * 16) % 10)) |
199 | aspect = 2; |
200 | else if (xres == (yres * 5)/4 && !((yres * 5) % 4)) |
201 | aspect = 3; |
202 | else if (xres == (yres * 15)/9 && !((yres * 15) % 9)) |
203 | aspect = 4; |
204 | else { |
205 | printk(KERN_INFO "fbcvt: Aspect ratio not CVT " |
206 | "standard\n" ); |
207 | aspect = 7; |
208 | cvt->status = 1; |
209 | } |
210 | |
211 | return aspect; |
212 | } |
213 | |
214 | static void fb_cvt_print_name(struct fb_cvt_data *cvt) |
215 | { |
216 | u32 pixcount, pixcount_mod; |
217 | int size = 256; |
218 | int off = 0; |
219 | u8 *buf; |
220 | |
221 | buf = kzalloc(size, GFP_KERNEL); |
222 | if (!buf) |
223 | return; |
224 | |
225 | pixcount = (cvt->xres * (cvt->yres/cvt->interlace))/1000000; |
226 | pixcount_mod = (cvt->xres * (cvt->yres/cvt->interlace)) % 1000000; |
227 | pixcount_mod /= 1000; |
228 | |
229 | off += scnprintf(buf: buf + off, size: size - off, fmt: "fbcvt: %dx%d@%d: CVT Name - " , |
230 | cvt->xres, cvt->yres, cvt->refresh); |
231 | |
232 | if (cvt->status) { |
233 | off += scnprintf(buf: buf + off, size: size - off, |
234 | fmt: "Not a CVT standard - %d.%03d Mega Pixel Image\n" , |
235 | pixcount, pixcount_mod); |
236 | } else { |
237 | if (pixcount) |
238 | off += scnprintf(buf: buf + off, size: size - off, fmt: "%d" , pixcount); |
239 | |
240 | off += scnprintf(buf: buf + off, size: size - off, fmt: ".%03dM" , pixcount_mod); |
241 | |
242 | if (cvt->aspect_ratio == 0) |
243 | off += scnprintf(buf: buf + off, size: size - off, fmt: "3" ); |
244 | else if (cvt->aspect_ratio == 3) |
245 | off += scnprintf(buf: buf + off, size: size - off, fmt: "4" ); |
246 | else if (cvt->aspect_ratio == 1 || cvt->aspect_ratio == 4) |
247 | off += scnprintf(buf: buf + off, size: size - off, fmt: "9" ); |
248 | else if (cvt->aspect_ratio == 2) |
249 | off += scnprintf(buf: buf + off, size: size - off, fmt: "A" ); |
250 | |
251 | if (cvt->flags & FB_CVT_FLAG_REDUCED_BLANK) |
252 | off += scnprintf(buf: buf + off, size: size - off, fmt: "-R" ); |
253 | } |
254 | |
255 | printk(KERN_INFO "%s\n" , buf); |
256 | kfree(objp: buf); |
257 | } |
258 | |
259 | static void fb_cvt_convert_to_mode(struct fb_cvt_data *cvt, |
260 | struct fb_videomode *mode) |
261 | { |
262 | mode->refresh = cvt->f_refresh; |
263 | mode->pixclock = KHZ2PICOS(cvt->pixclock/1000); |
264 | mode->left_margin = cvt->h_back_porch; |
265 | mode->right_margin = cvt->h_front_porch; |
266 | mode->hsync_len = cvt->hsync; |
267 | mode->upper_margin = cvt->v_back_porch; |
268 | mode->lower_margin = cvt->v_front_porch; |
269 | mode->vsync_len = cvt->vsync; |
270 | |
271 | mode->sync &= ~(FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT); |
272 | |
273 | if (cvt->flags & FB_CVT_FLAG_REDUCED_BLANK) |
274 | mode->sync |= FB_SYNC_HOR_HIGH_ACT; |
275 | else |
276 | mode->sync |= FB_SYNC_VERT_HIGH_ACT; |
277 | } |
278 | |
279 | /* |
280 | * fb_find_mode_cvt - calculate mode using VESA(TM) CVT |
281 | * @mode: pointer to fb_videomode; xres, yres, refresh and vmode must be |
282 | * pre-filled with the desired values |
283 | * @margins: add margin to calculation (1.8% of xres and yres) |
284 | * @rb: compute with reduced blanking (for flatpanels) |
285 | * |
286 | * RETURNS: |
287 | * 0 for success |
288 | * @mode is filled with computed values. If interlaced, the refresh field |
289 | * will be filled with the field rate (2x the frame rate) |
290 | * |
291 | * DESCRIPTION: |
292 | * Computes video timings using VESA(TM) Coordinated Video Timings |
293 | */ |
294 | int fb_find_mode_cvt(struct fb_videomode *mode, int margins, int rb) |
295 | { |
296 | struct fb_cvt_data cvt; |
297 | |
298 | memset(&cvt, 0, sizeof(cvt)); |
299 | |
300 | if (margins) |
301 | cvt.flags |= FB_CVT_FLAG_MARGINS; |
302 | |
303 | if (rb) |
304 | cvt.flags |= FB_CVT_FLAG_REDUCED_BLANK; |
305 | |
306 | if (mode->vmode & FB_VMODE_INTERLACED) |
307 | cvt.flags |= FB_CVT_FLAG_INTERLACED; |
308 | |
309 | cvt.xres = mode->xres; |
310 | cvt.yres = mode->yres; |
311 | cvt.refresh = mode->refresh; |
312 | cvt.f_refresh = cvt.refresh; |
313 | cvt.interlace = 1; |
314 | |
315 | if (!cvt.xres || !cvt.yres || !cvt.refresh) { |
316 | printk(KERN_INFO "fbcvt: Invalid input parameters\n" ); |
317 | return 1; |
318 | } |
319 | |
320 | if (!(cvt.refresh == 50 || cvt.refresh == 60 || cvt.refresh == 70 || |
321 | cvt.refresh == 85)) { |
322 | printk(KERN_INFO "fbcvt: Refresh rate not CVT " |
323 | "standard\n" ); |
324 | cvt.status = 1; |
325 | } |
326 | |
327 | cvt.xres &= ~(FB_CVT_CELLSIZE - 1); |
328 | |
329 | if (cvt.flags & FB_CVT_FLAG_INTERLACED) { |
330 | cvt.interlace = 2; |
331 | cvt.f_refresh *= 2; |
332 | } |
333 | |
334 | if (cvt.flags & FB_CVT_FLAG_REDUCED_BLANK) { |
335 | if (cvt.refresh != 60) { |
336 | printk(KERN_INFO "fbcvt: 60Hz refresh rate " |
337 | "advised for reduced blanking\n" ); |
338 | cvt.status = 1; |
339 | } |
340 | } |
341 | |
342 | if (cvt.flags & FB_CVT_FLAG_MARGINS) { |
343 | cvt.h_margin = (cvt.xres * 18)/1000; |
344 | cvt.h_margin &= ~(FB_CVT_CELLSIZE - 1); |
345 | cvt.v_margin = ((cvt.yres/cvt.interlace)* 18)/1000; |
346 | } |
347 | |
348 | cvt.aspect_ratio = fb_cvt_aspect_ratio(cvt: &cvt); |
349 | cvt.active_pixels = cvt.xres + 2 * cvt.h_margin; |
350 | cvt.hperiod = fb_cvt_hperiod(cvt: &cvt); |
351 | cvt.vsync = fb_cvt_vbi_tab[cvt.aspect_ratio]; |
352 | cvt.vtotal = fb_cvt_vtotal(cvt: &cvt); |
353 | cvt.hblank = fb_cvt_hblank(cvt: &cvt); |
354 | cvt.htotal = cvt.active_pixels + cvt.hblank; |
355 | cvt.hsync = fb_cvt_hsync(cvt: &cvt); |
356 | cvt.pixclock = fb_cvt_pixclock(cvt: &cvt); |
357 | cvt.hfreq = cvt.pixclock/cvt.htotal; |
358 | cvt.h_back_porch = cvt.hblank/2 + cvt.h_margin; |
359 | cvt.h_front_porch = cvt.hblank - cvt.hsync - cvt.h_back_porch + |
360 | 2 * cvt.h_margin; |
361 | cvt.v_front_porch = 3 + cvt.v_margin; |
362 | cvt.v_back_porch = cvt.vtotal - cvt.yres/cvt.interlace - |
363 | cvt.v_front_porch - cvt.vsync; |
364 | fb_cvt_print_name(cvt: &cvt); |
365 | fb_cvt_convert_to_mode(cvt: &cvt, mode); |
366 | |
367 | return 0; |
368 | } |
369 | |