]> git.sur5r.net Git - u-boot/blob - drivers/video/video-uclass.c
video: rk3288_mipi: Combine NULL check into IS_ERR_OR_NULL()
[u-boot] / drivers / video / video-uclass.c
1 /*
2  * Copyright (c) 2015 Google, Inc
3  *
4  * SPDX-License-Identifier:     GPL-2.0+
5  */
6
7 #include <common.h>
8 #include <dm.h>
9 #include <mapmem.h>
10 #include <stdio_dev.h>
11 #include <video.h>
12 #include <video_console.h>
13 #include <dm/lists.h>
14 #include <dm/device-internal.h>
15 #include <dm/uclass-internal.h>
16 #ifdef CONFIG_SANDBOX
17 #include <asm/sdl.h>
18 #endif
19
20 /*
21  * Theory of operation:
22  *
23  * Before relocation each device is bound. The driver for each device must
24  * set the @align and @size values in struct video_uc_platdata. This
25  * information represents the requires size and alignment of the frame buffer
26  * for the device. The values can be an over-estimate but cannot be too
27  * small. The actual values will be suppled (in the same manner) by the bind()
28  * method after relocation.
29  *
30  * This information is then picked up by video_reserve() which works out how
31  * much memory is needed for all devices. This is allocated between
32  * gd->video_bottom and gd->video_top.
33  *
34  * After relocation the same process occurs. The driver supplies the same
35  * @size and @align information and this time video_post_bind() checks that
36  * the drivers does not overflow the allocated memory.
37  *
38  * The frame buffer address is actually set (to plat->base) in
39  * video_post_probe(). This function also clears the frame buffer and
40  * allocates a suitable text console device. This can then be used to write
41  * text to the video device.
42  */
43 DECLARE_GLOBAL_DATA_PTR;
44
45 void video_set_flush_dcache(struct udevice *dev, bool flush)
46 {
47         struct video_priv *priv = dev_get_uclass_priv(dev);
48
49         priv->flush_dcache = flush;
50 }
51
52 static ulong alloc_fb(struct udevice *dev, ulong *addrp)
53 {
54         struct video_uc_platdata *plat = dev_get_uclass_platdata(dev);
55         ulong base, align, size;
56
57         if (!plat->size)
58                 return 0;
59
60         align = plat->align ? plat->align : 1 << 20;
61         base = *addrp - plat->size;
62         base &= ~(align - 1);
63         plat->base = base;
64         size = *addrp - base;
65         *addrp = base;
66
67         return size;
68 }
69
70 int video_reserve(ulong *addrp)
71 {
72         struct udevice *dev;
73         ulong size;
74
75         gd->video_top = *addrp;
76         for (uclass_find_first_device(UCLASS_VIDEO, &dev);
77              dev;
78              uclass_find_next_device(&dev)) {
79                 size = alloc_fb(dev, addrp);
80                 debug("%s: Reserving %lx bytes at %lx for video device '%s'\n",
81                       __func__, size, *addrp, dev->name);
82         }
83         gd->video_bottom = *addrp;
84         debug("Video frame buffers from %lx to %lx\n", gd->video_bottom,
85               gd->video_top);
86
87         return 0;
88 }
89
90 void video_clear(struct udevice *dev)
91 {
92         struct video_priv *priv = dev_get_uclass_priv(dev);
93
94         switch (priv->bpix) {
95         case VIDEO_BPP16: {
96                 u16 *ppix = priv->fb;
97                 u16 *end = priv->fb + priv->fb_size;
98
99                 while (ppix < end)
100                         *ppix++ = priv->colour_bg;
101                 break;
102         }
103         case VIDEO_BPP32: {
104                 u32 *ppix = priv->fb;
105                 u32 *end = priv->fb + priv->fb_size;
106
107                 while (ppix < end)
108                         *ppix++ = priv->colour_bg;
109                 break;
110         }
111         default:
112                 memset(priv->fb, priv->colour_bg, priv->fb_size);
113                 break;
114         }
115 }
116
117 void video_set_default_colors(struct video_priv *priv)
118 {
119 #ifdef CONFIG_SYS_WHITE_ON_BLACK
120         /* White is used when switching to bold, use light gray here */
121         priv->fg_col_idx = VID_LIGHT_GRAY;
122         priv->colour_fg = vid_console_color(priv, VID_LIGHT_GRAY);
123         priv->colour_bg = vid_console_color(priv, VID_BLACK);
124 #else
125         priv->fg_col_idx = VID_BLACK;
126         priv->colour_fg = vid_console_color(priv, VID_BLACK);
127         priv->colour_bg = vid_console_color(priv, VID_WHITE);
128 #endif
129 }
130
131 /* Flush video activity to the caches */
132 void video_sync(struct udevice *vid)
133 {
134         /*
135          * flush_dcache_range() is declared in common.h but it seems that some
136          * architectures do not actually implement it. Is there a way to find
137          * out whether it exists? For now, ARM is safe.
138          */
139 #if defined(CONFIG_ARM) && !defined(CONFIG_SYS_DCACHE_OFF)
140         struct video_priv *priv = dev_get_uclass_priv(vid);
141
142         if (priv->flush_dcache) {
143                 flush_dcache_range((ulong)priv->fb,
144                                    ALIGN((ulong)priv->fb + priv->fb_size,
145                                          CONFIG_SYS_CACHELINE_SIZE));
146         }
147 #elif defined(CONFIG_VIDEO_SANDBOX_SDL)
148         struct video_priv *priv = dev_get_uclass_priv(vid);
149         static ulong last_sync;
150
151         if (get_timer(last_sync) > 10) {
152                 sandbox_sdl_sync(priv->fb);
153                 last_sync = get_timer(0);
154         }
155 #endif
156 }
157
158 void video_sync_all(void)
159 {
160         struct udevice *dev;
161
162         for (uclass_find_first_device(UCLASS_VIDEO, &dev);
163              dev;
164              uclass_find_next_device(&dev)) {
165                 if (device_active(dev))
166                         video_sync(dev);
167         }
168 }
169
170 int video_get_xsize(struct udevice *dev)
171 {
172         struct video_priv *priv = dev_get_uclass_priv(dev);
173
174         return priv->xsize;
175 }
176
177 int video_get_ysize(struct udevice *dev)
178 {
179         struct video_priv *priv = dev_get_uclass_priv(dev);
180
181         return priv->ysize;
182 }
183
184 /* Set up the colour map */
185 static int video_pre_probe(struct udevice *dev)
186 {
187         struct video_priv *priv = dev_get_uclass_priv(dev);
188
189         priv->cmap = calloc(256, sizeof(ushort));
190         if (!priv->cmap)
191                 return -ENOMEM;
192
193         return 0;
194 }
195
196 static int video_pre_remove(struct udevice *dev)
197 {
198         struct video_priv *priv = dev_get_uclass_priv(dev);
199
200         free(priv->cmap);
201
202         return 0;
203 }
204
205 /* Set up the display ready for use */
206 static int video_post_probe(struct udevice *dev)
207 {
208         struct video_uc_platdata *plat = dev_get_uclass_platdata(dev);
209         struct video_priv *priv = dev_get_uclass_priv(dev);
210         char name[30], drv[15], *str;
211         const char *drv_name = drv;
212         struct udevice *cons;
213         int ret;
214
215         /* Set up the line and display size */
216         priv->fb = map_sysmem(plat->base, plat->size);
217         priv->line_length = priv->xsize * VNBYTES(priv->bpix);
218         priv->fb_size = priv->line_length * priv->ysize;
219
220         /* Set up colors  */
221         video_set_default_colors(priv);
222
223         if (!CONFIG_IS_ENABLED(NO_FB_CLEAR))
224                 video_clear(dev);
225
226         /*
227          * Create a text console device. For now we always do this, although
228          * it might be useful to support only bitmap drawing on the device
229          * for boards that don't need to display text. We create a TrueType
230          * console if enabled, a rotated console if the video driver requests
231          * it, otherwise a normal console.
232          *
233          * The console can be override by setting vidconsole_drv_name before
234          * probing this video driver, or in the probe() method.
235          *
236          * TrueType does not support rotation at present so fall back to the
237          * rotated console in that case.
238          */
239         if (!priv->rot && IS_ENABLED(CONFIG_CONSOLE_TRUETYPE)) {
240                 snprintf(name, sizeof(name), "%s.vidconsole_tt", dev->name);
241                 strcpy(drv, "vidconsole_tt");
242         } else {
243                 snprintf(name, sizeof(name), "%s.vidconsole%d", dev->name,
244                          priv->rot);
245                 snprintf(drv, sizeof(drv), "vidconsole%d", priv->rot);
246         }
247
248         str = strdup(name);
249         if (!str)
250                 return -ENOMEM;
251         if (priv->vidconsole_drv_name)
252                 drv_name = priv->vidconsole_drv_name;
253         ret = device_bind_driver(dev, drv_name, str, &cons);
254         if (ret) {
255                 debug("%s: Cannot bind console driver\n", __func__);
256                 return ret;
257         }
258
259         ret = device_probe(cons);
260         if (ret) {
261                 debug("%s: Cannot probe console driver\n", __func__);
262                 return ret;
263         }
264
265         return 0;
266 };
267
268 /* Post-relocation, allocate memory for the frame buffer */
269 static int video_post_bind(struct udevice *dev)
270 {
271         ulong addr = gd->video_top;
272         ulong size;
273
274         /* Before relocation there is nothing to do here */
275         if ((!gd->flags & GD_FLG_RELOC))
276                 return 0;
277         size = alloc_fb(dev, &addr);
278         if (addr < gd->video_bottom) {
279                 /* Device tree node may need the 'u-boot,dm-pre-reloc' tag */
280                 printf("Video device '%s' cannot allocate frame buffer memory -ensure the device is set up before relocation\n",
281                        dev->name);
282                 return -ENOSPC;
283         }
284         debug("%s: Claiming %lx bytes at %lx for video device '%s'\n",
285               __func__, size, addr, dev->name);
286         gd->video_bottom = addr;
287
288         return 0;
289 }
290
291 UCLASS_DRIVER(video) = {
292         .id             = UCLASS_VIDEO,
293         .name           = "video",
294         .flags          = DM_UC_FLAG_SEQ_ALIAS,
295         .post_bind      = video_post_bind,
296         .pre_probe      = video_pre_probe,
297         .post_probe     = video_post_probe,
298         .pre_remove     = video_pre_remove,
299         .per_device_auto_alloc_size     = sizeof(struct video_priv),
300         .per_device_platdata_auto_alloc_size = sizeof(struct video_uc_platdata),
301 };