1
2
3
4
5
6#include <common.h>
7#include <console.h>
8#include <cpu_func.h>
9#include <dm.h>
10#include <log.h>
11#include <malloc.h>
12#include <mapmem.h>
13#include <stdio_dev.h>
14#include <video.h>
15#include <video_console.h>
16#include <asm/cache.h>
17#include <dm/lists.h>
18#include <dm/device_compat.h>
19#include <dm/device-internal.h>
20#include <dm/uclass-internal.h>
21#ifdef CONFIG_SANDBOX
22#include <asm/sdl.h>
23#endif
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48DECLARE_GLOBAL_DATA_PTR;
49
50
51
52
53
54
55
56
57
58
59struct video_uc_priv {
60 ulong video_ptr;
61};
62
63void video_set_flush_dcache(struct udevice *dev, bool flush)
64{
65 struct video_priv *priv = dev_get_uclass_priv(dev);
66
67 priv->flush_dcache = flush;
68}
69
70static ulong alloc_fb(struct udevice *dev, ulong *addrp)
71{
72 struct video_uc_platdata *plat = dev_get_uclass_platdata(dev);
73 ulong base, align, size;
74
75 if (!plat->size)
76 return 0;
77
78 align = plat->align ? plat->align : 1 << 20;
79 base = *addrp - plat->size;
80 base &= ~(align - 1);
81 plat->base = base;
82 size = *addrp - base;
83 *addrp = base;
84
85 return size;
86}
87
88int video_reserve(ulong *addrp)
89{
90 struct udevice *dev;
91 ulong size;
92
93 gd->video_top = *addrp;
94 for (uclass_find_first_device(UCLASS_VIDEO, &dev);
95 dev;
96 uclass_find_next_device(&dev)) {
97 size = alloc_fb(dev, addrp);
98 debug("%s: Reserving %lx bytes at %lx for video device '%s'\n",
99 __func__, size, *addrp, dev->name);
100 }
101
102
103 if (*addrp == gd->video_top)
104 *addrp -= CONFIG_VIDEO_PCI_DEFAULT_FB_SIZE;
105
106 gd->video_bottom = *addrp;
107 gd->fb_base = *addrp;
108 debug("Video frame buffers from %lx to %lx\n", gd->video_bottom,
109 gd->video_top);
110
111 return 0;
112}
113
114int video_clear(struct udevice *dev)
115{
116 struct video_priv *priv = dev_get_uclass_priv(dev);
117 int ret;
118
119 switch (priv->bpix) {
120 case VIDEO_BPP16:
121 if (IS_ENABLED(CONFIG_VIDEO_BPP16)) {
122 u16 *ppix = priv->fb;
123 u16 *end = priv->fb + priv->fb_size;
124
125 while (ppix < end)
126 *ppix++ = priv->colour_bg;
127 break;
128 }
129 case VIDEO_BPP32:
130 if (IS_ENABLED(CONFIG_VIDEO_BPP32)) {
131 u32 *ppix = priv->fb;
132 u32 *end = priv->fb + priv->fb_size;
133
134 while (ppix < end)
135 *ppix++ = priv->colour_bg;
136 break;
137 }
138 default:
139 memset(priv->fb, priv->colour_bg, priv->fb_size);
140 break;
141 }
142 ret = video_sync_copy(dev, priv->fb, priv->fb + priv->fb_size);
143 if (ret)
144 return ret;
145
146 return video_sync(dev, false);
147}
148
149void video_set_default_colors(struct udevice *dev, bool invert)
150{
151 struct video_priv *priv = dev_get_uclass_priv(dev);
152 int fore, back;
153
154 if (CONFIG_IS_ENABLED(SYS_WHITE_ON_BLACK)) {
155
156 fore = VID_LIGHT_GRAY;
157 back = VID_BLACK;
158 } else {
159 fore = VID_BLACK;
160 back = VID_WHITE;
161 }
162 if (invert) {
163 int temp;
164
165 temp = fore;
166 fore = back;
167 back = temp;
168 }
169 priv->fg_col_idx = fore;
170 priv->bg_col_idx = back;
171 priv->colour_fg = vid_console_color(priv, fore);
172 priv->colour_bg = vid_console_color(priv, back);
173}
174
175
176int video_sync(struct udevice *vid, bool force)
177{
178 struct video_ops *ops = video_get_ops(vid);
179 int ret;
180
181 if (ops && ops->video_sync) {
182 ret = ops->video_sync(vid);
183 if (ret)
184 return ret;
185 }
186
187
188
189
190
191
192#if defined(CONFIG_ARM) && !CONFIG_IS_ENABLED(SYS_DCACHE_OFF)
193 struct video_priv *priv = dev_get_uclass_priv(vid);
194
195 if (priv->flush_dcache) {
196 flush_dcache_range((ulong)priv->fb,
197 ALIGN((ulong)priv->fb + priv->fb_size,
198 CONFIG_SYS_CACHELINE_SIZE));
199 }
200#elif defined(CONFIG_VIDEO_SANDBOX_SDL)
201 struct video_priv *priv = dev_get_uclass_priv(vid);
202 static ulong last_sync;
203
204 if (force || get_timer(last_sync) > 10) {
205 sandbox_sdl_sync(priv->fb);
206 last_sync = get_timer(0);
207 }
208#endif
209 return 0;
210}
211
212void video_sync_all(void)
213{
214 struct udevice *dev;
215 int ret;
216
217 for (uclass_find_first_device(UCLASS_VIDEO, &dev);
218 dev;
219 uclass_find_next_device(&dev)) {
220 if (device_active(dev)) {
221 ret = video_sync(dev, true);
222 if (ret)
223 dev_dbg(dev, "Video sync failed\n");
224 }
225 }
226}
227
228int video_get_xsize(struct udevice *dev)
229{
230 struct video_priv *priv = dev_get_uclass_priv(dev);
231
232 return priv->xsize;
233}
234
235int video_get_ysize(struct udevice *dev)
236{
237 struct video_priv *priv = dev_get_uclass_priv(dev);
238
239 return priv->ysize;
240}
241
242#ifdef CONFIG_VIDEO_COPY
243int video_sync_copy(struct udevice *dev, void *from, void *to)
244{
245 struct video_priv *priv = dev_get_uclass_priv(dev);
246
247 if (priv->copy_fb) {
248 long offset, size;
249
250
251 if ((ulong)to > (ulong)from) {
252 size = to - from;
253 offset = from - priv->fb;
254 } else {
255 size = from - to;
256 offset = to - priv->fb;
257 }
258
259
260
261
262
263 if (offset < -priv->fb_size || offset > 2 * priv->fb_size) {
264#ifdef DEBUG
265 char str[80];
266
267 snprintf(str, sizeof(str),
268 "[sync_copy fb=%p, from=%p, to=%p, offset=%lx]",
269 priv->fb, from, to, offset);
270 console_puts_select_stderr(true, str);
271#endif
272 return -EFAULT;
273 }
274
275
276
277
278
279
280
281 if (offset + size > priv->fb_size) {
282 size = priv->fb_size - offset;
283 } else if (offset < 0) {
284 size += offset;
285 offset = 0;
286 }
287
288 memcpy(priv->copy_fb + offset, priv->fb + offset, size);
289 }
290
291 return 0;
292}
293#endif
294
295
296static int video_pre_probe(struct udevice *dev)
297{
298 struct video_priv *priv = dev_get_uclass_priv(dev);
299
300 priv->cmap = calloc(256, sizeof(ushort));
301 if (!priv->cmap)
302 return -ENOMEM;
303
304 return 0;
305}
306
307static int video_pre_remove(struct udevice *dev)
308{
309 struct video_priv *priv = dev_get_uclass_priv(dev);
310
311 free(priv->cmap);
312
313 return 0;
314}
315
316
317static int video_post_probe(struct udevice *dev)
318{
319 struct video_uc_platdata *plat = dev_get_uclass_platdata(dev);
320 struct video_priv *priv = dev_get_uclass_priv(dev);
321 char name[30], drv[15], *str;
322 const char *drv_name = drv;
323 struct udevice *cons;
324 int ret;
325
326
327 priv->fb = map_sysmem(plat->base, plat->size);
328 if (!priv->line_length)
329 priv->line_length = priv->xsize * VNBYTES(priv->bpix);
330
331 priv->fb_size = priv->line_length * priv->ysize;
332
333 if (IS_ENABLED(CONFIG_VIDEO_COPY) && plat->copy_base)
334 priv->copy_fb = map_sysmem(plat->copy_base, plat->size);
335
336
337 video_set_default_colors(dev, false);
338
339 if (!CONFIG_IS_ENABLED(NO_FB_CLEAR))
340 video_clear(dev);
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355 if (!priv->rot && IS_ENABLED(CONFIG_CONSOLE_TRUETYPE)) {
356 snprintf(name, sizeof(name), "%s.vidconsole_tt", dev->name);
357 strcpy(drv, "vidconsole_tt");
358 } else {
359 snprintf(name, sizeof(name), "%s.vidconsole%d", dev->name,
360 priv->rot);
361 snprintf(drv, sizeof(drv), "vidconsole%d", priv->rot);
362 }
363
364 str = strdup(name);
365 if (!str)
366 return -ENOMEM;
367 if (priv->vidconsole_drv_name)
368 drv_name = priv->vidconsole_drv_name;
369 ret = device_bind_driver(dev, drv_name, str, &cons);
370 if (ret) {
371 debug("%s: Cannot bind console driver\n", __func__);
372 return ret;
373 }
374
375 ret = device_probe(cons);
376 if (ret) {
377 debug("%s: Cannot probe console driver\n", __func__);
378 return ret;
379 }
380
381 return 0;
382};
383
384
385static int video_post_bind(struct udevice *dev)
386{
387 struct video_uc_priv *uc_priv;
388 ulong addr;
389 ulong size;
390
391
392 if (!(gd->flags & GD_FLG_RELOC))
393 return 0;
394
395
396 uc_priv = dev->uclass->priv;
397 if (!uc_priv->video_ptr)
398 uc_priv->video_ptr = gd->video_top;
399
400
401 addr = uc_priv->video_ptr;
402 size = alloc_fb(dev, &addr);
403 if (addr < gd->video_bottom) {
404
405
406
407 printf("Video device '%s' cannot allocate frame buffer memory -ensure the device is set up before relocation\n",
408 dev->name);
409 return -ENOSPC;
410 }
411 debug("%s: Claiming %lx bytes at %lx for video device '%s'\n",
412 __func__, size, addr, dev->name);
413 uc_priv->video_ptr = addr;
414
415 return 0;
416}
417
418UCLASS_DRIVER(video) = {
419 .id = UCLASS_VIDEO,
420 .name = "video",
421 .flags = DM_UC_FLAG_SEQ_ALIAS,
422 .post_bind = video_post_bind,
423 .pre_probe = video_pre_probe,
424 .post_probe = video_post_probe,
425 .pre_remove = video_pre_remove,
426 .priv_auto_alloc_size = sizeof(struct video_uc_priv),
427 .per_device_auto_alloc_size = sizeof(struct video_priv),
428 .per_device_platdata_auto_alloc_size = sizeof(struct video_uc_platdata),
429};
430