← Back to branch summary

~pmdj/ubuntu/trusty/qemu/2.9+applesmc+fadtv3

« back to all changes in this revision

Viewing changes to roms/u-boot/drivers/video/videomodes.c

  • Committer: Phil Dennis-Jordan
  • Date: 2017-07-21 08:03:43 UTC
  • mfrom: (1.1.1)
  • Revision ID: phil@philjordan.eu-20170721080343-2yr2vdj7713czahv
New upstream release 2.9.0.

Show diffs side-by-side

added added

removed removed

Lines of Context:
roms/u-boot/drivers/video/videomodes.c
 
1
/*
 
2
 * (C) Copyright 2004
 
3
 * Pierre Aubert, Staubli Faverges , <p.aubert@staubli.com>
 
4
 * Copyright 2011 Freescale Semiconductor, Inc.
 
5
 *
 
6
 * SPDX-License-Identifier:     GPL-2.0+
 
7
 */
 
8
 
 
9
/************************************************************************
 
10
  Get Parameters for the video mode:
 
11
  The default video mode can be defined in CONFIG_SYS_DEFAULT_VIDEO_MODE.
 
12
  If undefined, default video mode is set to 0x301
 
13
  Parameters can be set via the variable "videomode" in the environment.
 
14
  2 diferent ways are possible:
 
15
  "videomode=301"   - 301 is a hexadecimal number describing the VESA
 
16
                      mode. Following modes are implemented:
 
17
 
 
18
                      Colors    640x480 800x600 1024x768 1152x864 1280x1024
 
19
                     --------+---------------------------------------------
 
20
                      8 bits |  0x301   0x303    0x305    0x161     0x307
 
21
                     15 bits |  0x310   0x313    0x316    0x162     0x319
 
22
                     16 bits |  0x311   0x314    0x317    0x163     0x31A
 
23
                     24 bits |  0x312   0x315    0x318      ?       0x31B
 
24
                     --------+---------------------------------------------
 
25
  "videomode=bootargs"
 
26
                   - the parameters are parsed from the bootargs.
 
27
                      The format is "NAME:VALUE,NAME:VALUE" etc.
 
28
                      Ex.:
 
29
                      "bootargs=video=ctfb:x:800,y:600,depth:16,pclk:25000"
 
30
                      Parameters not included in the list will be taken from
 
31
                      the default mode, which is one of the following:
 
32
                      mode:0  640x480x24
 
33
                      mode:1  800x600x16
 
34
                      mode:2  1024x768x8
 
35
                      mode:3  960x720x24
 
36
                      mode:4  1152x864x16
 
37
                      mode:5  1280x1024x8
 
38
 
 
39
                      if "mode" is not provided within the parameter list,
 
40
                      mode:0 is assumed.
 
41
                      Following parameters are supported:
 
42
                      x       xres = visible resolution horizontal
 
43
                      y       yres = visible resolution vertical
 
44
                      pclk    pixelclocks in pico sec
 
45
                      le      left_marging time from sync to picture in pixelclocks
 
46
                      ri      right_marging time from picture to sync in pixelclocks
 
47
                      up      upper_margin time from sync to picture
 
48
                      lo      lower_margin
 
49
                      hs      hsync_len length of horizontal sync
 
50
                      vs      vsync_len length of vertical sync
 
51
                      sync    see FB_SYNC_*
 
52
                      vmode   see FB_VMODE_*
 
53
                      depth   Color depth in bits per pixel
 
54
                      All other parameters in the variable bootargs are ignored.
 
55
                      It is also possible to set the parameters direct in the
 
56
                      variable "videomode", or in another variable i.e.
 
57
                      "myvideo" and setting the variable "videomode=myvideo"..
 
58
****************************************************************************/
 
59
 
 
60
#include <common.h>
 
61
#include <linux/ctype.h>
 
62
 
 
63
#include "videomodes.h"
 
64
 
 
65
const struct ctfb_vesa_modes vesa_modes[VESA_MODES_COUNT] = {
 
66
        {0x301, RES_MODE_640x480, 8},
 
67
        {0x310, RES_MODE_640x480, 15},
 
68
        {0x311, RES_MODE_640x480, 16},
 
69
        {0x312, RES_MODE_640x480, 24},
 
70
        {0x303, RES_MODE_800x600, 8},
 
71
        {0x313, RES_MODE_800x600, 15},
 
72
        {0x314, RES_MODE_800x600, 16},
 
73
        {0x315, RES_MODE_800x600, 24},
 
74
        {0x305, RES_MODE_1024x768, 8},
 
75
        {0x316, RES_MODE_1024x768, 15},
 
76
        {0x317, RES_MODE_1024x768, 16},
 
77
        {0x318, RES_MODE_1024x768, 24},
 
78
        {0x161, RES_MODE_1152x864, 8},
 
79
        {0x162, RES_MODE_1152x864, 15},
 
80
        {0x163, RES_MODE_1152x864, 16},
 
81
        {0x307, RES_MODE_1280x1024, 8},
 
82
        {0x319, RES_MODE_1280x1024, 15},
 
83
        {0x31A, RES_MODE_1280x1024, 16},
 
84
        {0x31B, RES_MODE_1280x1024, 24},
 
85
};
 
86
const struct ctfb_res_modes res_mode_init[RES_MODES_COUNT] = {
 
87
        /* x     y pixclk   le  ri  up  lo   hs vs  s  vmode */
 
88
        {640, 480, 39721, 40, 24, 32, 11, 96, 2, 0, FB_VMODE_NONINTERLACED},
 
89
        {800, 600, 27778, 64, 24, 22, 1, 72, 2, 0, FB_VMODE_NONINTERLACED},
 
90
        {1024, 768, 15384, 168, 8, 29, 3, 144, 4, 0, FB_VMODE_NONINTERLACED},
 
91
        {960, 720, 13100, 160, 40, 32, 8, 80, 4, 0, FB_VMODE_NONINTERLACED},
 
92
        {1152, 864, 12004, 200, 64, 32, 16, 80, 4, 0, FB_VMODE_NONINTERLACED},
 
93
        {1280, 1024, 9090, 200, 48, 26, 1, 184, 3, 0, FB_VMODE_NONINTERLACED},
 
94
};
 
95
 
 
96
/************************************************************************
 
97
 * Get Parameters for the video mode:
 
98
 */
 
99
/*********************************************************************
 
100
 * returns the length to the next seperator
 
101
 */
 
102
static int
 
103
video_get_param_len (char *start, char sep)
 
104
{
 
105
        int i = 0;
 
106
        while ((*start != 0) && (*start != sep)) {
 
107
                start++;
 
108
                i++;
 
109
        }
 
110
        return i;
 
111
}
 
112
 
 
113
static int
 
114
video_search_param (char *start, char *param)
 
115
{
 
116
        int len, totallen, i;
 
117
        char *p = start;
 
118
        len = strlen (param);
 
119
        totallen = len + strlen (start);
 
120
        for (i = 0; i < totallen; i++) {
 
121
                if (strncmp (p++, param, len) == 0)
 
122
                        return (i);
 
123
        }
 
124
        return -1;
 
125
}
 
126
 
 
127
/***************************************************************
 
128
 * Get parameter via the environment as it is done for the
 
129
 * linux kernel i.e:
 
130
 * video=ctfb:x:800,xv:1280,y:600,yv:1024,depth:16,mode:0,pclk:25000,
 
131
 *       le:56,ri:48,up:26,lo:5,hs:152,vs:2,sync:0,vmode:0,accel:0
 
132
 *
 
133
 * penv is a pointer to the environment, containing the string, or the name of
 
134
 * another environment variable. It could even be the term "bootargs"
 
135
 */
 
136
 
 
137
#define GET_OPTION(name,var)                            \
 
138
        if(strncmp(p,name,strlen(name))==0) {           \
 
139
                val_s=p+strlen(name);                   \
 
140
                var=simple_strtoul(val_s, NULL, 10);    \
 
141
        }
 
142
 
 
143
int video_get_params (struct ctfb_res_modes *pPar, char *penv)
 
144
{
 
145
        char *p, *s, *val_s;
 
146
        int i = 0;
 
147
        int bpp;
 
148
        int mode;
 
149
 
 
150
        /* first search for the environment containing the real param string */
 
151
        s = penv;
 
152
 
 
153
        if ((p = getenv (s)) != NULL)
 
154
                s = p;
 
155
 
 
156
        /*
 
157
         * in case of the bootargs line, we have to start
 
158
         * after "video=ctfb:"
 
159
         */
 
160
        i = video_search_param (s, "video=ctfb:");
 
161
        if (i >= 0) {
 
162
                s += i;
 
163
                s += strlen ("video=ctfb:");
 
164
        }
 
165
        /* search for mode as a default value */
 
166
        p = s;
 
167
        mode = 0;               /* default */
 
168
 
 
169
        while ((i = video_get_param_len (p, ',')) != 0) {
 
170
                GET_OPTION ("mode:", mode)
 
171
                        p += i;
 
172
                if (*p != 0)
 
173
                        p++;    /* skip ',' */
 
174
        }
 
175
 
 
176
        if (mode >= RES_MODES_COUNT)
 
177
                mode = 0;
 
178
 
 
179
        *pPar = res_mode_init[mode];    /* copy default values */
 
180
        bpp = 24 - ((mode % 3) * 8);
 
181
        p = s;                  /* restart */
 
182
 
 
183
        while ((i = video_get_param_len (p, ',')) != 0) {
 
184
                GET_OPTION ("x:", pPar->xres)
 
185
                        GET_OPTION ("y:", pPar->yres)
 
186
                        GET_OPTION ("le:", pPar->left_margin)
 
187
                        GET_OPTION ("ri:", pPar->right_margin)
 
188
                        GET_OPTION ("up:", pPar->upper_margin)
 
189
                        GET_OPTION ("lo:", pPar->lower_margin)
 
190
                        GET_OPTION ("hs:", pPar->hsync_len)
 
191
                        GET_OPTION ("vs:", pPar->vsync_len)
 
192
                        GET_OPTION ("sync:", pPar->sync)
 
193
                        GET_OPTION ("vmode:", pPar->vmode)
 
194
                        GET_OPTION ("pclk:", pPar->pixclock)
 
195
                        GET_OPTION ("depth:", bpp)
 
196
                        p += i;
 
197
                if (*p != 0)
 
198
                        p++;    /* skip ',' */
 
199
        }
 
200
        return bpp;
 
201
}
 
202
 
 
203
/*
 
204
 * Parse the 'video-mode' environment variable
 
205
 *
 
206
 * Example: "video-mode=fslfb:1280x1024-32@60,monitor=dvi".  See
 
207
 * doc/README.video for more information on how to set the variable.
 
208
 *
 
209
 * @xres: returned value of X-resolution
 
210
 * @yres: returned value of Y-resolution
 
211
 * @depth: returned value of color depth
 
212
 * @freq: returned value of monitor frequency
 
213
 * @options: pointer to any remaining options, or NULL
 
214
 *
 
215
 * Returns 1 if valid values were found, 0 otherwise
 
216
 */
 
217
int video_get_video_mode(unsigned int *xres, unsigned int *yres,
 
218
        unsigned int *depth, unsigned int *freq, const char **options)
 
219
{
 
220
        char *p = getenv("video-mode");
 
221
        if (!p)
 
222
                return 0;
 
223
 
 
224
        /* Skip over the driver name, which we don't care about. */
 
225
        p = strchr(p, ':');
 
226
        if (!p)
 
227
                return 0;
 
228
 
 
229
        /* Get the X-resolution*/
 
230
        while (*p && !isdigit(*p))
 
231
                p++;
 
232
        *xres = simple_strtoul(p, &p, 10);
 
233
        if (!*xres)
 
234
                return 0;
 
235
 
 
236
        /* Get the Y-resolution */
 
237
        while (*p && !isdigit(*p))
 
238
                p++;
 
239
        *yres = simple_strtoul(p, &p, 10);
 
240
        if (!*yres)
 
241
                return 0;
 
242
 
 
243
        /* Get the depth */
 
244
        while (*p && !isdigit(*p))
 
245
                p++;
 
246
        *depth = simple_strtoul(p, &p, 10);
 
247
        if (!*depth)
 
248
                return 0;
 
249
 
 
250
        /* Get the frequency */
 
251
        while (*p && !isdigit(*p))
 
252
                p++;
 
253
        *freq = simple_strtoul(p, &p, 10);
 
254
        if (!*freq)
 
255
                return 0;
 
256
 
 
257
        /* Find the extra options, if any */
 
258
        p = strchr(p, ',');
 
259
        *options = p ? p + 1 : NULL;
 
260
 
 
261
        return 1;
 
262
}