1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * (C) Copyright 2004
4 * Pierre Aubert, Staubli Faverges , <p.aubert@staubli.com>
5 * Copyright 2011 Freescale Semiconductor, Inc.
6 */
7
8 /************************************************************************
9 Get Parameters for the video mode:
10 The default video mode can be defined in CONFIG_SYS_DEFAULT_VIDEO_MODE.
11 If undefined, default video mode is set to 0x301
12 Parameters can be set via the variable "videomode" in the environment.
13 2 diferent ways are possible:
14 "videomode=301" - 301 is a hexadecimal number describing the VESA
15 mode. Following modes are implemented:
16
17 Colors 640x480 800x600 1024x768 1152x864 1280x1024
18 --------+---------------------------------------------
19 8 bits | 0x301 0x303 0x305 0x161 0x307
20 15 bits | 0x310 0x313 0x316 0x162 0x319
21 16 bits | 0x311 0x314 0x317 0x163 0x31A
22 24 bits | 0x312 0x315 0x318 ? 0x31B
23 --------+---------------------------------------------
24 "videomode=bootargs"
25 - the parameters are parsed from the bootargs.
26 The format is "NAME:VALUE,NAME:VALUE" etc.
27 Ex.:
28 "bootargs=video=ctfb:x:800,y:600,depth:16,pclk:25000"
29 Parameters not included in the list will be taken from
30 the default mode, which is one of the following:
31 mode:0 640x480x24
32 mode:1 800x600x16
33 mode:2 1024x768x8
34 mode:3 960x720x24
35 mode:4 1152x864x16
36 mode:5 1280x1024x8
37
38 if "mode" is not provided within the parameter list,
39 mode:0 is assumed.
40 Following parameters are supported:
41 x xres = visible resolution horizontal
42 y yres = visible resolution vertical
43 pclk pixelclocks in pico sec
44 le left_marging time from sync to picture in pixelclocks
45 ri right_marging time from picture to sync in pixelclocks
46 up upper_margin time from sync to picture
47 lo lower_margin
48 hs hsync_len length of horizontal sync
49 vs vsync_len length of vertical sync
50 sync see FB_SYNC_*
51 vmode see FB_VMODE_*
52 depth Color depth in bits per pixel
53 All other parameters in the variable bootargs are ignored.
54 It is also possible to set the parameters direct in the
55 variable "videomode", or in another variable i.e.
56 "myvideo" and setting the variable "videomode=myvideo"..
57 ****************************************************************************/
58
59 #include <common.h>
60 #include <edid.h>
61 #include <env.h>
62 #include <errno.h>
63 #include <linux/ctype.h>
64
65 #include "videomodes.h"
66
67 const struct ctfb_vesa_modes vesa_modes[VESA_MODES_COUNT] = {
68 {0x301, RES_MODE_640x480, 8},
69 {0x310, RES_MODE_640x480, 15},
70 {0x311, RES_MODE_640x480, 16},
71 {0x312, RES_MODE_640x480, 24},
72 {0x303, RES_MODE_800x600, 8},
73 {0x313, RES_MODE_800x600, 15},
74 {0x314, RES_MODE_800x600, 16},
75 {0x315, RES_MODE_800x600, 24},
76 {0x305, RES_MODE_1024x768, 8},
77 {0x316, RES_MODE_1024x768, 15},
78 {0x317, RES_MODE_1024x768, 16},
79 {0x318, RES_MODE_1024x768, 24},
80 {0x161, RES_MODE_1152x864, 8},
81 {0x162, RES_MODE_1152x864, 15},
82 {0x163, RES_MODE_1152x864, 16},
83 {0x307, RES_MODE_1280x1024, 8},
84 {0x319, RES_MODE_1280x1024, 15},
85 {0x31A, RES_MODE_1280x1024, 16},
86 {0x31B, RES_MODE_1280x1024, 24},
87 };
88 const struct ctfb_res_modes res_mode_init[RES_MODES_COUNT] = {
89 /* x y hz pixclk ps/kHz le ri up lo hs vs s vmode */
90 #ifndef CONFIG_VIDEO_STD_TIMINGS
91 { 640, 480, 60, 39721, 25180, 40, 24, 32, 11, 96, 2, 0, FB_VMODE_NONINTERLACED},
92 { 800, 600, 60, 27778, 36000, 64, 24, 22, 1, 72, 2, 0, FB_VMODE_NONINTERLACED},
93 {1024, 768, 60, 15384, 65000, 168, 8, 29, 3, 144, 4, 0, FB_VMODE_NONINTERLACED},
94 { 960, 720, 80, 13100, 76335, 160, 40, 32, 8, 80, 4, 0, FB_VMODE_NONINTERLACED},
95 {1152, 864, 60, 12004, 83300, 200, 64, 32, 16, 80, 4, 0, FB_VMODE_NONINTERLACED},
96 {1280, 1024, 60, 9090, 110000, 200, 48, 26, 1, 184, 3, 0, FB_VMODE_NONINTERLACED},
97 #else
98 { 640, 480, 60, 39683, 25200, 48, 16, 33, 10, 96, 2, 0, FB_VMODE_NONINTERLACED},
99 { 800, 600, 60, 25000, 40000, 88, 40, 23, 1, 128, 4, FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED},
100 {1024, 768, 60, 15384, 65000, 160, 24, 29, 3, 136, 6, 0, FB_VMODE_NONINTERLACED},
101 { 960, 720, 75, 13468, 74250, 176, 72, 27, 1, 112, 2, 0, FB_VMODE_NONINTERLACED},
102 {1152, 864, 75, 9259, 108000, 256, 64, 32, 1, 128, 3, FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED},
103 {1280, 1024, 60, 9259, 108000, 248, 48, 38, 1, 112, 3, FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED},
104 #endif
105 {1280, 720, 60, 13468, 74250, 220, 110, 20, 5, 40, 5, FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED},
106 {1360, 768, 60, 11696, 85500, 256, 64, 17, 3, 112, 7, 0, FB_VMODE_NONINTERLACED},
107 {1920, 1080, 60, 6734, 148500, 148, 88, 36, 4, 44, 5, FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED},
108 {1920, 1200, 60, 6494, 154000, 80, 48, 26, 3, 32, 6, FB_SYNC_HOR_HIGH_ACT, FB_VMODE_NONINTERLACED},
109 };
110
111 /************************************************************************
112 * Get Parameters for the video mode:
113 */
114 /*********************************************************************
115 * returns the length to the next seperator
116 */
117 static int
video_get_param_len(const char * start,char sep)118 video_get_param_len(const char *start, char sep)
119 {
120 int i = 0;
121 while ((*start != 0) && (*start != sep)) {
122 start++;
123 i++;
124 }
125 return i;
126 }
127
128 static int
video_search_param(char * start,char * param)129 video_search_param (char *start, char *param)
130 {
131 int len, totallen, i;
132 char *p = start;
133 len = strlen (param);
134 totallen = len + strlen (start);
135 for (i = 0; i < totallen; i++) {
136 if (strncmp (p++, param, len) == 0)
137 return (i);
138 }
139 return -1;
140 }
141
142 /***************************************************************
143 * Get parameter via the environment as it is done for the
144 * linux kernel i.e:
145 * video=ctfb:x:800,xv:1280,y:600,yv:1024,depth:16,mode:0,pclk:25000,
146 * le:56,ri:48,up:26,lo:5,hs:152,vs:2,sync:0,vmode:0,accel:0
147 *
148 * penv is a pointer to the environment, containing the string, or the name of
149 * another environment variable. It could even be the term "bootargs"
150 */
151
152 #define GET_OPTION(name,var) \
153 if(strncmp(p,name,strlen(name))==0) { \
154 val_s=p+strlen(name); \
155 var=simple_strtoul(val_s, NULL, 10); \
156 }
157
video_get_params(struct ctfb_res_modes * pPar,char * penv)158 int video_get_params (struct ctfb_res_modes *pPar, char *penv)
159 {
160 char *p, *s, *val_s;
161 int i = 0;
162 int bpp;
163 int mode;
164
165 /* first search for the environment containing the real param string */
166 s = penv;
167
168 p = env_get(s);
169 if (p)
170 s = p;
171
172 /*
173 * in case of the bootargs line, we have to start
174 * after "video=ctfb:"
175 */
176 i = video_search_param (s, "video=ctfb:");
177 if (i >= 0) {
178 s += i;
179 s += strlen ("video=ctfb:");
180 }
181 /* search for mode as a default value */
182 p = s;
183 mode = 0; /* default */
184
185 while ((i = video_get_param_len (p, ',')) != 0) {
186 GET_OPTION ("mode:", mode)
187 p += i;
188 if (*p != 0)
189 p++; /* skip ',' */
190 }
191
192 if (mode >= RES_MODES_COUNT)
193 mode = 0;
194
195 *pPar = res_mode_init[mode]; /* copy default values */
196 bpp = 24 - ((mode % 3) * 8);
197 p = s; /* restart */
198
199 while ((i = video_get_param_len (p, ',')) != 0) {
200 GET_OPTION ("x:", pPar->xres)
201 GET_OPTION ("y:", pPar->yres)
202 GET_OPTION ("refresh:", pPar->refresh)
203 GET_OPTION ("le:", pPar->left_margin)
204 GET_OPTION ("ri:", pPar->right_margin)
205 GET_OPTION ("up:", pPar->upper_margin)
206 GET_OPTION ("lo:", pPar->lower_margin)
207 GET_OPTION ("hs:", pPar->hsync_len)
208 GET_OPTION ("vs:", pPar->vsync_len)
209 GET_OPTION ("sync:", pPar->sync)
210 GET_OPTION ("vmode:", pPar->vmode)
211 GET_OPTION ("pclk:", pPar->pixclock)
212 GET_OPTION ("pclk_khz:", pPar->pixclock_khz)
213 GET_OPTION ("depth:", bpp)
214 p += i;
215 if (*p != 0)
216 p++; /* skip ',' */
217 }
218 return bpp;
219 }
220
221 /*
222 * Parse the 'video-mode' environment variable
223 *
224 * Example: "video-mode=fslfb:1280x1024-32@60,monitor=dvi". See
225 * doc/README.video for more information on how to set the variable.
226 *
227 * @xres: returned value of X-resolution
228 * @yres: returned value of Y-resolution
229 * @depth: returned value of color depth
230 * @freq: returned value of monitor frequency
231 * @options: pointer to any remaining options, or NULL
232 *
233 * Returns 1 if valid values were found, 0 otherwise
234 */
video_get_video_mode(unsigned int * xres,unsigned int * yres,unsigned int * depth,unsigned int * freq,const char ** options)235 int video_get_video_mode(unsigned int *xres, unsigned int *yres,
236 unsigned int *depth, unsigned int *freq, const char **options)
237 {
238 char *p = env_get("video-mode");
239 if (!p)
240 return 0;
241
242 /* Skip over the driver name, which we don't care about. */
243 p = strchr(p, ':');
244 if (!p)
245 return 0;
246
247 /* Get the X-resolution*/
248 while (*p && !isdigit(*p))
249 p++;
250 *xres = simple_strtoul(p, &p, 10);
251 if (!*xres)
252 return 0;
253
254 /* Get the Y-resolution */
255 while (*p && !isdigit(*p))
256 p++;
257 *yres = simple_strtoul(p, &p, 10);
258 if (!*yres)
259 return 0;
260
261 /* Get the depth */
262 while (*p && !isdigit(*p))
263 p++;
264 *depth = simple_strtoul(p, &p, 10);
265 if (!*depth)
266 return 0;
267
268 /* Get the frequency */
269 while (*p && !isdigit(*p))
270 p++;
271 *freq = simple_strtoul(p, &p, 10);
272 if (!*freq)
273 return 0;
274
275 /* Find the extra options, if any */
276 p = strchr(p, ',');
277 *options = p ? p + 1 : NULL;
278
279 return 1;
280 }
281
282 /*
283 * Parse the 'video-mode' environment variable using video_get_video_mode()
284 * and lookup the matching ctfb_res_modes in res_mode_init.
285 *
286 * @default_mode: RES_MODE_##x## define for the mode to store in mode_ret
287 * when 'video-mode' is not set or does not contain a valid mode
288 * @default_depth: depth to set when 'video-mode' is not set
289 * @mode_ret: pointer where the mode will be stored
290 * @depth_ret: pointer where the depth will be stored
291 * @options: pointer to any remaining options, or NULL
292 */
video_get_ctfb_res_modes(int default_mode,unsigned int default_depth,const struct ctfb_res_modes ** mode_ret,unsigned int * depth_ret,const char ** options)293 void video_get_ctfb_res_modes(int default_mode, unsigned int default_depth,
294 const struct ctfb_res_modes **mode_ret,
295 unsigned int *depth_ret,
296 const char **options)
297 {
298 unsigned int i, xres, yres, depth, refresh;
299
300 *mode_ret = &res_mode_init[default_mode];
301 *depth_ret = default_depth;
302 *options = NULL;
303
304 if (!video_get_video_mode(&xres, &yres, &depth, &refresh, options))
305 return;
306
307 for (i = 0; i < RES_MODES_COUNT; i++) {
308 if (res_mode_init[i].xres == xres &&
309 res_mode_init[i].yres == yres &&
310 res_mode_init[i].refresh == refresh) {
311 *mode_ret = &res_mode_init[i];
312 *depth_ret = depth;
313 return;
314 }
315 }
316
317 printf("video-mode %dx%d-%d@%d not available, falling back to %dx%d-%d@%d\n",
318 xres, yres, depth, refresh, (*mode_ret)->xres,
319 (*mode_ret)->yres, *depth_ret, (*mode_ret)->refresh);
320 }
321
322 /*
323 * Find the named string option within the ',' separated options string, and
324 * store its value in dest.
325 *
326 * @options: ',' separated options string
327 * @name: name of the option to look for
328 * @dest: destination buffer to store the value of the option in
329 * @dest_len: length of dest
330 * @def: value to store in dest if the option is not present in options
331 */
video_get_option_string(const char * options,const char * name,char * dest,int dest_len,const char * def)332 void video_get_option_string(const char *options, const char *name,
333 char *dest, int dest_len, const char *def)
334 {
335 const char *p = options;
336 const int name_len = strlen(name);
337 int i, len;
338
339 while (p && (i = video_get_param_len(p, ',')) != 0) {
340 if (strncmp(p, name, name_len) == 0 && p[name_len] == '=') {
341 len = i - (name_len + 1);
342 if (len >= dest_len)
343 len = dest_len - 1;
344 memcpy(dest, &p[name_len + 1], len);
345 dest[len] = 0;
346 return;
347 }
348 p += i;
349 if (*p != 0)
350 p++; /* skip ',' */
351 }
352 strcpy(dest, def);
353 }
354
355 /*
356 * Find the named integer option within the ',' separated options string, and
357 * return its value.
358 *
359 * @options: ',' separated options string
360 * @name: name of the option to look for
361 * @def: value to return if the option is not present in options
362 */
video_get_option_int(const char * options,const char * name,int def)363 int video_get_option_int(const char *options, const char *name, int def)
364 {
365 const char *p = options;
366 const int name_len = strlen(name);
367 int i;
368
369 while (p && (i = video_get_param_len(p, ',')) != 0) {
370 if (strncmp(p, name, name_len) == 0 && p[name_len] == '=')
371 return simple_strtoul(&p[name_len + 1], NULL, 10);
372
373 p += i;
374 if (*p != 0)
375 p++; /* skip ',' */
376 }
377 return def;
378 }
379
380 /**
381 * Convert an EDID detailed timing to a struct ctfb_res_modes
382 *
383 * @param t The EDID detailed timing to be converted
384 * @param mode Returns the converted timing
385 *
386 * @return 0 on success, or a negative errno on error
387 */
video_edid_dtd_to_ctfb_res_modes(struct edid_detailed_timing * t,struct ctfb_res_modes * mode)388 int video_edid_dtd_to_ctfb_res_modes(struct edid_detailed_timing *t,
389 struct ctfb_res_modes *mode)
390 {
391 int margin, h_total, v_total;
392
393 /* Check all timings are non 0 */
394 if (EDID_DETAILED_TIMING_PIXEL_CLOCK(*t) == 0 ||
395 EDID_DETAILED_TIMING_HORIZONTAL_ACTIVE(*t) == 0 ||
396 EDID_DETAILED_TIMING_HORIZONTAL_BLANKING(*t) == 0 ||
397 EDID_DETAILED_TIMING_VERTICAL_ACTIVE(*t) == 0 ||
398 EDID_DETAILED_TIMING_VERTICAL_BLANKING(*t) == 0 ||
399 EDID_DETAILED_TIMING_HSYNC_OFFSET(*t) == 0 ||
400 EDID_DETAILED_TIMING_VSYNC_OFFSET(*t) == 0 ||
401 /* 3d formats are not supported */
402 EDID_DETAILED_TIMING_FLAG_STEREO(*t) != 0)
403 return -EINVAL;
404
405 mode->xres = EDID_DETAILED_TIMING_HORIZONTAL_ACTIVE(*t);
406 mode->yres = EDID_DETAILED_TIMING_VERTICAL_ACTIVE(*t);
407
408 h_total = mode->xres + EDID_DETAILED_TIMING_HORIZONTAL_BLANKING(*t);
409 v_total = mode->yres + EDID_DETAILED_TIMING_VERTICAL_BLANKING(*t);
410 mode->refresh = EDID_DETAILED_TIMING_PIXEL_CLOCK(*t) /
411 (h_total * v_total);
412
413 mode->pixclock_khz = EDID_DETAILED_TIMING_PIXEL_CLOCK(*t) / 1000;
414 mode->pixclock = 1000000000L / mode->pixclock_khz;
415
416 mode->right_margin = EDID_DETAILED_TIMING_HSYNC_OFFSET(*t);
417 mode->hsync_len = EDID_DETAILED_TIMING_HSYNC_PULSE_WIDTH(*t);
418 margin = EDID_DETAILED_TIMING_HORIZONTAL_BLANKING(*t) -
419 (mode->right_margin + mode->hsync_len);
420 if (margin <= 0)
421 return -EINVAL;
422
423 mode->left_margin = margin;
424
425 mode->lower_margin = EDID_DETAILED_TIMING_VSYNC_OFFSET(*t);
426 mode->vsync_len = EDID_DETAILED_TIMING_VSYNC_PULSE_WIDTH(*t);
427 margin = EDID_DETAILED_TIMING_VERTICAL_BLANKING(*t) -
428 (mode->lower_margin + mode->vsync_len);
429 if (margin <= 0)
430 return -EINVAL;
431
432 mode->upper_margin = margin;
433
434 mode->sync = 0;
435 if (EDID_DETAILED_TIMING_FLAG_HSYNC_POLARITY(*t))
436 mode->sync |= FB_SYNC_HOR_HIGH_ACT;
437 if (EDID_DETAILED_TIMING_FLAG_VSYNC_POLARITY(*t))
438 mode->sync |= FB_SYNC_VERT_HIGH_ACT;
439
440 if (EDID_DETAILED_TIMING_FLAG_INTERLACED(*t))
441 mode->vmode = FB_VMODE_INTERLACED;
442 else
443 mode->vmode = FB_VMODE_NONINTERLACED;
444
445 return 0;
446 }
447