Tom Rini | 10e4779 | 2018-05-06 17:58:06 -0400 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0+ |
Simon Glass | 68b2627 | 2016-01-18 19:52:22 -0700 | [diff] [blame] | 2 | /* |
| 3 | * Copyright (c) 2015 Google, Inc |
Simon Glass | 68b2627 | 2016-01-18 19:52:22 -0700 | [diff] [blame] | 4 | */ |
| 5 | |
| 6 | #include <common.h> |
| 7 | #include <bmp_layout.h> |
| 8 | #include <dm.h> |
Simon Glass | 0f2af88 | 2020-05-10 11:40:05 -0600 | [diff] [blame] | 9 | #include <log.h> |
Simon Glass | 68b2627 | 2016-01-18 19:52:22 -0700 | [diff] [blame] | 10 | #include <mapmem.h> |
Anatolij Gustschin | 410f096 | 2018-12-01 15:30:08 +0100 | [diff] [blame] | 11 | #include <splash.h> |
Simon Glass | 68b2627 | 2016-01-18 19:52:22 -0700 | [diff] [blame] | 12 | #include <video.h> |
| 13 | #include <watchdog.h> |
| 14 | #include <asm/unaligned.h> |
| 15 | |
Simon Glass | 68b2627 | 2016-01-18 19:52:22 -0700 | [diff] [blame] | 16 | #define BMP_RLE8_ESCAPE 0 |
| 17 | #define BMP_RLE8_EOL 0 |
| 18 | #define BMP_RLE8_EOBMP 1 |
| 19 | #define BMP_RLE8_DELTA 2 |
| 20 | |
Simon Glass | 998e16a | 2021-11-19 13:23:54 -0700 | [diff] [blame] | 21 | /** |
| 22 | * get_bmp_col_16bpp() - Convert a colour-table entry into a 16bpp pixel value |
| 23 | * |
| 24 | * @return value to write to the 16bpp frame buffer for this palette entry |
| 25 | */ |
| 26 | static uint get_bmp_col_16bpp(struct bmp_color_table_entry cte) |
| 27 | { |
| 28 | return ((cte.red << 8) & 0xf800) | |
| 29 | ((cte.green << 3) & 0x07e0) | |
| 30 | ((cte.blue >> 3) & 0x001f); |
| 31 | } |
| 32 | |
| 33 | /** |
| 34 | * write_pix8() - Write a pixel from a BMP image into the framebuffer |
| 35 | * |
| 36 | * This handles frame buffers with 8, 16, 24 or 32 bits per pixel |
| 37 | * |
| 38 | * @fb: Place in frame buffer to update |
| 39 | * @bpix: Frame buffer bits-per-pixel, which controls how many bytes are written |
| 40 | * @palette: BMP palette table |
| 41 | * @bmap: Pointer to BMP bitmap position to write. This contains a single byte |
| 42 | * which is either written directly (bpix == 8) or used to look up the |
| 43 | * palette to get a colour to write |
| 44 | */ |
| 45 | static void write_pix8(u8 *fb, uint bpix, struct bmp_color_table_entry *palette, |
| 46 | u8 *bmap) |
| 47 | { |
| 48 | if (bpix == 8) { |
| 49 | *fb++ = *bmap; |
| 50 | } else if (bpix == 16) { |
| 51 | *(u16 *)fb = get_bmp_col_16bpp(palette[*bmap]); |
| 52 | } else { |
| 53 | /* Only support big endian */ |
| 54 | struct bmp_color_table_entry *cte = &palette[*bmap]; |
| 55 | |
| 56 | if (bpix == 24) { |
| 57 | *fb++ = cte->red; |
| 58 | *fb++ = cte->green; |
| 59 | *fb++ = cte->blue; |
| 60 | } else { |
| 61 | *fb++ = cte->blue; |
| 62 | *fb++ = cte->green; |
| 63 | *fb++ = cte->red; |
| 64 | *fb++ = 0; |
| 65 | } |
| 66 | } |
| 67 | } |
| 68 | |
| 69 | #ifdef CONFIG_VIDEO_BMP_RLE8 |
Simon Glass | 490bb99 | 2021-11-19 13:23:55 -0700 | [diff] [blame] | 70 | static void draw_unencoded_bitmap(u8 **fbp, uint bpix, uchar *bmap, |
| 71 | struct bmp_color_table_entry *palette, |
Simon Glass | 68b2627 | 2016-01-18 19:52:22 -0700 | [diff] [blame] | 72 | int cnt) |
| 73 | { |
Simon Glass | 490bb99 | 2021-11-19 13:23:55 -0700 | [diff] [blame] | 74 | u8 *fb = *fbp; |
| 75 | |
Simon Glass | 68b2627 | 2016-01-18 19:52:22 -0700 | [diff] [blame] | 76 | while (cnt > 0) { |
Simon Glass | 490bb99 | 2021-11-19 13:23:55 -0700 | [diff] [blame] | 77 | write_pix8(fb, bpix, palette, bmap++); |
| 78 | fb += bpix / 8; |
Simon Glass | 68b2627 | 2016-01-18 19:52:22 -0700 | [diff] [blame] | 79 | cnt--; |
| 80 | } |
Simon Glass | 490bb99 | 2021-11-19 13:23:55 -0700 | [diff] [blame] | 81 | *fbp = fb; |
Simon Glass | 68b2627 | 2016-01-18 19:52:22 -0700 | [diff] [blame] | 82 | } |
| 83 | |
Simon Glass | 490bb99 | 2021-11-19 13:23:55 -0700 | [diff] [blame] | 84 | static void draw_encoded_bitmap(u8 **fbp, uint bpix, |
| 85 | struct bmp_color_table_entry *palette, u8 *bmap, |
| 86 | int cnt) |
Simon Glass | 68b2627 | 2016-01-18 19:52:22 -0700 | [diff] [blame] | 87 | { |
Simon Glass | 490bb99 | 2021-11-19 13:23:55 -0700 | [diff] [blame] | 88 | u8 *fb = *fbp; |
Simon Glass | 68b2627 | 2016-01-18 19:52:22 -0700 | [diff] [blame] | 89 | |
| 90 | while (cnt > 0) { |
Simon Glass | 490bb99 | 2021-11-19 13:23:55 -0700 | [diff] [blame] | 91 | write_pix8(fb, bpix, palette, bmap); |
| 92 | fb += bpix / 8; |
Simon Glass | 68b2627 | 2016-01-18 19:52:22 -0700 | [diff] [blame] | 93 | cnt--; |
| 94 | } |
| 95 | *fbp = fb; |
| 96 | } |
| 97 | |
| 98 | static void video_display_rle8_bitmap(struct udevice *dev, |
Simon Glass | 490bb99 | 2021-11-19 13:23:55 -0700 | [diff] [blame] | 99 | struct bmp_image *bmp, uint bpix, |
| 100 | struct bmp_color_table_entry *palette, |
Patrice Chotard | cb30f7d | 2019-11-20 14:11:16 +0100 | [diff] [blame] | 101 | uchar *fb, int x_off, int y_off, |
| 102 | ulong width, ulong height) |
Simon Glass | 68b2627 | 2016-01-18 19:52:22 -0700 | [diff] [blame] | 103 | { |
| 104 | struct video_priv *priv = dev_get_uclass_priv(dev); |
| 105 | uchar *bmap; |
Simon Glass | 68b2627 | 2016-01-18 19:52:22 -0700 | [diff] [blame] | 106 | ulong cnt, runlen; |
| 107 | int x, y; |
| 108 | int decode = 1; |
Simon Glass | 490bb99 | 2021-11-19 13:23:55 -0700 | [diff] [blame] | 109 | uint bytes_per_pixel = bpix / 8; |
Simon Glass | 68b2627 | 2016-01-18 19:52:22 -0700 | [diff] [blame] | 110 | |
| 111 | debug("%s\n", __func__); |
Simon Glass | 68b2627 | 2016-01-18 19:52:22 -0700 | [diff] [blame] | 112 | bmap = (uchar *)bmp + get_unaligned_le32(&bmp->header.data_offset); |
| 113 | |
| 114 | x = 0; |
| 115 | y = height - 1; |
| 116 | |
| 117 | while (decode) { |
| 118 | if (bmap[0] == BMP_RLE8_ESCAPE) { |
| 119 | switch (bmap[1]) { |
| 120 | case BMP_RLE8_EOL: |
| 121 | /* end of line */ |
| 122 | bmap += 2; |
| 123 | x = 0; |
| 124 | y--; |
Simon Glass | 490bb99 | 2021-11-19 13:23:55 -0700 | [diff] [blame] | 125 | fb -= width * bytes_per_pixel + |
| 126 | priv->line_length; |
Simon Glass | 68b2627 | 2016-01-18 19:52:22 -0700 | [diff] [blame] | 127 | break; |
| 128 | case BMP_RLE8_EOBMP: |
| 129 | /* end of bitmap */ |
| 130 | decode = 0; |
| 131 | break; |
| 132 | case BMP_RLE8_DELTA: |
| 133 | /* delta run */ |
| 134 | x += bmap[2]; |
| 135 | y -= bmap[3]; |
Simon Glass | 490bb99 | 2021-11-19 13:23:55 -0700 | [diff] [blame] | 136 | fb = (uchar *)(priv->fb + |
| 137 | (y + y_off - 1) * priv->line_length + |
| 138 | (x + x_off) * bytes_per_pixel); |
Simon Glass | 68b2627 | 2016-01-18 19:52:22 -0700 | [diff] [blame] | 139 | bmap += 4; |
| 140 | break; |
| 141 | default: |
| 142 | /* unencoded run */ |
| 143 | runlen = bmap[1]; |
| 144 | bmap += 2; |
| 145 | if (y < height) { |
| 146 | if (x < width) { |
| 147 | if (x + runlen > width) |
| 148 | cnt = width - x; |
| 149 | else |
| 150 | cnt = runlen; |
| 151 | draw_unencoded_bitmap( |
Simon Glass | 490bb99 | 2021-11-19 13:23:55 -0700 | [diff] [blame] | 152 | &fb, bpix, |
| 153 | bmap, palette, cnt); |
Simon Glass | 68b2627 | 2016-01-18 19:52:22 -0700 | [diff] [blame] | 154 | } |
| 155 | x += runlen; |
| 156 | } |
| 157 | bmap += runlen; |
| 158 | if (runlen & 1) |
| 159 | bmap++; |
| 160 | } |
| 161 | } else { |
| 162 | /* encoded run */ |
| 163 | if (y < height) { |
| 164 | runlen = bmap[0]; |
| 165 | if (x < width) { |
| 166 | /* aggregate the same code */ |
| 167 | while (bmap[0] == 0xff && |
| 168 | bmap[2] != BMP_RLE8_ESCAPE && |
| 169 | bmap[1] == bmap[3]) { |
| 170 | runlen += bmap[2]; |
| 171 | bmap += 2; |
| 172 | } |
| 173 | if (x + runlen > width) |
| 174 | cnt = width - x; |
| 175 | else |
| 176 | cnt = runlen; |
Simon Glass | 490bb99 | 2021-11-19 13:23:55 -0700 | [diff] [blame] | 177 | draw_encoded_bitmap(&fb, bpix, palette, |
| 178 | &bmap[1], cnt); |
Simon Glass | 68b2627 | 2016-01-18 19:52:22 -0700 | [diff] [blame] | 179 | } |
| 180 | x += runlen; |
| 181 | } |
| 182 | bmap += 2; |
| 183 | } |
| 184 | } |
| 185 | } |
| 186 | #endif |
| 187 | |
Simon Glass | 68b2627 | 2016-01-18 19:52:22 -0700 | [diff] [blame] | 188 | /** |
| 189 | * video_splash_align_axis() - Align a single coordinate |
| 190 | * |
| 191 | *- if a coordinate is 0x7fff then the image will be centred in |
| 192 | * that direction |
| 193 | *- if a coordinate is -ve then it will be offset to the |
| 194 | * left/top of the centre by that many pixels |
| 195 | *- if a coordinate is positive it will be used unchnaged. |
| 196 | * |
| 197 | * @axis: Input and output coordinate |
| 198 | * @panel_size: Size of panel in pixels for that axis |
| 199 | * @picture_size: Size of bitmap in pixels for that axis |
| 200 | */ |
| 201 | static void video_splash_align_axis(int *axis, unsigned long panel_size, |
| 202 | unsigned long picture_size) |
| 203 | { |
Patrice Chotard | 066eace | 2019-11-20 14:11:15 +0100 | [diff] [blame] | 204 | long panel_picture_delta = panel_size - picture_size; |
| 205 | long axis_alignment; |
Simon Glass | 68b2627 | 2016-01-18 19:52:22 -0700 | [diff] [blame] | 206 | |
| 207 | if (*axis == BMP_ALIGN_CENTER) |
| 208 | axis_alignment = panel_picture_delta / 2; |
| 209 | else if (*axis < 0) |
| 210 | axis_alignment = panel_picture_delta + *axis + 1; |
| 211 | else |
| 212 | return; |
| 213 | |
| 214 | *axis = max(0, (int)axis_alignment); |
| 215 | } |
| 216 | |
Simon Glass | 68b2627 | 2016-01-18 19:52:22 -0700 | [diff] [blame] | 217 | int video_bmp_display(struct udevice *dev, ulong bmp_image, int x, int y, |
| 218 | bool align) |
| 219 | { |
| 220 | struct video_priv *priv = dev_get_uclass_priv(dev); |
Simon Glass | 1f47573 | 2016-01-30 15:45:16 -0700 | [diff] [blame] | 221 | int i, j; |
Simon Glass | 4761c8c | 2020-07-02 21:12:27 -0600 | [diff] [blame] | 222 | uchar *start, *fb; |
Simon Glass | 68b2627 | 2016-01-18 19:52:22 -0700 | [diff] [blame] | 223 | struct bmp_image *bmp = map_sysmem(bmp_image, 0); |
| 224 | uchar *bmap; |
| 225 | ushort padded_width; |
| 226 | unsigned long width, height, byte_width; |
| 227 | unsigned long pwidth = priv->xsize; |
| 228 | unsigned colours, bpix, bmp_bpix; |
| 229 | struct bmp_color_table_entry *palette; |
| 230 | int hdr_size; |
Simon Glass | 4761c8c | 2020-07-02 21:12:27 -0600 | [diff] [blame] | 231 | int ret; |
Simon Glass | 68b2627 | 2016-01-18 19:52:22 -0700 | [diff] [blame] | 232 | |
| 233 | if (!bmp || !(bmp->header.signature[0] == 'B' && |
| 234 | bmp->header.signature[1] == 'M')) { |
| 235 | printf("Error: no valid bmp image at %lx\n", bmp_image); |
| 236 | |
| 237 | return -EINVAL; |
| 238 | } |
| 239 | |
| 240 | width = get_unaligned_le32(&bmp->header.width); |
| 241 | height = get_unaligned_le32(&bmp->header.height); |
| 242 | bmp_bpix = get_unaligned_le16(&bmp->header.bit_count); |
| 243 | hdr_size = get_unaligned_le16(&bmp->header.size); |
| 244 | debug("hdr_size=%d, bmp_bpix=%d\n", hdr_size, bmp_bpix); |
| 245 | palette = (void *)bmp + 14 + hdr_size; |
| 246 | |
| 247 | colours = 1 << bmp_bpix; |
| 248 | |
| 249 | bpix = VNBITS(priv->bpix); |
| 250 | |
| 251 | if (bpix != 1 && bpix != 8 && bpix != 16 && bpix != 32) { |
| 252 | printf("Error: %d bit/pixel mode, but BMP has %d bit/pixel\n", |
| 253 | bpix, bmp_bpix); |
| 254 | |
| 255 | return -EINVAL; |
| 256 | } |
| 257 | |
| 258 | /* |
Stefan Roese | 7ee599e | 2019-01-30 08:54:12 +0100 | [diff] [blame] | 259 | * We support displaying 8bpp and 24bpp BMPs on 16bpp LCDs |
Simon Glass | 68b2627 | 2016-01-18 19:52:22 -0700 | [diff] [blame] | 260 | * and displaying 24bpp BMPs on 32bpp LCDs |
Stefan Roese | 7ee599e | 2019-01-30 08:54:12 +0100 | [diff] [blame] | 261 | */ |
Simon Glass | 68b2627 | 2016-01-18 19:52:22 -0700 | [diff] [blame] | 262 | if (bpix != bmp_bpix && |
| 263 | !(bmp_bpix == 8 && bpix == 16) && |
Ye Li | b5c864d | 2020-06-10 02:52:23 -0700 | [diff] [blame] | 264 | !(bmp_bpix == 8 && bpix == 24) && |
| 265 | !(bmp_bpix == 8 && bpix == 32) && |
Stefan Roese | 7ee599e | 2019-01-30 08:54:12 +0100 | [diff] [blame] | 266 | !(bmp_bpix == 24 && bpix == 16) && |
Simon Glass | 68b2627 | 2016-01-18 19:52:22 -0700 | [diff] [blame] | 267 | !(bmp_bpix == 24 && bpix == 32)) { |
| 268 | printf("Error: %d bit/pixel mode, but BMP has %d bit/pixel\n", |
| 269 | bpix, get_unaligned_le16(&bmp->header.bit_count)); |
| 270 | return -EPERM; |
| 271 | } |
| 272 | |
| 273 | debug("Display-bmp: %d x %d with %d colours, display %d\n", |
| 274 | (int)width, (int)height, (int)colours, 1 << bpix); |
| 275 | |
Simon Glass | 68b2627 | 2016-01-18 19:52:22 -0700 | [diff] [blame] | 276 | padded_width = (width & 0x3 ? (width & ~0x3) + 4 : width); |
| 277 | |
| 278 | if (align) { |
| 279 | video_splash_align_axis(&x, priv->xsize, width); |
| 280 | video_splash_align_axis(&y, priv->ysize, height); |
| 281 | } |
| 282 | |
| 283 | if ((x + width) > pwidth) |
| 284 | width = pwidth - x; |
| 285 | if ((y + height) > priv->ysize) |
| 286 | height = priv->ysize - y; |
| 287 | |
| 288 | bmap = (uchar *)bmp + get_unaligned_le32(&bmp->header.data_offset); |
Simon Glass | 4761c8c | 2020-07-02 21:12:27 -0600 | [diff] [blame] | 289 | start = (uchar *)(priv->fb + |
| 290 | (y + height) * priv->line_length + x * bpix / 8); |
| 291 | |
| 292 | /* Move back to the final line to be drawn */ |
| 293 | fb = start - priv->line_length; |
Simon Glass | 68b2627 | 2016-01-18 19:52:22 -0700 | [diff] [blame] | 294 | |
| 295 | switch (bmp_bpix) { |
| 296 | case 1: |
| 297 | case 8: { |
Simon Glass | 68b2627 | 2016-01-18 19:52:22 -0700 | [diff] [blame] | 298 | #ifdef CONFIG_VIDEO_BMP_RLE8 |
| 299 | u32 compression = get_unaligned_le32(&bmp->header.compression); |
| 300 | debug("compressed %d %d\n", compression, BMP_BI_RLE8); |
| 301 | if (compression == BMP_BI_RLE8) { |
Simon Glass | 490bb99 | 2021-11-19 13:23:55 -0700 | [diff] [blame] | 302 | video_display_rle8_bitmap(dev, bmp, bpix, palette, fb, |
| 303 | x, y, width, height); |
Simon Glass | 68b2627 | 2016-01-18 19:52:22 -0700 | [diff] [blame] | 304 | break; |
| 305 | } |
| 306 | #endif |
Ye Li | b5c864d | 2020-06-10 02:52:23 -0700 | [diff] [blame] | 307 | byte_width = width * (bpix / 8); |
| 308 | if (!byte_width) |
Simon Glass | 68b2627 | 2016-01-18 19:52:22 -0700 | [diff] [blame] | 309 | byte_width = width; |
Simon Glass | 68b2627 | 2016-01-18 19:52:22 -0700 | [diff] [blame] | 310 | |
| 311 | for (i = 0; i < height; ++i) { |
| 312 | WATCHDOG_RESET(); |
| 313 | for (j = 0; j < width; j++) { |
Simon Glass | 998e16a | 2021-11-19 13:23:54 -0700 | [diff] [blame] | 314 | write_pix8(fb, bpix, palette, bmap); |
| 315 | bmap++; |
| 316 | fb += bpix / 8; |
Simon Glass | 68b2627 | 2016-01-18 19:52:22 -0700 | [diff] [blame] | 317 | } |
| 318 | bmap += (padded_width - width); |
| 319 | fb -= byte_width + priv->line_length; |
| 320 | } |
| 321 | break; |
| 322 | } |
| 323 | #if defined(CONFIG_BMP_16BPP) |
| 324 | case 16: |
| 325 | for (i = 0; i < height; ++i) { |
| 326 | WATCHDOG_RESET(); |
Simon Glass | aa662a6 | 2021-11-19 13:23:53 -0700 | [diff] [blame] | 327 | for (j = 0; j < width; j++) { |
| 328 | *fb++ = *bmap++; |
| 329 | *fb++ = *bmap++; |
| 330 | } |
Sylwester Nawrocki | 17e65b3 | 2020-12-01 12:30:50 +0100 | [diff] [blame] | 331 | bmap += (padded_width - width); |
Stefan Roese | 956e339 | 2016-11-12 10:32:38 +0100 | [diff] [blame] | 332 | fb -= width * 2 + priv->line_length; |
Simon Glass | 68b2627 | 2016-01-18 19:52:22 -0700 | [diff] [blame] | 333 | } |
| 334 | break; |
| 335 | #endif /* CONFIG_BMP_16BPP */ |
Philipp Tomsich | 5cfa3f4 | 2017-05-05 21:48:30 +0200 | [diff] [blame] | 336 | #if defined(CONFIG_BMP_24BPP) |
Simon Glass | 68b2627 | 2016-01-18 19:52:22 -0700 | [diff] [blame] | 337 | case 24: |
| 338 | for (i = 0; i < height; ++i) { |
| 339 | for (j = 0; j < width; j++) { |
Stefan Roese | 7ee599e | 2019-01-30 08:54:12 +0100 | [diff] [blame] | 340 | if (bpix == 16) { |
| 341 | /* 16bit 555RGB format */ |
| 342 | *(u16 *)fb = ((bmap[2] >> 3) << 10) | |
| 343 | ((bmap[1] >> 3) << 5) | |
| 344 | (bmap[0] >> 3); |
| 345 | bmap += 3; |
| 346 | fb += 2; |
| 347 | } else { |
| 348 | *(fb++) = *(bmap++); |
| 349 | *(fb++) = *(bmap++); |
| 350 | *(fb++) = *(bmap++); |
| 351 | *(fb++) = 0; |
| 352 | } |
Simon Glass | 68b2627 | 2016-01-18 19:52:22 -0700 | [diff] [blame] | 353 | } |
Stefan Roese | 956e339 | 2016-11-12 10:32:38 +0100 | [diff] [blame] | 354 | fb -= priv->line_length + width * (bpix / 8); |
Sylwester Nawrocki | 17e65b3 | 2020-12-01 12:30:50 +0100 | [diff] [blame] | 355 | bmap += (padded_width - width); |
Simon Glass | 68b2627 | 2016-01-18 19:52:22 -0700 | [diff] [blame] | 356 | } |
| 357 | break; |
Philipp Tomsich | 5cfa3f4 | 2017-05-05 21:48:30 +0200 | [diff] [blame] | 358 | #endif /* CONFIG_BMP_24BPP */ |
Simon Glass | 68b2627 | 2016-01-18 19:52:22 -0700 | [diff] [blame] | 359 | #if defined(CONFIG_BMP_32BPP) |
| 360 | case 32: |
| 361 | for (i = 0; i < height; ++i) { |
| 362 | for (j = 0; j < width; j++) { |
| 363 | *(fb++) = *(bmap++); |
| 364 | *(fb++) = *(bmap++); |
| 365 | *(fb++) = *(bmap++); |
| 366 | *(fb++) = *(bmap++); |
| 367 | } |
Stefan Roese | 956e339 | 2016-11-12 10:32:38 +0100 | [diff] [blame] | 368 | fb -= priv->line_length + width * (bpix / 8); |
Simon Glass | 68b2627 | 2016-01-18 19:52:22 -0700 | [diff] [blame] | 369 | } |
| 370 | break; |
| 371 | #endif /* CONFIG_BMP_32BPP */ |
| 372 | default: |
| 373 | break; |
| 374 | }; |
| 375 | |
Simon Glass | 4761c8c | 2020-07-02 21:12:27 -0600 | [diff] [blame] | 376 | /* Find the position of the top left of the image in the framebuffer */ |
| 377 | fb = (uchar *)(priv->fb + y * priv->line_length + x * bpix / 8); |
| 378 | ret = video_sync_copy(dev, start, fb); |
| 379 | if (ret) |
| 380 | return log_ret(ret); |
| 381 | |
Michal Simek | 632e3d4 | 2020-12-14 08:47:52 +0100 | [diff] [blame] | 382 | return video_sync(dev, false); |
Simon Glass | 68b2627 | 2016-01-18 19:52:22 -0700 | [diff] [blame] | 383 | } |