blob: 5215114b2d8e6907c0000a372091e548a778b7a9 [file] [log] [blame]
Tom Rini83d290c2018-05-06 17:58:06 -04001// SPDX-License-Identifier: GPL-2.0+
Simon Glass1acafc72016-01-18 19:52:15 -07002/*
3 * Copyright (c) 2015 Google, Inc
Simon Glass1acafc72016-01-18 19:52:15 -07004 */
5
Patrick Delaunayb953ec22021-04-27 11:02:19 +02006#define LOG_CATEGORY UCLASS_VIDEO
7
Simon Glass1acafc72016-01-18 19:52:15 -07008#include <common.h>
Simon Glass9beac5d2020-07-02 21:12:20 -06009#include <console.h>
Simon Glass1eb69ae2019-11-14 12:57:39 -070010#include <cpu_func.h>
Simon Glass1acafc72016-01-18 19:52:15 -070011#include <dm.h>
Simon Glassf7ae49f2020-05-10 11:40:05 -060012#include <log.h>
Simon Glass336d4612020-02-03 07:36:16 -070013#include <malloc.h>
Simon Glass1acafc72016-01-18 19:52:15 -070014#include <mapmem.h>
15#include <stdio_dev.h>
16#include <video.h>
17#include <video_console.h>
Simon Glass90526e92020-05-10 11:39:56 -060018#include <asm/cache.h>
Simon Glass401d1c42020-10-30 21:38:53 -060019#include <asm/global_data.h>
Simon Glass1acafc72016-01-18 19:52:15 -070020#include <dm/lists.h>
Michal Simek9de731f2020-12-14 08:47:52 +010021#include <dm/device_compat.h>
Simon Glass1acafc72016-01-18 19:52:15 -070022#include <dm/device-internal.h>
23#include <dm/uclass-internal.h>
24#ifdef CONFIG_SANDBOX
25#include <asm/sdl.h>
26#endif
27
28/*
29 * Theory of operation:
30 *
31 * Before relocation each device is bound. The driver for each device must
Simon Glass8a8d24b2020-12-03 16:55:23 -070032 * set the @align and @size values in struct video_uc_plat. This
Simon Glass1acafc72016-01-18 19:52:15 -070033 * information represents the requires size and alignment of the frame buffer
34 * for the device. The values can be an over-estimate but cannot be too
35 * small. The actual values will be suppled (in the same manner) by the bind()
36 * method after relocation.
37 *
38 * This information is then picked up by video_reserve() which works out how
39 * much memory is needed for all devices. This is allocated between
40 * gd->video_bottom and gd->video_top.
41 *
42 * After relocation the same process occurs. The driver supplies the same
43 * @size and @align information and this time video_post_bind() checks that
44 * the drivers does not overflow the allocated memory.
45 *
46 * The frame buffer address is actually set (to plat->base) in
47 * video_post_probe(). This function also clears the frame buffer and
48 * allocates a suitable text console device. This can then be used to write
49 * text to the video device.
50 */
51DECLARE_GLOBAL_DATA_PTR;
52
Simon Glass7812bbd2020-07-02 21:12:32 -060053/**
54 * struct video_uc_priv - Information for the video uclass
55 *
56 * @video_ptr: Current allocation position of the video framebuffer pointer.
57 * While binding devices after relocation, this points to the next
58 * available address to use for a device's framebuffer. It starts at
59 * gd->video_top and works downwards, running out of space when it hits
60 * gd->video_bottom.
61 */
62struct video_uc_priv {
63 ulong video_ptr;
64};
65
Simon Glass68dcdc92016-01-21 19:44:52 -070066void video_set_flush_dcache(struct udevice *dev, bool flush)
67{
68 struct video_priv *priv = dev_get_uclass_priv(dev);
69
70 priv->flush_dcache = flush;
71}
72
Simon Glass1acafc72016-01-18 19:52:15 -070073static ulong alloc_fb(struct udevice *dev, ulong *addrp)
74{
Simon Glass8a8d24b2020-12-03 16:55:23 -070075 struct video_uc_plat *plat = dev_get_uclass_plat(dev);
Simon Glass1acafc72016-01-18 19:52:15 -070076 ulong base, align, size;
77
Bin Meng39683982016-10-09 04:14:17 -070078 if (!plat->size)
79 return 0;
80
Simon Glass1acafc72016-01-18 19:52:15 -070081 align = plat->align ? plat->align : 1 << 20;
82 base = *addrp - plat->size;
83 base &= ~(align - 1);
84 plat->base = base;
85 size = *addrp - base;
86 *addrp = base;
87
88 return size;
89}
90
91int video_reserve(ulong *addrp)
92{
93 struct udevice *dev;
94 ulong size;
95
96 gd->video_top = *addrp;
97 for (uclass_find_first_device(UCLASS_VIDEO, &dev);
98 dev;
99 uclass_find_next_device(&dev)) {
100 size = alloc_fb(dev, addrp);
101 debug("%s: Reserving %lx bytes at %lx for video device '%s'\n",
102 __func__, size, *addrp, dev->name);
103 }
Simon Glass551ca0e2020-07-02 21:12:33 -0600104
105 /* Allocate space for PCI video devices in case there were not bound */
106 if (*addrp == gd->video_top)
107 *addrp -= CONFIG_VIDEO_PCI_DEFAULT_FB_SIZE;
108
Simon Glass1acafc72016-01-18 19:52:15 -0700109 gd->video_bottom = *addrp;
Simon Glassaef43ea2020-05-10 14:17:01 -0600110 gd->fb_base = *addrp;
Simon Glass1acafc72016-01-18 19:52:15 -0700111 debug("Video frame buffers from %lx to %lx\n", gd->video_bottom,
112 gd->video_top);
113
114 return 0;
115}
116
Simon Glassc6ebd012018-10-01 12:22:26 -0600117int video_clear(struct udevice *dev)
Simon Glass1acafc72016-01-18 19:52:15 -0700118{
119 struct video_priv *priv = dev_get_uclass_priv(dev);
Simon Glass138dfea2020-07-02 21:12:22 -0600120 int ret;
Simon Glass1acafc72016-01-18 19:52:15 -0700121
Heinrich Schuchardtd7a75d32018-02-08 21:47:10 +0100122 switch (priv->bpix) {
Simon Glass0c20aaf2019-12-20 18:10:37 -0700123 case VIDEO_BPP16:
124 if (IS_ENABLED(CONFIG_VIDEO_BPP16)) {
125 u16 *ppix = priv->fb;
126 u16 *end = priv->fb + priv->fb_size;
Heinrich Schuchardtd7a75d32018-02-08 21:47:10 +0100127
Simon Glass0c20aaf2019-12-20 18:10:37 -0700128 while (ppix < end)
129 *ppix++ = priv->colour_bg;
130 break;
131 }
132 case VIDEO_BPP32:
133 if (IS_ENABLED(CONFIG_VIDEO_BPP32)) {
134 u32 *ppix = priv->fb;
135 u32 *end = priv->fb + priv->fb_size;
Simon Glass1acafc72016-01-18 19:52:15 -0700136
Simon Glass0c20aaf2019-12-20 18:10:37 -0700137 while (ppix < end)
138 *ppix++ = priv->colour_bg;
139 break;
140 }
Heinrich Schuchardtd7a75d32018-02-08 21:47:10 +0100141 default:
Simon Glass1acafc72016-01-18 19:52:15 -0700142 memset(priv->fb, priv->colour_bg, priv->fb_size);
Heinrich Schuchardtd7a75d32018-02-08 21:47:10 +0100143 break;
Simon Glass1acafc72016-01-18 19:52:15 -0700144 }
Simon Glass138dfea2020-07-02 21:12:22 -0600145 ret = video_sync_copy(dev, priv->fb, priv->fb + priv->fb_size);
146 if (ret)
147 return ret;
Simon Glassc6ebd012018-10-01 12:22:26 -0600148
Michal Simek53376632020-12-15 15:12:09 +0100149 return video_sync(dev, false);
Simon Glass1acafc72016-01-18 19:52:15 -0700150}
151
Simon Glassb9f210a2018-11-06 15:21:36 -0700152void video_set_default_colors(struct udevice *dev, bool invert)
Heinrich Schuchardt5c30fbb2018-02-08 21:47:11 +0100153{
Simon Glassb9f210a2018-11-06 15:21:36 -0700154 struct video_priv *priv = dev_get_uclass_priv(dev);
155 int fore, back;
156
Simon Glass0c20aaf2019-12-20 18:10:37 -0700157 if (CONFIG_IS_ENABLED(SYS_WHITE_ON_BLACK)) {
158 /* White is used when switching to bold, use light gray here */
159 fore = VID_LIGHT_GRAY;
160 back = VID_BLACK;
161 } else {
162 fore = VID_BLACK;
163 back = VID_WHITE;
164 }
Simon Glassb9f210a2018-11-06 15:21:36 -0700165 if (invert) {
166 int temp;
167
168 temp = fore;
169 fore = back;
170 back = temp;
171 }
172 priv->fg_col_idx = fore;
Andre Przywaraeabb0722019-03-23 01:29:56 +0000173 priv->bg_col_idx = back;
Simon Glassb9f210a2018-11-06 15:21:36 -0700174 priv->colour_fg = vid_console_color(priv, fore);
175 priv->colour_bg = vid_console_color(priv, back);
Heinrich Schuchardt5c30fbb2018-02-08 21:47:11 +0100176}
177
Simon Glass1acafc72016-01-18 19:52:15 -0700178/* Flush video activity to the caches */
Michal Simek9de731f2020-12-14 08:47:52 +0100179int video_sync(struct udevice *vid, bool force)
Simon Glass1acafc72016-01-18 19:52:15 -0700180{
Michal Simek9d69c2d2020-12-03 09:30:00 +0100181 struct video_ops *ops = video_get_ops(vid);
182 int ret;
183
184 if (ops && ops->video_sync) {
185 ret = ops->video_sync(vid);
186 if (ret)
187 return ret;
188 }
189
Simon Glass1acafc72016-01-18 19:52:15 -0700190 /*
191 * flush_dcache_range() is declared in common.h but it seems that some
192 * architectures do not actually implement it. Is there a way to find
193 * out whether it exists? For now, ARM is safe.
194 */
Trevor Woerner10015022019-05-03 09:41:00 -0400195#if defined(CONFIG_ARM) && !CONFIG_IS_ENABLED(SYS_DCACHE_OFF)
Simon Glass1acafc72016-01-18 19:52:15 -0700196 struct video_priv *priv = dev_get_uclass_priv(vid);
197
198 if (priv->flush_dcache) {
199 flush_dcache_range((ulong)priv->fb,
Simon Glass79813942016-11-13 14:22:06 -0700200 ALIGN((ulong)priv->fb + priv->fb_size,
201 CONFIG_SYS_CACHELINE_SIZE));
Simon Glass1acafc72016-01-18 19:52:15 -0700202 }
203#elif defined(CONFIG_VIDEO_SANDBOX_SDL)
204 struct video_priv *priv = dev_get_uclass_priv(vid);
205 static ulong last_sync;
206
Simon Glass7c19e4c2022-02-28 15:13:48 -0700207 if (force || get_timer(last_sync) > 100) {
Simon Glass1acafc72016-01-18 19:52:15 -0700208 sandbox_sdl_sync(priv->fb);
209 last_sync = get_timer(0);
210 }
211#endif
Michal Simek9de731f2020-12-14 08:47:52 +0100212 return 0;
Simon Glass1acafc72016-01-18 19:52:15 -0700213}
214
215void video_sync_all(void)
216{
217 struct udevice *dev;
Michal Simek9de731f2020-12-14 08:47:52 +0100218 int ret;
Simon Glass1acafc72016-01-18 19:52:15 -0700219
220 for (uclass_find_first_device(UCLASS_VIDEO, &dev);
221 dev;
222 uclass_find_next_device(&dev)) {
Michal Simek9de731f2020-12-14 08:47:52 +0100223 if (device_active(dev)) {
224 ret = video_sync(dev, true);
225 if (ret)
226 dev_dbg(dev, "Video sync failed\n");
227 }
Simon Glass1acafc72016-01-18 19:52:15 -0700228 }
229}
230
Patrick Delaunay2e2e6d82021-11-15 16:32:20 +0100231bool video_is_active(void)
232{
233 struct udevice *dev;
234
235 for (uclass_find_first_device(UCLASS_VIDEO, &dev);
236 dev;
237 uclass_find_next_device(&dev)) {
238 if (device_active(dev))
239 return true;
240 }
241
242 return false;
243}
244
Simon Glass1acafc72016-01-18 19:52:15 -0700245int video_get_xsize(struct udevice *dev)
246{
247 struct video_priv *priv = dev_get_uclass_priv(dev);
248
249 return priv->xsize;
250}
251
252int video_get_ysize(struct udevice *dev)
253{
254 struct video_priv *priv = dev_get_uclass_priv(dev);
255
256 return priv->ysize;
257}
258
Simon Glass9beac5d2020-07-02 21:12:20 -0600259#ifdef CONFIG_VIDEO_COPY
260int video_sync_copy(struct udevice *dev, void *from, void *to)
261{
262 struct video_priv *priv = dev_get_uclass_priv(dev);
263
264 if (priv->copy_fb) {
265 long offset, size;
266
267 /* Find the offset of the first byte to copy */
268 if ((ulong)to > (ulong)from) {
269 size = to - from;
270 offset = from - priv->fb;
271 } else {
272 size = from - to;
273 offset = to - priv->fb;
274 }
275
276 /*
277 * Allow a bit of leeway for valid requests somewhere near the
278 * frame buffer
279 */
280 if (offset < -priv->fb_size || offset > 2 * priv->fb_size) {
281#ifdef DEBUG
Simon Glass6a19e932021-11-19 13:23:51 -0700282 char str[120];
Simon Glass9beac5d2020-07-02 21:12:20 -0600283
284 snprintf(str, sizeof(str),
Simon Glass6a19e932021-11-19 13:23:51 -0700285 "[** FAULT sync_copy fb=%p, from=%p, to=%p, offset=%lx]",
Simon Glass9beac5d2020-07-02 21:12:20 -0600286 priv->fb, from, to, offset);
287 console_puts_select_stderr(true, str);
288#endif
289 return -EFAULT;
290 }
291
292 /*
293 * Silently crop the memcpy. This allows callers to avoid doing
294 * this themselves. It is common for the end pointer to go a
295 * few lines after the end of the frame buffer, since most of
296 * the update algorithms terminate a line after their last write
297 */
298 if (offset + size > priv->fb_size) {
299 size = priv->fb_size - offset;
300 } else if (offset < 0) {
301 size += offset;
302 offset = 0;
303 }
304
305 memcpy(priv->copy_fb + offset, priv->fb + offset, size);
306 }
307
308 return 0;
309}
Simon Glass7d701162021-01-13 20:29:46 -0700310
311int video_sync_copy_all(struct udevice *dev)
312{
313 struct video_priv *priv = dev_get_uclass_priv(dev);
314
315 video_sync_copy(dev, priv->fb, priv->fb + priv->fb_size);
316
317 return 0;
318}
319
Simon Glass9beac5d2020-07-02 21:12:20 -0600320#endif
321
Simon Glass84e63ab2021-11-19 13:24:03 -0700322#define SPLASH_DECL(_name) \
323 extern u8 __splash_ ## _name ## _begin[]; \
324 extern u8 __splash_ ## _name ## _end[]
325
326#define SPLASH_START(_name) __splash_ ## _name ## _begin
327
328SPLASH_DECL(u_boot_logo);
329
330static int show_splash(struct udevice *dev)
331{
332 u8 *data = SPLASH_START(u_boot_logo);
333 int ret;
334
335 ret = video_bmp_display(dev, map_to_sysmem(data), -4, 4, true);
336
337 return 0;
338}
339
Simon Glass1acafc72016-01-18 19:52:15 -0700340/* Set up the display ready for use */
341static int video_post_probe(struct udevice *dev)
342{
Simon Glass8a8d24b2020-12-03 16:55:23 -0700343 struct video_uc_plat *plat = dev_get_uclass_plat(dev);
Simon Glass1acafc72016-01-18 19:52:15 -0700344 struct video_priv *priv = dev_get_uclass_priv(dev);
345 char name[30], drv[15], *str;
Simon Glass826f35f2016-01-14 18:10:48 -0700346 const char *drv_name = drv;
Simon Glass1acafc72016-01-18 19:52:15 -0700347 struct udevice *cons;
348 int ret;
349
350 /* Set up the line and display size */
351 priv->fb = map_sysmem(plat->base, plat->size);
Simon Glass06696eb2018-11-29 15:08:52 -0700352 if (!priv->line_length)
353 priv->line_length = priv->xsize * VNBYTES(priv->bpix);
354
Simon Glass1acafc72016-01-18 19:52:15 -0700355 priv->fb_size = priv->line_length * priv->ysize;
356
Simon Glass6efa8092020-07-02 21:12:21 -0600357 if (IS_ENABLED(CONFIG_VIDEO_COPY) && plat->copy_base)
358 priv->copy_fb = map_sysmem(plat->copy_base, plat->size);
359
Heinrich Schuchardt5c30fbb2018-02-08 21:47:11 +0100360 /* Set up colors */
Simon Glassb9f210a2018-11-06 15:21:36 -0700361 video_set_default_colors(dev, false);
Rob Clark8ef05352017-08-03 12:47:01 -0400362
363 if (!CONFIG_IS_ENABLED(NO_FB_CLEAR))
364 video_clear(dev);
Simon Glass1acafc72016-01-18 19:52:15 -0700365
Simon Glass83510762016-01-18 19:52:17 -0700366 /*
Simon Glass826f35f2016-01-14 18:10:48 -0700367 * Create a text console device. For now we always do this, although
Simon Glass83510762016-01-18 19:52:17 -0700368 * it might be useful to support only bitmap drawing on the device
Simon Glass826f35f2016-01-14 18:10:48 -0700369 * for boards that don't need to display text. We create a TrueType
370 * console if enabled, a rotated console if the video driver requests
371 * it, otherwise a normal console.
372 *
373 * The console can be override by setting vidconsole_drv_name before
374 * probing this video driver, or in the probe() method.
375 *
376 * TrueType does not support rotation at present so fall back to the
377 * rotated console in that case.
Simon Glass83510762016-01-18 19:52:17 -0700378 */
Simon Glass826f35f2016-01-14 18:10:48 -0700379 if (!priv->rot && IS_ENABLED(CONFIG_CONSOLE_TRUETYPE)) {
Simon Glassa29b0122016-01-14 18:10:42 -0700380 snprintf(name, sizeof(name), "%s.vidconsole_tt", dev->name);
381 strcpy(drv, "vidconsole_tt");
382 } else {
383 snprintf(name, sizeof(name), "%s.vidconsole%d", dev->name,
384 priv->rot);
385 snprintf(drv, sizeof(drv), "vidconsole%d", priv->rot);
386 }
387
Simon Glass83510762016-01-18 19:52:17 -0700388 str = strdup(name);
389 if (!str)
390 return -ENOMEM;
Simon Glass826f35f2016-01-14 18:10:48 -0700391 if (priv->vidconsole_drv_name)
392 drv_name = priv->vidconsole_drv_name;
393 ret = device_bind_driver(dev, drv_name, str, &cons);
Simon Glass83510762016-01-18 19:52:17 -0700394 if (ret) {
395 debug("%s: Cannot bind console driver\n", __func__);
396 return ret;
397 }
Simon Glass826f35f2016-01-14 18:10:48 -0700398
Simon Glass83510762016-01-18 19:52:17 -0700399 ret = device_probe(cons);
400 if (ret) {
401 debug("%s: Cannot probe console driver\n", __func__);
402 return ret;
403 }
404
Simon Glass84e63ab2021-11-19 13:24:03 -0700405 if (IS_ENABLED(CONFIG_VIDEO_LOGO) && !plat->hide_logo) {
406 ret = show_splash(dev);
407 if (ret) {
408 log_debug("Cannot show splash screen\n");
409 return ret;
410 }
411 }
412
Simon Glass1acafc72016-01-18 19:52:15 -0700413 return 0;
414};
415
416/* Post-relocation, allocate memory for the frame buffer */
417static int video_post_bind(struct udevice *dev)
418{
Simon Glass7812bbd2020-07-02 21:12:32 -0600419 struct video_uc_priv *uc_priv;
420 ulong addr;
Simon Glass1acafc72016-01-18 19:52:15 -0700421 ulong size;
422
423 /* Before relocation there is nothing to do here */
Tom Rini75164182018-04-22 09:47:48 -0400424 if (!(gd->flags & GD_FLG_RELOC))
Simon Glass1acafc72016-01-18 19:52:15 -0700425 return 0;
Simon Glass7812bbd2020-07-02 21:12:32 -0600426
427 /* Set up the video pointer, if this is the first device */
Simon Glass0fd3d912020-12-22 19:30:28 -0700428 uc_priv = uclass_get_priv(dev->uclass);
Simon Glass7812bbd2020-07-02 21:12:32 -0600429 if (!uc_priv->video_ptr)
430 uc_priv->video_ptr = gd->video_top;
431
432 /* Allocate framebuffer space for this device */
433 addr = uc_priv->video_ptr;
Simon Glass1acafc72016-01-18 19:52:15 -0700434 size = alloc_fb(dev, &addr);
435 if (addr < gd->video_bottom) {
Patrick Delaunay69989742019-05-21 19:19:12 +0200436 /* Device tree node may need the 'u-boot,dm-pre-reloc' or
437 * 'u-boot,dm-pre-proper' tag
438 */
Simon Glass1acafc72016-01-18 19:52:15 -0700439 printf("Video device '%s' cannot allocate frame buffer memory -ensure the device is set up before relocation\n",
440 dev->name);
441 return -ENOSPC;
442 }
443 debug("%s: Claiming %lx bytes at %lx for video device '%s'\n",
444 __func__, size, addr, dev->name);
Simon Glass7812bbd2020-07-02 21:12:32 -0600445 uc_priv->video_ptr = addr;
Simon Glass1acafc72016-01-18 19:52:15 -0700446
447 return 0;
448}
449
450UCLASS_DRIVER(video) = {
451 .id = UCLASS_VIDEO,
452 .name = "video",
453 .flags = DM_UC_FLAG_SEQ_ALIAS,
454 .post_bind = video_post_bind,
Simon Glass1acafc72016-01-18 19:52:15 -0700455 .post_probe = video_post_probe,
Simon Glass41575d82020-12-03 16:55:17 -0700456 .priv_auto = sizeof(struct video_uc_priv),
457 .per_device_auto = sizeof(struct video_priv),
Simon Glass8a8d24b2020-12-03 16:55:23 -0700458 .per_device_plat_auto = sizeof(struct video_uc_plat),
Simon Glass1acafc72016-01-18 19:52:15 -0700459};