1/* 2 * Video uclass to support displays (see also vidconsole for text) 3 * 4 * Copyright (c) 2015 Google, Inc 5 */ 6 7#ifndef _VIDEO_H_ 8#define _VIDEO_H_ 9 10#include <stdio_dev.h> 11 12struct udevice; 13 14/** 15 * struct video_uc_plat - uclass platform data for a video device 16 * 17 * This holds information that the uclass needs to know about each device. It 18 * is accessed using dev_get_uclass_plat(dev). See 'Theory of operation' at 19 * the top of video-uclass.c for details on how this information is set. 20 * 21 * @align: Frame-buffer alignment, indicating the memory boundary the frame 22 * buffer should start on. If 0, 1MB is assumed 23 * @size: Frame-buffer size, in bytes 24 * @base: Base address of frame buffer, 0 if not yet known. If CONFIG_VIDEO_COPY 25 * is enabled, this is the software copy, so writes to this will not be 26 * visible until vidconsole_sync_copy() is called. If CONFIG_VIDEO_COPY is 27 * disabled, this is the hardware framebuffer. 28 * @copy_base: Base address of a hardware copy of the frame buffer. If 29 * CONFIG_VIDEO_COPY is disabled, this is not used. 30 * @copy_size: Size of copy framebuffer, used if @size is 0 31 * @hide_logo: Hide the logo (used for testing) 32 */ 33struct video_uc_plat { 34 uint align; 35 uint size; 36 ulong base; 37 ulong copy_base; 38 ulong copy_size; 39 bool hide_logo; 40}; 41 42enum video_polarity { 43 VIDEO_ACTIVE_HIGH, /* Pins are active high */ 44 VIDEO_ACTIVE_LOW, /* Pins are active low */ 45}; 46 47/* 48 * Bits per pixel selector. Each value n is such that the bits-per-pixel is 49 * 2 ^ n 50 */ 51enum video_log2_bpp { 52 VIDEO_BPP1 = 0, 53 VIDEO_BPP2, 54 VIDEO_BPP4, 55 VIDEO_BPP8, 56 VIDEO_BPP16, 57 VIDEO_BPP32, 58}; 59 60/* 61 * Convert enum video_log2_bpp to bytes and bits. Note we omit the outer 62 * brackets to allow multiplication by fractional pixels. 63 */ 64#define VNBYTES(bpix) ((1 << (bpix)) / 8) 65 66#define VNBITS(bpix) (1 << (bpix)) 67 68enum video_format { 69 VIDEO_UNKNOWN, 70 VIDEO_RGBA8888, 71 VIDEO_X8B8G8R8, 72 VIDEO_X8R8G8B8, 73 VIDEO_X2R10G10B10, 74}; 75 76/** 77 * struct video_priv - Device information used by the video uclass 78 * 79 * @xsize: Number of pixel columns (e.g. 1366) 80 * @ysize: Number of pixels rows (e.g.. 768) 81 * @rot: Display rotation (0=none, 1=90 degrees clockwise, etc.) 82 * @bpix: Encoded bits per pixel (enum video_log2_bpp) 83 * @format: Pixel format (enum video_format) 84 * @vidconsole_drv_name: Driver to use for the text console, NULL to 85 * select automatically 86 * @font_size: Font size in pixels (0 to use a default value) 87 * @fb: Frame buffer 88 * @fb_size: Frame buffer size 89 * @copy_fb: Copy of the frame buffer to keep up to date; see struct 90 * video_uc_plat 91 * @line_length: Length of each frame buffer line, in bytes. This can be 92 * set by the driver, but if not, the uclass will set it after 93 * probing 94 * @colour_fg: Foreground colour (pixel value) 95 * @colour_bg: Background colour (pixel value) 96 * @flush_dcache: true to enable flushing of the data cache after 97 * the LCD is updated 98 * @fg_col_idx: Foreground color code (bit 3 = bold, bit 0-2 = color) 99 * @bg_col_idx: Background color code (bit 3 = bold, bit 0-2 = color) 100 */ 101struct video_priv { 102 /* Things set up by the driver: */ 103 ushort xsize; 104 ushort ysize; 105 ushort rot; 106 enum video_log2_bpp bpix; 107 enum video_format format; 108 const char *vidconsole_drv_name; 109 int font_size; 110 111 /* 112 * Things that are private to the uclass: don't use these in the 113 * driver 114 */ 115 void *fb; 116 int fb_size; 117 void *copy_fb; 118 int line_length; 119 u32 colour_fg; 120 u32 colour_bg; 121 bool flush_dcache; 122 u8 fg_col_idx; 123 u8 bg_col_idx; 124}; 125 126/** 127 * struct video_ops - structure for keeping video operations 128 * @video_sync: Synchronize FB with device. Some device like SPI based LCD 129 * displays needs synchronization when data in an FB is available. 130 * For these devices implement video_sync hook to call a sync 131 * function. vid is pointer to video device udevice. Function 132 * should return 0 on success video_sync and error code otherwise 133 */ 134struct video_ops { 135 int (*video_sync)(struct udevice *vid); 136}; 137 138#define video_get_ops(dev) ((struct video_ops *)(dev)->driver->ops) 139 140/** 141 * struct video_handoff - video information passed from SPL 142 * 143 * This is used when video is set up by SPL, to provide the details to U-Boot 144 * proper. 145 * 146 * @fb: Base address of frame buffer, 0 if not yet known 147 * @size: Frame-buffer size, in bytes 148 * @xsize: Number of pixel columns (e.g. 1366) 149 * @ysize: Number of pixels rows (e.g.. 768) 150 * @line_length: Length of each frame buffer line, in bytes. This can be 151 * set by the driver, but if not, the uclass will set it after 152 * probing 153 * @bpix: Encoded bits per pixel (enum video_log2_bpp) 154 */ 155struct video_handoff { 156 u64 fb; 157 u32 size; 158 u16 xsize; 159 u16 ysize; 160 u32 line_length; 161 u8 bpix; 162}; 163 164/** enum colour_idx - the 16 colors supported by consoles */ 165enum colour_idx { 166 VID_BLACK = 0, 167 VID_RED, 168 VID_GREEN, 169 VID_BROWN, 170 VID_BLUE, 171 VID_MAGENTA, 172 VID_CYAN, 173 VID_LIGHT_GRAY, 174 VID_GRAY, 175 VID_LIGHT_RED, 176 VID_LIGHT_GREEN, 177 VID_YELLOW, 178 VID_LIGHT_BLUE, 179 VID_LIGHT_MAGENTA, 180 VID_LIGHT_CYAN, 181 VID_WHITE, 182 183 VID_COLOUR_COUNT 184}; 185 186/** 187 * video_index_to_colour() - convert a color code to a pixel's internal 188 * representation 189 * 190 * The caller has to guarantee that the color index is less than 191 * VID_COLOR_COUNT. 192 * 193 * @priv private data of the video device (UCLASS_VIDEO) 194 * @idx color index (e.g. VID_YELLOW) 195 * Return: color value 196 */ 197u32 video_index_to_colour(struct video_priv *priv, enum colour_idx idx); 198 199/** 200 * video_reserve() - Reserve frame-buffer memory for video devices 201 * 202 * Note: This function is for internal use. 203 * 204 * This uses the uclass plat's @size and @align members to figure out 205 * a size and position for each frame buffer as part of the pre-relocation 206 * process of determining the post-relocation memory layout. 207 * 208 * gd->video_top is set to the initial value of *@addrp and gd->video_bottom 209 * is set to the final value. 210 * 211 * @addrp: On entry, the top of available memory. On exit, the new top, 212 * after allocating the required memory. 213 * Return: 0 214 */ 215int video_reserve(ulong *addrp); 216 217/** 218 * video_clear() - Clear a device's frame buffer to background colour. 219 * 220 * @dev: Device to clear 221 * Return: 0 on success 222 */ 223int video_clear(struct udevice *dev); 224 225/** 226 * video_fill() - Fill a device's frame buffer to a colour. 227 * 228 * @dev: Device to fill 229 * @colour: Colour to use, in the frame buffer's format 230 * Return: 0 on success 231 */ 232int video_fill(struct udevice *dev, u32 colour); 233 234/** 235 * video_fill_part() - Erase a region 236 * 237 * Erase a rectangle of the display within the given bounds. 238 * 239 * @dev: Device to update 240 * @xstart: X start position in pixels from the left 241 * @ystart: Y start position in pixels from the top 242 * @xend: X end position in pixels from the left 243 * @yend: Y end position in pixels from the top 244 * @colour: Value to write 245 * Return: 0 if OK, -ENOSYS if the display depth is not supported 246 */ 247int video_fill_part(struct udevice *dev, int xstart, int ystart, int xend, 248 int yend, u32 colour); 249 250/** 251 * video_sync() - Sync a device's frame buffer with its hardware 252 * 253 * @vid: Device to sync 254 * @force: True to force a sync even if there was one recently (this is 255 * very expensive on sandbox) 256 * 257 * @return: 0 on success, error code otherwise 258 * 259 * Some frame buffers are cached or have a secondary frame buffer. This 260 * function syncs these up so that the current contents of the U-Boot frame 261 * buffer are displayed to the user. 262 */ 263int video_sync(struct udevice *vid, bool force); 264 265/** 266 * video_sync_all() - Sync all devices' frame buffers with their hardware 267 * 268 * This calls video_sync() on all active video devices. 269 */ 270void video_sync_all(void); 271 272/** 273 * video_bmp_get_info() - Get information about a bitmap image 274 * 275 * @bmp_image: Pointer to BMP image to check 276 * @widthp: Returns width in pixels 277 * @heightp: Returns height in pixels 278 * @bpixp: Returns log2 of bits per pixel 279 */ 280void video_bmp_get_info(void *bmp_image, ulong *widthp, ulong *heightp, 281 uint *bpixp); 282 283/** 284 * video_bmp_display() - Display a BMP file 285 * 286 * @dev: Device to display the bitmap on 287 * @bmp_image: Address of bitmap image to display 288 * @x: X position in pixels from the left 289 * @y: Y position in pixels from the top 290 * @align: true to adjust the coordinates to centre the image. If false 291 * the coordinates are used as is. If true: 292 * 293 * - if a coordinate is 0x7fff then the image will be centred in 294 * that direction 295 * - if a coordinate is -ve then it will be offset to the 296 * left/top of the centre by that many pixels 297 * - if a coordinate is positive it will be used unchanged. 298 * Return: 0 if OK, -ve on error 299 */ 300int video_bmp_display(struct udevice *dev, ulong bmp_image, int x, int y, 301 bool align); 302 303/** 304 * video_get_xsize() - Get the width of the display in pixels 305 * 306 * @dev: Device to check 307 * Return: device frame buffer width in pixels 308 */ 309int video_get_xsize(struct udevice *dev); 310 311/** 312 * video_get_ysize() - Get the height of the display in pixels 313 * 314 * @dev: Device to check 315 * Return: device frame buffer height in pixels 316 */ 317int video_get_ysize(struct udevice *dev); 318 319/** 320 * Set whether we need to flush the dcache when changing the image. This 321 * defaults to off. 322 * 323 * @param flush non-zero to flush cache after update, 0 to skip 324 */ 325void video_set_flush_dcache(struct udevice *dev, bool flush); 326 327/** 328 * Set default colors and attributes 329 * 330 * @dev: video device 331 * @invert true to invert colours 332 */ 333void video_set_default_colors(struct udevice *dev, bool invert); 334 335/** 336 * video_default_font_height() - Get the default font height 337 * 338 * @dev: video device 339 * Returns: Default font height in pixels, which depends on which console driver 340 * is in use 341 */ 342int video_default_font_height(struct udevice *dev); 343 344#ifdef CONFIG_VIDEO_COPY 345/** 346 * vidconsole_sync_copy() - Sync back to the copy framebuffer 347 * 348 * This ensures that the copy framebuffer has the same data as the framebuffer 349 * for a particular region. It should be called after the framebuffer is updated 350 * 351 * @from and @to can be in either order. The region between them is synced. 352 * 353 * @dev: Vidconsole device being updated 354 * @from: Start/end address within the framebuffer (->fb) 355 * @to: Other address within the frame buffer 356 * Return: 0 if OK, -EFAULT if the start address is before the start of the 357 * frame buffer start 358 */ 359int video_sync_copy(struct udevice *dev, void *from, void *to); 360 361/** 362 * video_sync_copy_all() - Sync the entire framebuffer to the copy 363 * 364 * @dev: Vidconsole device being updated 365 * Return: 0 (always) 366 */ 367int video_sync_copy_all(struct udevice *dev); 368#else 369static inline int video_sync_copy(struct udevice *dev, void *from, void *to) 370{ 371 return 0; 372} 373 374static inline int video_sync_copy_all(struct udevice *dev) 375{ 376 return 0; 377} 378 379#endif 380 381/** 382 * video_is_active() - Test if one video device it active 383 * 384 * Return: true if at least one video device is active, else false. 385 */ 386bool video_is_active(void); 387 388/** 389 * video_get_u_boot_logo() - Get a pointer to the U-Boot logo 390 * 391 * Returns: Pointer to logo 392 */ 393void *video_get_u_boot_logo(void); 394 395/* 396 * bmp_display() - Display BMP (bitmap) data located in memory 397 * 398 * @addr: address of the bmp data 399 * @x: Position of bitmap from the left side, in pixels 400 * @y: Position of bitmap from the top, in pixels 401 */ 402int bmp_display(ulong addr, int x, int y); 403 404/* 405 * bmp_info() - Show information about bmp file 406 * 407 * @addr: address of bmp file 408 * Returns: 0 if OK, else 1 if bmp image not found 409 */ 410int bmp_info(ulong addr); 411 412/* 413 * video_reserve_from_bloblist()- Reserve frame-buffer memory for video devices 414 * using blobs. 415 * 416 * @ho: video information passed from SPL 417 * Returns: 0 (always) 418 */ 419int video_reserve_from_bloblist(struct video_handoff *ho); 420 421#endif 422