blob: 41bb7647fda2713ce915dd0fab02c89a3b27d4d2 [file] [log] [blame]
Tom Rini10e47792018-05-06 17:58:06 -04001// SPDX-License-Identifier: GPL-2.0+
Simon Glass623d28f2016-01-18 19:52:15 -07002/*
3 * Copyright (c) 2015 Google, Inc
Simon Glass623d28f2016-01-18 19:52:15 -07004 */
5
Patrick Delaunay81313352021-04-27 11:02:19 +02006#define LOG_CATEGORY UCLASS_VIDEO
7
Nikhil M Jainf7ec5312023-07-18 14:27:31 +05308#include <bloblist.h>
Simon Glass73c9c372020-07-02 21:12:20 -06009#include <console.h>
Simon Glass63334482019-11-14 12:57:39 -070010#include <cpu_func.h>
Simon Glasse0337a52024-07-31 08:44:10 -060011#include <cyclic.h>
Simon Glass623d28f2016-01-18 19:52:15 -070012#include <dm.h>
Simon Glass0f2af882020-05-10 11:40:05 -060013#include <log.h>
Simon Glass9bc15642020-02-03 07:36:16 -070014#include <malloc.h>
Simon Glass623d28f2016-01-18 19:52:15 -070015#include <mapmem.h>
Nikhil M Jainf7ec5312023-07-18 14:27:31 +053016#include <spl.h>
Simon Glass623d28f2016-01-18 19:52:15 -070017#include <stdio_dev.h>
18#include <video.h>
19#include <video_console.h>
Simon Glass274e0b02020-05-10 11:39:56 -060020#include <asm/cache.h>
Simon Glass3ba929a2020-10-30 21:38:53 -060021#include <asm/global_data.h>
Simon Glass623d28f2016-01-18 19:52:15 -070022#include <dm/lists.h>
Michal Simek632e3d42020-12-14 08:47:52 +010023#include <dm/device_compat.h>
Simon Glass623d28f2016-01-18 19:52:15 -070024#include <dm/device-internal.h>
25#include <dm/uclass-internal.h>
26#ifdef CONFIG_SANDBOX
27#include <asm/sdl.h>
28#endif
29
30/*
31 * Theory of operation:
32 *
33 * Before relocation each device is bound. The driver for each device must
Simon Glassb75b15b2020-12-03 16:55:23 -070034 * set the @align and @size values in struct video_uc_plat. This
Simon Glass623d28f2016-01-18 19:52:15 -070035 * information represents the requires size and alignment of the frame buffer
36 * for the device. The values can be an over-estimate but cannot be too
37 * small. The actual values will be suppled (in the same manner) by the bind()
Pali Rohárf204fce2022-03-09 20:46:00 +010038 * method after relocation. Additionally driver can allocate frame buffer
39 * itself by setting plat->base.
Simon Glass623d28f2016-01-18 19:52:15 -070040 *
41 * This information is then picked up by video_reserve() which works out how
42 * much memory is needed for all devices. This is allocated between
43 * gd->video_bottom and gd->video_top.
44 *
45 * After relocation the same process occurs. The driver supplies the same
46 * @size and @align information and this time video_post_bind() checks that
47 * the drivers does not overflow the allocated memory.
48 *
49 * The frame buffer address is actually set (to plat->base) in
50 * video_post_probe(). This function also clears the frame buffer and
51 * allocates a suitable text console device. This can then be used to write
52 * text to the video device.
53 */
54DECLARE_GLOBAL_DATA_PTR;
55
Simon Glasse0337a52024-07-31 08:44:10 -060056struct cyclic_info;
57
Simon Glass951255d2020-07-02 21:12:32 -060058/**
59 * struct video_uc_priv - Information for the video uclass
60 *
61 * @video_ptr: Current allocation position of the video framebuffer pointer.
62 * While binding devices after relocation, this points to the next
63 * available address to use for a device's framebuffer. It starts at
64 * gd->video_top and works downwards, running out of space when it hits
65 * gd->video_bottom.
Simon Glasse0337a52024-07-31 08:44:10 -060066 * @cyc: handle for cyclic-execution function, or NULL if none
Simon Glass951255d2020-07-02 21:12:32 -060067 */
68struct video_uc_priv {
69 ulong video_ptr;
Simon Glasse0337a52024-07-31 08:44:10 -060070 bool cyc_active;
71 struct cyclic_info cyc;
Simon Glass951255d2020-07-02 21:12:32 -060072};
73
Simon Glass2a006332022-10-06 08:36:03 -060074/** struct vid_rgb - Describes a video colour */
75struct vid_rgb {
76 u32 r;
77 u32 g;
78 u32 b;
79};
80
Simon Glass64635382016-01-21 19:44:52 -070081void video_set_flush_dcache(struct udevice *dev, bool flush)
82{
83 struct video_priv *priv = dev_get_uclass_priv(dev);
84
85 priv->flush_dcache = flush;
86}
87
Simon Glassdf865d32023-03-10 12:47:17 -080088static ulong alloc_fb_(ulong align, ulong size, ulong *addrp)
89{
90 ulong base;
91
92 align = align ? align : 1 << 20;
93 base = *addrp - size;
94 base &= ~(align - 1);
95 size = *addrp - base;
96 *addrp = base;
97
98 return size;
99}
100
Simon Glass623d28f2016-01-18 19:52:15 -0700101static ulong alloc_fb(struct udevice *dev, ulong *addrp)
102{
Simon Glassb75b15b2020-12-03 16:55:23 -0700103 struct video_uc_plat *plat = dev_get_uclass_plat(dev);
Simon Glassdf865d32023-03-10 12:47:17 -0800104 ulong size;
Simon Glass623d28f2016-01-18 19:52:15 -0700105
Simon Glassdf865d32023-03-10 12:47:17 -0800106 if (!plat->size) {
107 if (IS_ENABLED(CONFIG_VIDEO_COPY) && plat->copy_size) {
108 size = alloc_fb_(plat->align, plat->copy_size, addrp);
109 plat->copy_base = *addrp;
110 return size;
111 }
112
Bin Meng755623d2016-10-09 04:14:17 -0700113 return 0;
Simon Glassdf865d32023-03-10 12:47:17 -0800114 }
Bin Meng755623d2016-10-09 04:14:17 -0700115
Pali Rohárf204fce2022-03-09 20:46:00 +0100116 /* Allow drivers to allocate the frame buffer themselves */
117 if (plat->base)
118 return 0;
119
Simon Glassdf865d32023-03-10 12:47:17 -0800120 size = alloc_fb_(plat->align, plat->size, addrp);
121 plat->base = *addrp;
Simon Glass623d28f2016-01-18 19:52:15 -0700122
123 return size;
124}
125
126int video_reserve(ulong *addrp)
127{
128 struct udevice *dev;
129 ulong size;
130
Devarsh Thakkar2febd462023-12-05 21:25:20 +0530131 if (IS_ENABLED(CONFIG_SPL_VIDEO_HANDOFF) && spl_phase() == PHASE_BOARD_F)
132 return 0;
133
Simon Glass623d28f2016-01-18 19:52:15 -0700134 gd->video_top = *addrp;
135 for (uclass_find_first_device(UCLASS_VIDEO, &dev);
136 dev;
137 uclass_find_next_device(&dev)) {
138 size = alloc_fb(dev, addrp);
139 debug("%s: Reserving %lx bytes at %lx for video device '%s'\n",
140 __func__, size, *addrp, dev->name);
141 }
Simon Glassc3d2f352020-07-02 21:12:33 -0600142
143 /* Allocate space for PCI video devices in case there were not bound */
144 if (*addrp == gd->video_top)
Nikhil M Jain9e3301d2023-04-20 17:41:08 +0530145 *addrp -= CONFIG_VAL(VIDEO_PCI_DEFAULT_FB_SIZE);
Simon Glassc3d2f352020-07-02 21:12:33 -0600146
Simon Glass623d28f2016-01-18 19:52:15 -0700147 gd->video_bottom = *addrp;
148 debug("Video frame buffers from %lx to %lx\n", gd->video_bottom,
149 gd->video_top);
150
151 return 0;
152}
153
Simon Glass853e8d22024-08-21 10:18:55 -0600154ulong video_get_fb(void)
155{
156 struct udevice *dev;
157
158 uclass_find_first_device(UCLASS_VIDEO, &dev);
159 if (dev) {
160 const struct video_uc_plat *uc_plat = dev_get_uclass_plat(dev);
161
162 return uc_plat->base;
163 }
164
165 return 0;
166}
167
Simon Glass062673b2023-06-01 10:22:33 -0600168int video_fill_part(struct udevice *dev, int xstart, int ystart, int xend,
169 int yend, u32 colour)
170{
171 struct video_priv *priv = dev_get_uclass_priv(dev);
172 void *start, *line;
173 int pixels = xend - xstart;
174 int row, i, ret;
175
176 start = priv->fb + ystart * priv->line_length;
177 start += xstart * VNBYTES(priv->bpix);
178 line = start;
179 for (row = ystart; row < yend; row++) {
180 switch (priv->bpix) {
181 case VIDEO_BPP8: {
182 u8 *dst = line;
183
184 if (IS_ENABLED(CONFIG_VIDEO_BPP8)) {
185 for (i = 0; i < pixels; i++)
186 *dst++ = colour;
187 }
188 break;
189 }
190 case VIDEO_BPP16: {
191 u16 *dst = line;
192
193 if (IS_ENABLED(CONFIG_VIDEO_BPP16)) {
194 for (i = 0; i < pixels; i++)
195 *dst++ = colour;
196 }
197 break;
198 }
199 case VIDEO_BPP32: {
200 u32 *dst = line;
201
202 if (IS_ENABLED(CONFIG_VIDEO_BPP32)) {
203 for (i = 0; i < pixels; i++)
204 *dst++ = colour;
205 }
206 break;
207 }
208 default:
209 return -ENOSYS;
210 }
211 line += priv->line_length;
212 }
213 ret = video_sync_copy(dev, start, line);
214 if (ret)
215 return ret;
216
217 return 0;
218}
219
Nikhil M Jain76833532023-07-18 14:27:30 +0530220int video_reserve_from_bloblist(struct video_handoff *ho)
221{
Devarsh Thakkar2febd462023-12-05 21:25:20 +0530222 if (!ho->fb || ho->size == 0)
223 return -ENOENT;
224
Nikhil M Jain76833532023-07-18 14:27:30 +0530225 gd->video_bottom = ho->fb;
Nikhil M Jain76833532023-07-18 14:27:30 +0530226 gd->video_top = ho->fb + ho->size;
Devarsh Thakkar2febd462023-12-05 21:25:20 +0530227 debug("%s: Reserving %lx bytes at %08x as per bloblist received\n",
228 __func__, (unsigned long)ho->size, (u32)ho->fb);
Nikhil M Jain76833532023-07-18 14:27:30 +0530229
230 return 0;
231}
232
Simon Glass2baa6f82022-10-06 08:36:08 -0600233int video_fill(struct udevice *dev, u32 colour)
Simon Glass623d28f2016-01-18 19:52:15 -0700234{
235 struct video_priv *priv = dev_get_uclass_priv(dev);
Simon Glassf8ec6212020-07-02 21:12:22 -0600236 int ret;
Simon Glass623d28f2016-01-18 19:52:15 -0700237
Heinrich Schuchardt5e4947e2018-02-08 21:47:10 +0100238 switch (priv->bpix) {
Simon Glass05c17d62019-12-20 18:10:37 -0700239 case VIDEO_BPP16:
Nikhil M Jain9e3301d2023-04-20 17:41:08 +0530240 if (CONFIG_IS_ENABLED(VIDEO_BPP16)) {
Simon Glass05c17d62019-12-20 18:10:37 -0700241 u16 *ppix = priv->fb;
242 u16 *end = priv->fb + priv->fb_size;
Heinrich Schuchardt5e4947e2018-02-08 21:47:10 +0100243
Simon Glass05c17d62019-12-20 18:10:37 -0700244 while (ppix < end)
Simon Glass2baa6f82022-10-06 08:36:08 -0600245 *ppix++ = colour;
Simon Glass05c17d62019-12-20 18:10:37 -0700246 break;
247 }
248 case VIDEO_BPP32:
Nikhil M Jain9e3301d2023-04-20 17:41:08 +0530249 if (CONFIG_IS_ENABLED(VIDEO_BPP32)) {
Simon Glass05c17d62019-12-20 18:10:37 -0700250 u32 *ppix = priv->fb;
251 u32 *end = priv->fb + priv->fb_size;
Simon Glass623d28f2016-01-18 19:52:15 -0700252
Simon Glass05c17d62019-12-20 18:10:37 -0700253 while (ppix < end)
Simon Glass2baa6f82022-10-06 08:36:08 -0600254 *ppix++ = colour;
Simon Glass05c17d62019-12-20 18:10:37 -0700255 break;
256 }
Heinrich Schuchardt5e4947e2018-02-08 21:47:10 +0100257 default:
Simon Glass2baa6f82022-10-06 08:36:08 -0600258 memset(priv->fb, colour, priv->fb_size);
Heinrich Schuchardt5e4947e2018-02-08 21:47:10 +0100259 break;
Simon Glass623d28f2016-01-18 19:52:15 -0700260 }
Simon Glassf8ec6212020-07-02 21:12:22 -0600261 ret = video_sync_copy(dev, priv->fb, priv->fb + priv->fb_size);
262 if (ret)
263 return ret;
Simon Glass55343122018-10-01 12:22:26 -0600264
Michal Simeka1e136d2020-12-15 15:12:09 +0100265 return video_sync(dev, false);
Simon Glass623d28f2016-01-18 19:52:15 -0700266}
267
Simon Glass2baa6f82022-10-06 08:36:08 -0600268int video_clear(struct udevice *dev)
269{
270 struct video_priv *priv = dev_get_uclass_priv(dev);
271 int ret;
272
273 ret = video_fill(dev, priv->colour_bg);
274 if (ret)
275 return ret;
276
277 return 0;
278}
279
Simon Glass2a006332022-10-06 08:36:03 -0600280static const struct vid_rgb colours[VID_COLOUR_COUNT] = {
281 { 0x00, 0x00, 0x00 }, /* black */
282 { 0xc0, 0x00, 0x00 }, /* red */
283 { 0x00, 0xc0, 0x00 }, /* green */
284 { 0xc0, 0x60, 0x00 }, /* brown */
285 { 0x00, 0x00, 0xc0 }, /* blue */
286 { 0xc0, 0x00, 0xc0 }, /* magenta */
287 { 0x00, 0xc0, 0xc0 }, /* cyan */
288 { 0xc0, 0xc0, 0xc0 }, /* light gray */
289 { 0x80, 0x80, 0x80 }, /* gray */
290 { 0xff, 0x00, 0x00 }, /* bright red */
291 { 0x00, 0xff, 0x00 }, /* bright green */
292 { 0xff, 0xff, 0x00 }, /* yellow */
293 { 0x00, 0x00, 0xff }, /* bright blue */
294 { 0xff, 0x00, 0xff }, /* bright magenta */
295 { 0x00, 0xff, 0xff }, /* bright cyan */
296 { 0xff, 0xff, 0xff }, /* white */
297};
298
Simon Glassd17a6242023-06-01 10:22:48 -0600299u32 video_index_to_colour(struct video_priv *priv, enum colour_idx idx)
Simon Glass2a006332022-10-06 08:36:03 -0600300{
301 switch (priv->bpix) {
302 case VIDEO_BPP16:
Nikhil M Jain9e3301d2023-04-20 17:41:08 +0530303 if (CONFIG_IS_ENABLED(VIDEO_BPP16)) {
Simon Glass2a006332022-10-06 08:36:03 -0600304 return ((colours[idx].r >> 3) << 11) |
305 ((colours[idx].g >> 2) << 5) |
306 ((colours[idx].b >> 3) << 0);
307 }
308 break;
309 case VIDEO_BPP32:
Nikhil M Jain9e3301d2023-04-20 17:41:08 +0530310 if (CONFIG_IS_ENABLED(VIDEO_BPP32)) {
Michal Simek985eac82023-05-17 10:42:07 +0200311 switch (priv->format) {
312 case VIDEO_X2R10G10B10:
Simon Glass2a006332022-10-06 08:36:03 -0600313 return (colours[idx].r << 22) |
314 (colours[idx].g << 12) |
315 (colours[idx].b << 2);
Michal Simek985eac82023-05-17 10:42:07 +0200316 case VIDEO_RGBA8888:
317 return (colours[idx].r << 24) |
318 (colours[idx].g << 16) |
319 (colours[idx].b << 8) | 0xff;
320 default:
Simon Glass2a006332022-10-06 08:36:03 -0600321 return (colours[idx].r << 16) |
322 (colours[idx].g << 8) |
323 (colours[idx].b << 0);
Michal Simek985eac82023-05-17 10:42:07 +0200324 }
Simon Glass2a006332022-10-06 08:36:03 -0600325 }
326 break;
327 default:
328 break;
329 }
330
331 /*
332 * For unknown bit arrangements just support
333 * black and white.
334 */
335 if (idx)
336 return 0xffffff; /* white */
337
338 return 0x000000; /* black */
339}
340
Simon Glass2b063b82018-11-06 15:21:36 -0700341void video_set_default_colors(struct udevice *dev, bool invert)
Heinrich Schuchardt290e1d82018-02-08 21:47:11 +0100342{
Simon Glass2b063b82018-11-06 15:21:36 -0700343 struct video_priv *priv = dev_get_uclass_priv(dev);
344 int fore, back;
345
Simon Glass05c17d62019-12-20 18:10:37 -0700346 if (CONFIG_IS_ENABLED(SYS_WHITE_ON_BLACK)) {
347 /* White is used when switching to bold, use light gray here */
348 fore = VID_LIGHT_GRAY;
349 back = VID_BLACK;
350 } else {
351 fore = VID_BLACK;
352 back = VID_WHITE;
353 }
Simon Glass2b063b82018-11-06 15:21:36 -0700354 if (invert) {
355 int temp;
356
357 temp = fore;
358 fore = back;
359 back = temp;
360 }
361 priv->fg_col_idx = fore;
Andre Przywara4ed5bc82019-03-23 01:29:56 +0000362 priv->bg_col_idx = back;
Simon Glass2a006332022-10-06 08:36:03 -0600363 priv->colour_fg = video_index_to_colour(priv, fore);
364 priv->colour_bg = video_index_to_colour(priv, back);
Heinrich Schuchardt290e1d82018-02-08 21:47:11 +0100365}
366
Simon Glass623d28f2016-01-18 19:52:15 -0700367/* Flush video activity to the caches */
Michal Simek632e3d42020-12-14 08:47:52 +0100368int video_sync(struct udevice *vid, bool force)
Simon Glass623d28f2016-01-18 19:52:15 -0700369{
Simon Glass7f6280f2024-07-31 08:44:09 -0600370 struct video_priv *priv = dev_get_uclass_priv(vid);
Michal Simek8ae95df2020-12-03 09:30:00 +0100371 struct video_ops *ops = video_get_ops(vid);
372 int ret;
373
374 if (ops && ops->video_sync) {
375 ret = ops->video_sync(vid);
376 if (ret)
377 return ret;
378 }
379
Simon Glasse0337a52024-07-31 08:44:10 -0600380 if (CONFIG_IS_ENABLED(CYCLIC) && !force &&
381 get_timer(priv->last_sync) < CONFIG_VIDEO_SYNC_MS)
382 return 0;
383
Simon Glass623d28f2016-01-18 19:52:15 -0700384 /*
385 * flush_dcache_range() is declared in common.h but it seems that some
386 * architectures do not actually implement it. Is there a way to find
387 * out whether it exists? For now, ARM is safe.
388 */
Trevor Woerner43ec7e02019-05-03 09:41:00 -0400389#if defined(CONFIG_ARM) && !CONFIG_IS_ENABLED(SYS_DCACHE_OFF)
Simon Glass623d28f2016-01-18 19:52:15 -0700390 if (priv->flush_dcache) {
391 flush_dcache_range((ulong)priv->fb,
Simon Glasseebc3fd2016-11-13 14:22:06 -0700392 ALIGN((ulong)priv->fb + priv->fb_size,
393 CONFIG_SYS_CACHELINE_SIZE));
Simon Glass623d28f2016-01-18 19:52:15 -0700394 }
395#elif defined(CONFIG_VIDEO_SANDBOX_SDL)
Simon Glasse0337a52024-07-31 08:44:10 -0600396 sandbox_sdl_sync(priv->fb);
Simon Glass623d28f2016-01-18 19:52:15 -0700397#endif
Simon Glasse0337a52024-07-31 08:44:10 -0600398 priv->last_sync = get_timer(0);
399
Michal Simek632e3d42020-12-14 08:47:52 +0100400 return 0;
Simon Glass623d28f2016-01-18 19:52:15 -0700401}
402
403void video_sync_all(void)
404{
405 struct udevice *dev;
Michal Simek632e3d42020-12-14 08:47:52 +0100406 int ret;
Simon Glass623d28f2016-01-18 19:52:15 -0700407
408 for (uclass_find_first_device(UCLASS_VIDEO, &dev);
409 dev;
410 uclass_find_next_device(&dev)) {
Michal Simek632e3d42020-12-14 08:47:52 +0100411 if (device_active(dev)) {
412 ret = video_sync(dev, true);
413 if (ret)
414 dev_dbg(dev, "Video sync failed\n");
415 }
Simon Glass623d28f2016-01-18 19:52:15 -0700416 }
417}
418
Patrick Delaunayefcc84b2021-11-15 16:32:20 +0100419bool video_is_active(void)
420{
421 struct udevice *dev;
422
Devarsh Thakkar42e41062024-02-22 18:38:09 +0530423 /* Assume video to be active if SPL passed video hand-off to U-boot */
424 if (IS_ENABLED(CONFIG_SPL_VIDEO_HANDOFF) && spl_phase() > PHASE_SPL)
425 return true;
426
Patrick Delaunayefcc84b2021-11-15 16:32:20 +0100427 for (uclass_find_first_device(UCLASS_VIDEO, &dev);
428 dev;
429 uclass_find_next_device(&dev)) {
430 if (device_active(dev))
431 return true;
432 }
433
434 return false;
435}
436
Simon Glass623d28f2016-01-18 19:52:15 -0700437int video_get_xsize(struct udevice *dev)
438{
439 struct video_priv *priv = dev_get_uclass_priv(dev);
440
441 return priv->xsize;
442}
443
444int video_get_ysize(struct udevice *dev)
445{
446 struct video_priv *priv = dev_get_uclass_priv(dev);
447
448 return priv->ysize;
449}
450
Simon Glass73c9c372020-07-02 21:12:20 -0600451#ifdef CONFIG_VIDEO_COPY
452int video_sync_copy(struct udevice *dev, void *from, void *to)
453{
454 struct video_priv *priv = dev_get_uclass_priv(dev);
455
456 if (priv->copy_fb) {
457 long offset, size;
458
459 /* Find the offset of the first byte to copy */
460 if ((ulong)to > (ulong)from) {
461 size = to - from;
462 offset = from - priv->fb;
463 } else {
464 size = from - to;
465 offset = to - priv->fb;
466 }
467
468 /*
469 * Allow a bit of leeway for valid requests somewhere near the
470 * frame buffer
471 */
472 if (offset < -priv->fb_size || offset > 2 * priv->fb_size) {
473#ifdef DEBUG
Simon Glass78cdc5d2021-11-19 13:23:51 -0700474 char str[120];
Simon Glass73c9c372020-07-02 21:12:20 -0600475
476 snprintf(str, sizeof(str),
Simon Glass78cdc5d2021-11-19 13:23:51 -0700477 "[** FAULT sync_copy fb=%p, from=%p, to=%p, offset=%lx]",
Simon Glass73c9c372020-07-02 21:12:20 -0600478 priv->fb, from, to, offset);
479 console_puts_select_stderr(true, str);
480#endif
481 return -EFAULT;
482 }
483
484 /*
485 * Silently crop the memcpy. This allows callers to avoid doing
486 * this themselves. It is common for the end pointer to go a
487 * few lines after the end of the frame buffer, since most of
488 * the update algorithms terminate a line after their last write
489 */
490 if (offset + size > priv->fb_size) {
491 size = priv->fb_size - offset;
492 } else if (offset < 0) {
493 size += offset;
494 offset = 0;
495 }
496
497 memcpy(priv->copy_fb + offset, priv->fb + offset, size);
498 }
499
500 return 0;
501}
Simon Glass62b535e2021-01-13 20:29:46 -0700502
503int video_sync_copy_all(struct udevice *dev)
504{
505 struct video_priv *priv = dev_get_uclass_priv(dev);
506
507 video_sync_copy(dev, priv->fb, priv->fb + priv->fb_size);
508
509 return 0;
510}
511
Simon Glass73c9c372020-07-02 21:12:20 -0600512#endif
513
Simon Glass87a3cd72021-11-19 13:24:03 -0700514#define SPLASH_DECL(_name) \
515 extern u8 __splash_ ## _name ## _begin[]; \
516 extern u8 __splash_ ## _name ## _end[]
517
518#define SPLASH_START(_name) __splash_ ## _name ## _begin
519
520SPLASH_DECL(u_boot_logo);
521
Simon Glass22477422022-10-06 08:36:09 -0600522void *video_get_u_boot_logo(void)
523{
524 return SPLASH_START(u_boot_logo);
525}
526
Simon Glass87a3cd72021-11-19 13:24:03 -0700527static int show_splash(struct udevice *dev)
528{
529 u8 *data = SPLASH_START(u_boot_logo);
530 int ret;
531
532 ret = video_bmp_display(dev, map_to_sysmem(data), -4, 4, true);
533
534 return 0;
535}
536
Simon Glass70459902022-10-06 08:36:18 -0600537int video_default_font_height(struct udevice *dev)
538{
539 struct vidconsole_priv *vc_priv = dev_get_uclass_priv(dev);
540
541 if (IS_ENABLED(CONFIG_CONSOLE_TRUETYPE))
542 return IF_ENABLED_INT(CONFIG_CONSOLE_TRUETYPE,
543 CONFIG_CONSOLE_TRUETYPE_SIZE);
544
545 return vc_priv->y_charsize;
546}
547
Simon Glasse0337a52024-07-31 08:44:10 -0600548static void video_idle(struct cyclic_info *cyc)
549{
550 video_sync_all();
551}
552
Simon Glass623d28f2016-01-18 19:52:15 -0700553/* Set up the display ready for use */
554static int video_post_probe(struct udevice *dev)
555{
Simon Glassb75b15b2020-12-03 16:55:23 -0700556 struct video_uc_plat *plat = dev_get_uclass_plat(dev);
Simon Glasse0337a52024-07-31 08:44:10 -0600557 struct video_uc_priv *uc_priv = uclass_get_priv(dev->uclass);
Simon Glass623d28f2016-01-18 19:52:15 -0700558 struct video_priv *priv = dev_get_uclass_priv(dev);
559 char name[30], drv[15], *str;
Simon Glassb3a72b32016-01-14 18:10:48 -0700560 const char *drv_name = drv;
Simon Glass623d28f2016-01-18 19:52:15 -0700561 struct udevice *cons;
562 int ret;
563
564 /* Set up the line and display size */
565 priv->fb = map_sysmem(plat->base, plat->size);
Simon Glass7d186732018-11-29 15:08:52 -0700566 if (!priv->line_length)
567 priv->line_length = priv->xsize * VNBYTES(priv->bpix);
568
Simon Glass623d28f2016-01-18 19:52:15 -0700569 priv->fb_size = priv->line_length * priv->ysize;
570
Devarsh Thakkarf5254cc2023-12-05 21:25:21 +0530571 /*
572 * Set up video handoff fields for passing video blob to next stage
573 * NOTE:
574 * This assumes that reserved video memory only uses a single framebuffer
575 */
576 if (spl_phase() == PHASE_SPL && CONFIG_IS_ENABLED(BLOBLIST)) {
577 struct video_handoff *ho;
578
579 ho = bloblist_add(BLOBLISTT_U_BOOT_VIDEO, sizeof(*ho), 0);
580 if (!ho)
581 return log_msg_ret("blf", -ENOENT);
582 ho->fb = gd->video_bottom;
583 /* Fill aligned size here as calculated in video_reserve() */
584 ho->size = gd->video_top - gd->video_bottom;
585 ho->xsize = priv->xsize;
586 ho->ysize = priv->ysize;
587 ho->line_length = priv->line_length;
588 ho->bpix = priv->bpix;
589 }
590
Simon Glassb4928e52020-07-02 21:12:21 -0600591 if (IS_ENABLED(CONFIG_VIDEO_COPY) && plat->copy_base)
592 priv->copy_fb = map_sysmem(plat->copy_base, plat->size);
593
Heinrich Schuchardt290e1d82018-02-08 21:47:11 +0100594 /* Set up colors */
Simon Glass2b063b82018-11-06 15:21:36 -0700595 video_set_default_colors(dev, false);
Rob Clarkf1411882017-08-03 12:47:01 -0400596
597 if (!CONFIG_IS_ENABLED(NO_FB_CLEAR))
598 video_clear(dev);
Simon Glass623d28f2016-01-18 19:52:15 -0700599
Simon Glass84c7fb32016-01-18 19:52:17 -0700600 /*
Simon Glassb3a72b32016-01-14 18:10:48 -0700601 * Create a text console device. For now we always do this, although
Simon Glass84c7fb32016-01-18 19:52:17 -0700602 * it might be useful to support only bitmap drawing on the device
Simon Glassb3a72b32016-01-14 18:10:48 -0700603 * for boards that don't need to display text. We create a TrueType
604 * console if enabled, a rotated console if the video driver requests
605 * it, otherwise a normal console.
606 *
607 * The console can be override by setting vidconsole_drv_name before
608 * probing this video driver, or in the probe() method.
609 *
610 * TrueType does not support rotation at present so fall back to the
611 * rotated console in that case.
Simon Glass84c7fb32016-01-18 19:52:17 -0700612 */
Simon Glassb3a72b32016-01-14 18:10:48 -0700613 if (!priv->rot && IS_ENABLED(CONFIG_CONSOLE_TRUETYPE)) {
Simon Glass2ef353e2016-01-14 18:10:42 -0700614 snprintf(name, sizeof(name), "%s.vidconsole_tt", dev->name);
615 strcpy(drv, "vidconsole_tt");
616 } else {
617 snprintf(name, sizeof(name), "%s.vidconsole%d", dev->name,
618 priv->rot);
619 snprintf(drv, sizeof(drv), "vidconsole%d", priv->rot);
620 }
621
Simon Glass84c7fb32016-01-18 19:52:17 -0700622 str = strdup(name);
623 if (!str)
624 return -ENOMEM;
Simon Glassb3a72b32016-01-14 18:10:48 -0700625 if (priv->vidconsole_drv_name)
626 drv_name = priv->vidconsole_drv_name;
627 ret = device_bind_driver(dev, drv_name, str, &cons);
Simon Glass84c7fb32016-01-18 19:52:17 -0700628 if (ret) {
629 debug("%s: Cannot bind console driver\n", __func__);
630 return ret;
631 }
Simon Glassb3a72b32016-01-14 18:10:48 -0700632
Simon Glass84c7fb32016-01-18 19:52:17 -0700633 ret = device_probe(cons);
634 if (ret) {
635 debug("%s: Cannot probe console driver\n", __func__);
636 return ret;
637 }
638
Nikhil M Jain9e3301d2023-04-20 17:41:08 +0530639 if (CONFIG_IS_ENABLED(VIDEO_LOGO) &&
640 !CONFIG_IS_ENABLED(SPLASH_SCREEN) && !plat->hide_logo) {
Simon Glass87a3cd72021-11-19 13:24:03 -0700641 ret = show_splash(dev);
642 if (ret) {
643 log_debug("Cannot show splash screen\n");
644 return ret;
645 }
646 }
647
Simon Glasse0337a52024-07-31 08:44:10 -0600648 /* register cyclic as soon as the first video device is probed */
649 if (CONFIG_IS_ENABLED(CYCLIC) && (gd->flags && GD_FLG_RELOC) &&
650 !uc_priv->cyc_active) {
651 uint ms = CONFIG_IF_ENABLED_INT(CYCLIC, VIDEO_SYNC_CYCLIC_MS);
652
653 cyclic_register(&uc_priv->cyc, video_idle, ms * 1000,
654 "video_init");
655 uc_priv->cyc_active = true;
656 }
657
Simon Glass623d28f2016-01-18 19:52:15 -0700658 return 0;
659};
660
661/* Post-relocation, allocate memory for the frame buffer */
662static int video_post_bind(struct udevice *dev)
663{
Simon Glass951255d2020-07-02 21:12:32 -0600664 struct video_uc_priv *uc_priv;
665 ulong addr;
Simon Glass623d28f2016-01-18 19:52:15 -0700666 ulong size;
667
668 /* Before relocation there is nothing to do here */
Tom Rini6985a722018-04-22 09:47:48 -0400669 if (!(gd->flags & GD_FLG_RELOC))
Simon Glass623d28f2016-01-18 19:52:15 -0700670 return 0;
Simon Glass951255d2020-07-02 21:12:32 -0600671
672 /* Set up the video pointer, if this is the first device */
Simon Glass95588622020-12-22 19:30:28 -0700673 uc_priv = uclass_get_priv(dev->uclass);
Simon Glass951255d2020-07-02 21:12:32 -0600674 if (!uc_priv->video_ptr)
675 uc_priv->video_ptr = gd->video_top;
676
677 /* Allocate framebuffer space for this device */
678 addr = uc_priv->video_ptr;
Simon Glass623d28f2016-01-18 19:52:15 -0700679 size = alloc_fb(dev, &addr);
680 if (addr < gd->video_bottom) {
Bin Mengacbafdd2023-07-23 12:40:24 +0800681 /*
682 * Device tree node may need the 'bootph-all' or
Simon Glassfc1aa352023-02-13 08:56:34 -0700683 * 'bootph-some-ram' tag
Patrick Delaunayd1937182019-05-21 19:19:12 +0200684 */
Bin Mengacbafdd2023-07-23 12:40:24 +0800685 printf("Video device '%s' cannot allocate frame buffer memory "
686 "- ensure the device is set up before relocation\n",
Simon Glass623d28f2016-01-18 19:52:15 -0700687 dev->name);
688 return -ENOSPC;
689 }
690 debug("%s: Claiming %lx bytes at %lx for video device '%s'\n",
691 __func__, size, addr, dev->name);
Simon Glass951255d2020-07-02 21:12:32 -0600692 uc_priv->video_ptr = addr;
Simon Glass623d28f2016-01-18 19:52:15 -0700693
694 return 0;
695}
696
Simon Glasse0337a52024-07-31 08:44:10 -0600697__maybe_unused static int video_destroy(struct uclass *uc)
698{
699 struct video_uc_priv *uc_priv = uclass_get_priv(uc);
700
701 if (uc_priv->cyc_active) {
702 cyclic_unregister(&uc_priv->cyc);
703 uc_priv->cyc_active = false;
704 }
705
706 return 0;
707}
708
Simon Glass623d28f2016-01-18 19:52:15 -0700709UCLASS_DRIVER(video) = {
710 .id = UCLASS_VIDEO,
711 .name = "video",
712 .flags = DM_UC_FLAG_SEQ_ALIAS,
713 .post_bind = video_post_bind,
Simon Glass623d28f2016-01-18 19:52:15 -0700714 .post_probe = video_post_probe,
Simon Glass8a2b47f2020-12-03 16:55:17 -0700715 .priv_auto = sizeof(struct video_uc_priv),
716 .per_device_auto = sizeof(struct video_priv),
Simon Glassb75b15b2020-12-03 16:55:23 -0700717 .per_device_plat_auto = sizeof(struct video_uc_plat),
Simon Glasse0337a52024-07-31 08:44:10 -0600718 CONFIG_IS_ENABLED(CYCLIC, (.destroy = video_destroy, ))
Simon Glass623d28f2016-01-18 19:52:15 -0700719};