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