1 /**************************************************************************** 2 * video/fb.h 3 * 4 * Copyright (C) 2008-2011, 2013, 2016-2018 Gregory Nutt. All rights 5 * reserved. 6 * Author: Gregory Nutt <gnutt@nuttx.org> 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in 16 * the documentation and/or other materials provided with the 17 * distribution. 18 * 3. Neither the name NuttX nor the names of its contributors may be 19 * used to endorse or promote products derived from this software 20 * without specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 23 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 24 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 25 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 26 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 27 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 28 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS 29 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 30 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 32 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 33 * POSSIBILITY OF SUCH DAMAGE. 34 * 35 ****************************************************************************/ 36 37 #ifndef __INCLUDE_NUTTX_VIDEO_FB_H 38 #define __INCLUDE_NUTTX_VIDEO_FB_H 39 40 /**************************************************************************** 41 * Included Files 42 ****************************************************************************/ 43 #include "fb_mem.h" 44 45 #define CONFIG_FB_CMAP 46 #define CONFIG_FB_OVERLAY_BLIT 47 #define CONFIG_FB_OVERLAY 48 #define CONFIG_FB_TRANSPARENCY 49 50 51 /**************************************************************************** 52 * Pre-processor definitions 53 ****************************************************************************/ 54 55 /* Color format definitions. The pretty much define the color pixel processing 56 * organization of the video controller. 57 */ 58 59 /* Monochrome Formats *******************************************************/ 60 61 #define FB_FMT_Y1 0 /* BPP=1, monochrome */ 62 #define FB_FMT_Y2 1 /* BPP=2, 2-bit uncompressed greyscale */ 63 #define FB_FMT_Y4 2 /* BPP=4, 4-bit uncompressed greyscale */ 64 #define FB_FMT_Y8 3 /* BPP=8, 8-bit uncompressed greyscale */ 65 #define FB_FMT_Y16 4 /* BPP=16, 16-bit uncompressed greyscale */ 66 #define FB_FMT_GREY FB_FMT_Y8 /* BPP=8 */ 67 #define FB_FMT_Y800 FB_FMT_Y8 /* BPP=8 */ 68 69 #define FB_ISMONO(f) ((f) >= FB_FMT_Y4 && (f) <= FB_FMT_Y16) 70 71 /* RGB video formats ********************************************************/ 72 73 /* Standard RGB */ 74 75 #define FB_FMT_RGB1 FB_FMT_Y1 /* BPP=1 */ 76 #define FB_FMT_RGB4 5 /* BPP=4 */ 77 #define FB_FMT_RGB8 6 /* BPP=8 RGB palette index */ 78 #define FB_FMT_RGB8_222 7 /* BPP=8 R=2, G=2, B=2 */ 79 #define FB_FMT_RGB8_332 8 /* BPP=8 R=3, G=3, B=2 */ 80 #define FB_FMT_RGB12_444 9 /* BPP=12 R=4, G=4, B=4 */ 81 #define FB_FMT_RGB16_555 10 /* BPP=16 R=5, G=5, B=5 (1 unused bit) */ 82 #define FB_FMT_RGB16_565 11 /* BPP=16 R=6, G=6, B=5 */ 83 #define FB_FMT_RGB24 12 /* BPP=24 */ 84 #define FB_FMT_RGB32 13 /* BPP=32 */ 85 86 /* Run length encoded RGB */ 87 88 #define FB_FMT_RGBRLE4 14 /* BPP=4 */ 89 #define FB_FMT_RGBRLE8 15 /* BPP=8 */ 90 91 /* Raw RGB */ 92 93 #define FB_FMT_RGBRAW 16 /* BPP=? */ 94 95 /* Raw RGB with arbitrary sample packing within a pixel. Packing and precision 96 * of R, G and B components is determined by bit masks for each. 97 */ 98 99 #define FB_FMT_RGBBTFLD16 17 /* BPP=16 */ 100 #define FB_FMT_RGBBTFLD24 18 /* BPP=24 */ 101 #define FB_FMT_RGBBTFLD32 19 /* BPP=32 */ 102 #define FB_FMT_RGBA16 20 /* BPP=16 Raw RGB with alpha */ 103 #define FB_FMT_RGBA32 21 /* BPP=32 Raw RGB with alpha */ 104 105 /* Raw RGB with a transparency field. Layout is as for standard RGB at 16 and 106 * 32 bits per pixel but the msb in each pixel indicates whether the pixel is 107 * transparent or not. 108 */ 109 110 #define FB_FMT_RGBT16 22 /* BPP=16 */ 111 #define FB_FMT_RGBT32 23 /* BPP=32 */ 112 113 #define FB_ISRGB(f) ((f) >= FB_FMT_RGB1 && (f) <= FB_FMT_RGBT32) 114 115 /* Packed YUV Formats *******************************************************/ 116 117 #define FB_FMT_AYUV 24 /* BPP=32 Combined YUV and alpha */ 118 #define FB_FMT_CLJR 25 /* BPP=8 4 pixels packed into a uint32_t. 119 * YUV 4:1:1 with l< 8 bits 120 * per YUV sample */ 121 #define FB_FMT_CYUV 26 /* BPP=16 UYVY except that height is 122 * reversed */ 123 #define FB_FMT_IRAW 27 /* BPP=? Intel uncompressed YUV */ 124 #define FB_FMT_IUYV 28 /* BPP=16 Interlaced UYVY (line order 125 * 0,2,4,.., 1,3,5...) */ 126 #define FB_FMT_IY41 29 /* BPP=12 Interlaced Y41P (line order 127 * 0,2,4,.., 1,3,5...) */ 128 #define FB_FMT_IYU2 30 /* BPP=24 */ 129 #define FB_FMT_HDYC 31 /* BPP=16 UYVY except uses the BT709 130 * color space */ 131 #define FB_FMT_UYVP 32 /* BPP=24? YCbCr 4:2:2, 10-bits per 132 * component in U0Y0V0Y1 order */ 133 #define FB_FMT_UYVY 33 /* BPP=16 YUV 4:2:2 */ 134 #define FB_FMT_UYNV FB_FMT_UYVY /* BPP=16 */ 135 #define FB_FMT_Y422 FB_FMT_UYVY /* BPP=16 */ 136 #define FB_FMT_V210 34 /* BPP=32 10-bit 4:2:2 YCrCb */ 137 #define FB_FMT_V422 35 /* BPP=16 Upside down version of UYVY */ 138 #define FB_FMT_V655 36 /* BPP=16? 16-bit YUV 4:2:2 */ 139 #define FB_FMT_VYUY 37 /* BPP=? ATI Packed YUV Data */ 140 #define FB_FMT_YUYV 38 /* BPP=16 YUV 4:2:2 */ 141 #define FB_FMT_YUY2 FB_FMT_YUYV /* BPP=16 YUV 4:2:2 */ 142 #define FB_FMT_YUNV FB_FMT_YUYV /* BPP=16 YUV 4:2:2 */ 143 #define FB_FMT_YVYU 39 /* BPP=16 YUV 4:2:2 */ 144 #define FB_FMT_Y41P 40 /* BPP=12 YUV 4:1:1 */ 145 #define FB_FMT_Y411 41 /* BPP=12 YUV 4:1:1 */ 146 #define FB_FMT_Y211 42 /* BPP=8 */ 147 #define FB_FMT_Y41T 43 /* BPP=12 Y41P LSB for transparency */ 148 #define FB_FMT_Y42T 44 /* BPP=16 UYVY LSB for transparency */ 149 #define FB_FMT_YUVP 45 /* BPP=24? YCbCr 4:2:2 Y0U0Y1V0 order */ 150 151 #define FB_ISYUVPACKED(f) ((f) >= FB_FMT_AYUV && (f) <= FB_FMT_YUVP) 152 153 /* Packed Planar YUV Formats ************************************************/ 154 155 #define FB_FMT_YVU9 46 /* BPP=9 8-bit Y followed by 8-bit 156 * 4x4 VU */ 157 #define FB_FMT_YUV9 47 /* BPP=9? */ 158 #define FB_FMT_IF09 48 /* BPP=9.5 YVU9 + 4x4 plane of delta 159 * relative to tframe. */ 160 #define FB_FMT_YV16 49 /* BPP=16 8-bit Y followed by 8-bit 161 * 2x1 VU */ 162 #define FB_FMT_YV12 50 /* BPP=12 8-bit Y followed by 8-bit 163 * 2x2 VU */ 164 #define FB_FMT_I420 51 /* BPP=12 8-bit Y followed by 8-bit 165 * 2x2 UV */ 166 #define FB_FMT_IYUV FB_FMT_I420 /* BPP=12 */ 167 #define FB_FMT_NV12 52 /* BPP=12 8-bit Y followed by an 168 * interleaved 2x2 UV */ 169 #define FB_FMT_NV21 53 /* BPP=12 NV12 with UV reversed */ 170 #define FB_FMT_IMC1 54 /* BPP=12 YV12 except UV planes same 171 * stride as Y */ 172 #define FB_FMT_IMC2 55 /* BPP=12 IMC1 except UV lines 173 * interleaved at half stride 174 * boundaries */ 175 #define FB_FMT_IMC3 56 /* BPP=12 As IMC1 except that UV 176 * swapped */ 177 #define FB_FMT_IMC4 57 /* BPP=12 As IMC2 except that UV 178 * swapped */ 179 #define FB_FMT_CLPL 58 /* BPP=12 YV12 but including a level 180 * of indirection. */ 181 #define FB_FMT_Y41B 59 /* BPP=12? 4:1:1 planar. */ 182 #define FB_FMT_Y42B 60 /* BPP=16? YUV 4:2:2 planar. */ 183 #define FB_FMT_CXY1 61 /* BPP=12 */ 184 #define FB_FMT_CXY2 62 /* BPP=16 */ 185 186 #define FB_ISYUVPLANAR(f) (((f) >= FB_FMT_AYUV) && (f) <= FB_FMT_YUVP) 187 #define FB_ISYUV(f) (FB_ISYUVPACKED(f) || FB_ISYUVPLANAR(f)) 188 189 /* Hardware cursor control **************************************************/ 190 191 #ifdef CONFIG_FB_HWCURSOR 192 # define FB_CUR_ENABLE 0x01 /* Enable the cursor */ 193 # define FB_CUR_SETIMAGE 0x02 /* Set the cursor image */ 194 # define FB_CUR_SETPOSITION 0x04 /* Set the position of the cursor */ 195 # define FB_CUR_SETSIZE 0x08 /* Set the size of the cursor */ 196 # define FB_CUR_XOR 0x10 /* Use XOR vs COPY ROP on image */ 197 #endif 198 199 /* Hardware overlay acceleration *******************************************/ 200 201 #ifdef CONFIG_FB_OVERLAY 202 # define FB_ACCL_TRANSP 0x01 /* Hardware tranparency support */ 203 # define FB_ACCL_CHROMA 0x02 /* Hardware chromakey support */ 204 # define FB_ACCL_COLOR 0x04 /* Hardware color support */ 205 # define FB_ACCL_AREA 0x08 /* Hardware support area selection */ 206 207 #ifdef CONFIG_FB_OVERLAY_BLIT 208 # define FB_ACCL_BLIT 0x10 /* Hardware blit support */ 209 # define FB_ACCL_BLEND 0x20 /* Hardware blend support */ 210 #endif 211 212 /* Overlay transparency mode ************************************************/ 213 214 # define FB_CONST_ALPHA 0x00 /* Transparency by alpha value */ 215 # define FB_PIXEL_ALPHA 0x01 /* Transparency by pixel alpha value */ 216 217 #endif /* CONFIG_FB_OVERLAY */ 218 219 /* FB character driver IOCTL commands ***************************************/ 220 #define _FBIOCBASE (0x2800) /* Frame buffer character driver ioctl commands */ 221 #define _IOC_X(type,nr) ((type)|(nr)) 222 #define _FBIOC(nr) _IOC_X(_FBIOCBASE,nr) 223 224 /* ioctls */ 225 226 #define FBIOGET_VIDEOINFO _FBIOC(0x0001) /* Get color plane info */ 227 /* Argument: writable struct 228 * fb_videoinfo_s */ 229 #define FBIOGET_PLANEINFO _FBIOC(0x0002) /* Get video plane info */ 230 /* Argument: writable struct 231 * fb_planeinfo_s */ 232 233 #ifdef CONFIG_FB_CMAP 234 # define FBIOGET_CMAP _FBIOC(0x0003) /* Get RGB color mapping */ 235 /* Argument: writable struct 236 * fb_cmap_s */ 237 # define FBIOPUT_CMAP _FBIOC(0x0004) /* Put RGB color mapping */ 238 /* Argument: read-only struct 239 * fb_cmap_s */ 240 #endif 241 242 #ifdef CONFIG_FB_HWCURSOR 243 # define FBIOGET_CURSOR _FBIOC(0x0005) /* Get cursor attributes */ 244 /* Argument: writable struct 245 * fb_cursorattrib_s */ 246 # define FBIOPUT_CURSOR _FBIOC(0x0006) /* Set cursor attributes */ 247 /* Argument: read-only struct 248 * fb_setcursor_s */ 249 #endif 250 251 #ifdef CONFIG_LCD_UPDATE 252 # define FBIO_UPDATE _FBIOC(0x0007) /* Update a rectangular region in 253 * the framebuffer 254 * Argument: read-only struct 255 * nxgl_rect_s */ 256 #endif 257 258 #ifdef CONFIG_FB_SYNC 259 # define FBIO_WAITFORVSYNC _FBIOC(0x0008) /* Wait for vertical sync */ 260 #endif 261 262 #ifdef CONFIG_FB_OVERLAY 263 # define FBIOGET_OVERLAYINFO _FBIOC(0x0009) /* Get video overlay info */ 264 /* Argument: writable struct 265 * fb_overlayinfo_s */ 266 # define FBIO_SELECT_OVERLAY _FBIOC(0x000a) /* Select overlay */ 267 /* Argument: read-only 268 * unsigned long */ 269 # define FBIOSET_TRANSP _FBIOC(0x000b) /* Set opacity or transparency 270 * Argument: read-only struct 271 * fb_overlayinfo_s */ 272 # define FBIOSET_CHROMAKEY _FBIOC(0x000c) /* Set chroma key 273 * Argument: read-only struct 274 * fb_overlayinfo_s */ 275 # define FBIOSET_COLOR _FBIOC(0x000d) /* Set color 276 * Argument: read-only struct 277 * fb_overlayinfo_s */ 278 # define FBIOSET_BLANK _FBIOC(0x000e) /* Blank or unblank 279 * Argument: read-only struct 280 * fb_overlayinfo_s */ 281 # define FBIOSET_AREA _FBIOC(0x000f) /* Set active overlay area 282 * Argument: read-only struct 283 * fb_overlayinfo_s */ 284 #ifdef CONFIG_FB_OVERLAY_BLIT 285 # define FBIOSET_BLIT _FBIOC(0x0010) /* Blit area between overlays 286 * Argument: read-only struct 287 * fb_overlayblit_s */ 288 # define FBIOSET_BLEND _FBIOC(0x0011) /* Blend area between overlays 289 * Argument: read-only struct 290 * fb_overlayblend_s */ 291 #endif 292 #endif /* CONFIG_FB_OVERLAY */ 293 294 #define FIOC_MMAP _FBIOC(0x0012) 295 296 /**************************************************************************** 297 * Public Types 298 ****************************************************************************/ 299 300 /* If any dimension of the display exceeds 65,536 pixels, then the following 301 * type will need to change: 302 */ 303 304 typedef uint16_t fb_coord_t; 305 306 /* This structure describes the overall video controller */ 307 308 struct fb_videoinfo_s { 309 uint8_t fmt; /* see FB_FMT_* */ 310 fb_coord_t xres; /* Horizontal resolution in pixel columns */ 311 fb_coord_t yres; /* Vertical resolution in pixel rows */ 312 uint8_t nplanes; /* Number of color planes supported */ 313 #ifdef CONFIG_FB_OVERLAY 314 uint8_t noverlays; /* Number of overlays supported */ 315 #endif 316 }; 317 318 /* This structure describes one color plane. Some YUV formats may support 319 * up to 4 planes 320 */ 321 322 struct fb_planeinfo_s { 323 void *fbmem; /* Start of frame buffer memory */ 324 size_t fblen; /* Length of frame buffer memory in bytes */ 325 fb_coord_t stride; /* Length of a line in bytes */ 326 uint8_t display; /* Display number */ 327 uint8_t bpp; /* Bits per pixel */ 328 }; 329 330 #ifdef CONFIG_FB_OVERLAY 331 /* This structure describes the transparency. */ 332 333 struct fb_transp_s { 334 uint8_t transp; /* Transparency */ 335 uint8_t transp_mode; /* Transparency mode */ 336 }; 337 338 /* This structure describes an area. */ 339 340 struct fb_area_s { 341 fb_coord_t x; /* x-offset of the area */ 342 fb_coord_t y; /* y-offset of the area */ 343 fb_coord_t w; /* Width of the area */ 344 fb_coord_t h; /* Height of the area */ 345 }; 346 347 /* This structure describes one overlay. */ 348 349 struct fb_overlayinfo_s { 350 void *fbmem; /* Start of frame buffer virtual memory */ 351 void *memphys; /* Start of frame buffer physical memory */ 352 size_t fblen; /* Length of frame buffer memory in bytes */ 353 fb_coord_t stride; /* Length of a line in bytes */ 354 uint8_t overlay; /* Overlay number */ 355 uint8_t bpp; /* Bits per pixel */ 356 uint8_t blank; /* Blank or unblank */ 357 uint32_t chromakey; /* Chroma key argb8888 formatted */ 358 uint32_t color; /* Color argb8888 formatted */ 359 struct fb_transp_s transp; /* Transparency */ 360 struct fb_area_s sarea; /* Selected area within the overlay */ 361 uint32_t accl; /* Supported hardware acceleration */ 362 }; 363 364 #ifdef CONFIG_FB_OVERLAY_BLIT 365 /* This structure describes an overlay area within a whole overlay */ 366 367 struct fb_overlayarea_s { 368 uint8_t overlay; /* Number overlay */ 369 struct fb_area_s area; /* Overlay area */ 370 }; 371 372 /* This structure describes blit operation */ 373 374 struct fb_overlayblit_s { 375 struct fb_overlayarea_s dest; /* The destination overlay area */ 376 struct fb_overlayarea_s src; /* The source overlay area */ 377 }; 378 379 /* This structure describes blend operation */ 380 381 struct fb_overlayblend_s { 382 struct fb_overlayarea_s dest; /* The destination overlay area */ 383 struct fb_overlayarea_s foreground; /* The foreground overlay area */ 384 struct fb_overlayarea_s background; /* The background overlay area */ 385 }; 386 #endif 387 #endif /* CONFIG_FB_OVERLAY */ 388 389 /* On video controllers that support mapping of a pixel palette value 390 * to an RGB encoding, the following structure may be used to define 391 * that mapping. 392 */ 393 394 #ifdef CONFIG_FB_CMAP 395 struct fb_cmap_s { 396 uint16_t first; /* Offset offset first color entry in tables */ 397 uint16_t len; /* Number of color entries in tables */ 398 399 /* Tables of color component. Any may be NULL if not used */ 400 401 uint8_t *red; /* Table of 8-bit red values */ 402 uint8_t *green; /* Table of 8-bit green values */ 403 uint8_t *blue; /* Table of 8-bit blue values */ 404 #ifdef CONFIG_FB_TRANSPARENCY 405 uint8_t *transp; /* Table of 8-bit transparency */ 406 #endif 407 }; 408 #endif 409 410 #ifdef CONFIG_FB_HWCURSOR 411 #ifdef CONFIG_FB_HWCURSORIMAGE 412 /* If the video controller hardware supports a hardware cursor and 413 * that hardware cursor supports user-provided images, then the 414 * following structure may be used to provide the cursor image 415 */ 416 417 struct fb_cursorimage_s { 418 fb_coord_t width; /* Width of the cursor image in pixels */ 419 fb_coord_t height; /* Height of the cursor image in pixels */ 420 const uint8_t *image; /* Pointer to image data */ 421 }; 422 #endif 423 424 /* The following structure defines the cursor position/size */ 425 426 struct fb_cursorpos_s { 427 fb_coord_t x; /* X position in pixels */ 428 fb_coord_t y; /* Y position in rows */ 429 }; 430 431 /* If the hardware supports setting the cursor size, then this structure 432 * is used to provide the size. 433 */ 434 435 #ifdef CONFIG_FB_HWCURSORSIZE 436 struct fb_cursorsize_s { 437 fb_coord_t h; /* Height in rows */ 438 fb_coord_t w; /* Width in pixels */ 439 }; 440 #endif 441 442 /* The following is used to get the cursor attributes */ 443 444 struct fb_cursorattrib_s { 445 #ifdef CONFIG_FB_HWCURSORIMAGE 446 uint8_t fmt; /* Video format of cursor */ 447 #endif 448 struct fb_cursorpos_s pos; /* Current cursor position */ 449 #ifdef CONFIG_FB_HWCURSORSIZE 450 struct fb_cursorsize_s mxsize; /* Maximum cursor size */ 451 struct fb_cursorsize_s size; /* Current size */ 452 #endif 453 }; 454 455 struct fb_setcursor_s { 456 uint8_t flags; /* See FB_CUR_* definitions */ 457 struct fb_cursorpos_s pos; /* Cursor position */ 458 #ifdef CONFIG_FB_HWCURSORSIZE 459 struct fb_cursorsize_s size; /* Cursor size */ 460 #endif 461 #ifdef CONFIG_FB_HWCURSORIMAGE 462 struct fb_cursorimage_s img; /* Cursor image */ 463 #endif 464 }; 465 #endif 466 467 /* The framebuffer "object" is accessed through within the OS via 468 * the following vtable: 469 */ 470 471 struct fb_vtable_s { 472 /* Get information about the video controller configuration and the 473 * configuration of each color plane. 474 */ 475 476 int (*getvideoinfo)(struct fb_vtable_s *vtable, struct fb_videoinfo_s *vinfo); 477 int (*getplaneinfo)(struct fb_vtable_s *vtable, int planeno, struct fb_planeinfo_s *pinfo); 478 479 #ifdef CONFIG_FB_CMAP 480 /* The following are provided only if the video hardware supports RGB 481 * color mapping 482 */ 483 484 int (*getcmap)(struct fb_vtable_s *vtable, struct fb_cmap_s *cmap); 485 int (*putcmap)(struct fb_vtable_s *vtable, const struct fb_cmap_s *cmap); 486 #endif 487 488 #ifdef CONFIG_FB_HWCURSOR 489 /* The following are provided only if the video hardware supports a 490 * hardware cursor. 491 */ 492 493 int (*getcursor)(struct fb_vtable_s *vtable, struct fb_cursorattrib_s *attrib); 494 int (*setcursor)(struct fb_vtable_s *vtable, struct fb_setcursor_s *settings); 495 #endif 496 497 #ifdef CONFIG_FB_SYNC 498 /* The following are provided only if the video hardware signals 499 * vertical sync. 500 */ 501 502 int (*waitforvsync)(struct fb_vtable_s *vtable); 503 #endif 504 505 #ifdef CONFIG_FB_OVERLAY 506 /* Get information about the video controller configuration and the 507 * configuration of each overlay. 508 */ 509 510 int (*getoverlayinfo)(struct fb_vtable_s *vtable, int overlayno, struct fb_overlayinfo_s *oinfo); 511 512 /* The following are provided only if the video hardware supports 513 * transparency 514 */ 515 516 int (*settransp)(struct fb_vtable_s *vtable, const struct fb_overlayinfo_s *oinfo); 517 518 /* The following are provided only if the video hardware supports 519 * chromakey 520 */ 521 522 int (*setchromakey)(struct fb_vtable_s *vtable, const struct fb_overlayinfo_s *oinfo); 523 524 /* The following are provided only if the video hardware supports 525 * filling the overlay with a color. 526 */ 527 528 int (*setcolor)(struct fb_vtable_s *vtable, const struct fb_overlayinfo_s *oinfo); 529 530 /* The following allows to switch the overlay on or off */ 531 532 int (*setblank)(struct fb_vtable_s *vtable, const struct fb_overlayinfo_s *oinfo); 533 534 /* The following allows to set the active area for subsequently overlay 535 * operations. 536 */ 537 538 int (*setarea)(struct fb_vtable_s *vtable, const struct fb_overlayinfo_s *oinfo); 539 540 #ifdef CONFIG_FB_OVERLAY_BLIT 541 /* The following are provided only if the video hardware supports 542 * blit operation between overlays. 543 */ 544 545 int (*blit)(struct fb_vtable_s *vtable, const struct fb_overlayblit_s *blit); 546 547 /* The following are provided only if the video hardware supports 548 * blend operation between overlays. 549 */ 550 551 int (*blend)(struct fb_vtable_s *vtable, const struct fb_overlayblend_s *blend); 552 #endif 553 #endif 554 int (*fb_open)(struct fb_vtable_s *vtable); 555 int (*fb_release)(struct fb_vtable_s *vtable); 556 #ifdef CONFIG_FB_OVERLAY 557 int (*fb_pan_display)(struct fb_vtable_s *vtable, struct fb_overlayinfo_s *oinfo); 558 #endif 559 int (*fb_ioctl)(struct fb_vtable_s *vtable, int cmd, unsigned long arg); 560 int (*fb_check_var)(struct fb_vtable_s *vtable, unsigned long arg); 561 int (*fb_set_par)(struct fb_vtable_s *vtable); 562 }; 563 564 /**************************************************************************** 565 * Public Data 566 ****************************************************************************/ 567 568 #ifdef __cplusplus 569 #define EXTERN extern "C" 570 extern "C" { 571 #else 572 #define EXTERN extern 573 #endif 574 575 /**************************************************************************** 576 * Public Function Prototypes 577 ****************************************************************************/ 578 579 /**************************************************************************** 580 * If an architecture supports a framebuffer, then it must provide the 581 * following APIs to access the framebuffer. 582 ****************************************************************************/ 583 584 /**************************************************************************** 585 * Name: up_fbinitialize 586 * 587 * Description: 588 * Initialize the framebuffer video hardware associated with the display. 589 * 590 * There are multiple logic paths that may call up_fbinitialize() so any 591 * implementation of up_fbinitialize() should be tolerant of being called 592 * multiple times. 593 * 594 * Input Parameters: 595 * display - In the case of hardware with multiple displays, this 596 * specifies the display. Normally this is zero. 597 * 598 * Returned Value: 599 * Zero is returned on success; a negated errno value is returned on any 600 * failure. 601 * 602 ****************************************************************************/ 603 604 int up_fbinitialize(int display); 605 606 /**************************************************************************** 607 * Name: up_fbgetvplane 608 * 609 * Description: 610 * Return a a reference to the framebuffer object for the specified video 611 * plane of the specified plane. Many OSDs support multiple planes of video. 612 * 613 * Input Parameters: 614 * display - In the case of hardware with multiple displays, this 615 * specifies the display. Normally this is zero. 616 * vplane - Identifies the plane being queried. 617 * 618 * Returned Value: 619 * A non-NULL pointer to the frame buffer access structure is returned on 620 * success; NULL is returned on any failure. 621 * 622 ****************************************************************************/ 623 624 struct fb_vtable_s *up_fbgetvplane(int display, int vplane); 625 626 /**************************************************************************** 627 * Name: up_fbuninitialize 628 * 629 * Description: 630 * Uninitialize the framebuffer support for the specified display. 631 * 632 * Input Parameters: 633 * display - In the case of hardware with multiple displays, this 634 * specifies the display. Normally this is zero. 635 * 636 * Returned Value: 637 * None 638 * 639 ****************************************************************************/ 640 641 void up_fbuninitialize(int display); 642 643 /**************************************************************************** 644 * Name: fb_register 645 * 646 * Description: 647 * Register the framebuffer character device at /dev/fbN where N is the 648 * display number if the devices supports only a single plane. If the 649 * hardware supports multiple color planes, then the device will be 650 * registered at /dev/fbN.M where N is the again display number but M 651 * is the display plane. 652 * 653 * Input Parameters: 654 * display - The display number for the case of boards supporting multiple 655 * displays or for hardware that supports multiple 656 * layers (each layer is consider a display). Typically zero. 657 * plane - Identifies the color plane on hardware that supports separate 658 * framebuffer "planes" for each color component. 659 * 660 * Returned Value: 661 * Zero (OK) is returned success; a negated errno value is returned on any 662 * failure. 663 * 664 ****************************************************************************/ 665 int fb_register(int display, int plane); 666 667 int fb_unregister(int display); 668 669 int fb_open(const char *key, struct fb_mem **result); 670 int fb_close(struct fb_mem *fbmem); 671 int fb_ioctl(struct fb_mem *fbmem, int cmd, unsigned long arg); 672 int getplaneinfo(struct fb_mem *fbmem, struct fb_planeinfo_s **result); 673 674 #undef EXTERN 675 #ifdef __cplusplus 676 } 677 #endif 678 679 #endif /* __INCLUDE_NUTTX_VIDEO_FB_H */ 680