include/video.h

   1 /*
   2  * Video uclass and legacy implementation
   3  *
   4  * Copyright (c) 2015 Google, Inc
   5  *
   6  * MPC823 Video Controller
   7  * =======================
   8  * (C) 2000 by Paolo Scaffardi (arsenio@tin.it)
   9  * AIRVENT SAM s.p.a - RIMINI(ITALY)
  10  *
  11  */
  12
  13 #ifndef _VIDEO_H_
  14 #define _VIDEO_H_
  15
  16 #ifdef CONFIG_DM_VIDEO
  17
  18 #include <stdio_dev.h>
  19
  20 struct udevice;
  21
  22 struct video_uc_platdata {
  23         uint align;
  24         uint size;
  25         ulong base;
  26 };
  27
  28 enum video_polarity {
  29         VIDEO_ACTIVE_HIGH,      /* Pins are active high */
  30         VIDEO_ACTIVE_LOW,       /* Pins are active low */
  31 };
  32
  33 /*
  34  * Bits per pixel selector. Each value n is such that the bits-per-pixel is
  35  * 2 ^ n
  36  */
  37 enum video_log2_bpp {
  38         VIDEO_BPP1      = 0,
  39         VIDEO_BPP2,
  40         VIDEO_BPP4,
  41         VIDEO_BPP8,
  42         VIDEO_BPP16,
  43         VIDEO_BPP32,
  44 };
  45
  46 /*
  47  * Convert enum video_log2_bpp to bytes and bits. Note we omit the outer
  48  * brackets to allow multiplication by fractional pixels.
  49  */
  50 #define VNBYTES(bpix)   (1 << (bpix)) / 8
  51
  52 #define VNBITS(bpix)    (1 << (bpix))
  53
  54 /**
  55  * struct video_priv - Device information used by the video uclass
  56  *
  57  * @xsize:      Number of pixel columns (e.g. 1366)
  58  * @ysize:      Number of pixels rows (e.g.. 768)
  59  * @rot:        Display rotation (0=none, 1=90 degrees clockwise, etc.)
  60  * @bpix:       Encoded bits per pixel (enum video_log2_bpp)
  61  * @vidconsole_drv_name:        Driver to use for the text console, NULL to
  62  *              select automatically
  63  * @font_size:  Font size in pixels (0 to use a default value)
  64  * @fb:         Frame buffer
  65  * @fb_size:    Frame buffer size
  66  * @line_length:        Length of each frame buffer line, in bytes. This can be
  67  *              set by the driver, but if not, the uclass will set it after
  68  *              probing
  69  * @colour_fg:  Foreground colour (pixel value)
  70  * @colour_bg:  Background colour (pixel value)
  71  * @flush_dcache:       true to enable flushing of the data cache after
  72  *              the LCD is updated
  73  * @cmap:       Colour map for 8-bit-per-pixel displays
  74  * @fg_col_idx: Foreground color code (bit 3 = bold, bit 0-2 = color)
  75  * @bg_col_idx: Background color code (bit 3 = bold, bit 0-2 = color)
  76  */
  77 struct video_priv {
  78         /* Things set up by the driver: */
  79         ushort xsize;
  80         ushort ysize;
  81         ushort rot;
  82         enum video_log2_bpp bpix;
  83         const char *vidconsole_drv_name;
  84         int font_size;
  85
  86         /*
  87          * Things that are private to the uclass: don't use these in the
  88          * driver
  89          */
  90         void *fb;
  91         int fb_size;
  92         int line_length;
  93         u32 colour_fg;
  94         u32 colour_bg;
  95         bool flush_dcache;
  96         ushort *cmap;
  97         u8 fg_col_idx;
  98         u8 bg_col_idx;
  99 };
 100
 101 /* Placeholder - there are no video operations at present */
 102 struct video_ops {
 103 };
 104
 105 #define video_get_ops(dev)        ((struct video_ops *)(dev)->driver->ops)
 106
 107 /**
 108  * video_reserve() - Reserve frame-buffer memory for video devices
 109  *
 110  * Note: This function is for internal use.
 111  *
 112  * This uses the uclass platdata's @size and @align members to figure out
 113  * a size and position for each frame buffer as part of the pre-relocation
 114  * process of determining the post-relocation memory layout.
 115  *
 116  * gd->video_top is set to the initial value of *@addrp and gd->video_bottom
 117  * is set to the final value.
 118  *
 119  * @addrp:      On entry, the top of available memory. On exit, the new top,
 120  *              after allocating the required memory.
 121  * @return 0
 122  */
 123 int video_reserve(ulong *addrp);
 124
 125 /**
 126  * video_clear() - Clear a device's frame buffer to background color.
 127  *
 128  * @dev:        Device to clear
 129  * @return 0
 130  */
 131 int video_clear(struct udevice *dev);
 132
 133 /**
 134  * video_sync() - Sync a device's frame buffer with its hardware
 135  *
 136  * Some frame buffers are cached or have a secondary frame buffer. This
 137  * function syncs these up so that the current contents of the U-Boot frame
 138  * buffer are displayed to the user.
 139  *
 140  * @dev:        Device to sync
 141  * @force:      True to force a sync even if there was one recently (this is
 142  *              very expensive on sandbox)
 143  */
 144 void video_sync(struct udevice *vid, bool force);
 145
 146 /**
 147  * video_sync_all() - Sync all devices' frame buffers with there hardware
 148  *
 149  * This calls video_sync() on all active video devices.
 150  */
 151 void video_sync_all(void);
 152
 153 /**
 154  * video_bmp_display() - Display a BMP file
 155  *
 156  * @dev:        Device to display the bitmap on
 157  * @bmp_image:  Address of bitmap image to display
 158  * @x:          X position in pixels from the left
 159  * @y:          Y position in pixels from the top
 160  * @align:      true to adjust the coordinates to centre the image. If false
 161  *              the coordinates are used as is. If true:
 162  *
 163  *              - if a coordinate is 0x7fff then the image will be centred in
 164  *                that direction
 165  *              - if a coordinate is -ve then it will be offset to the
 166  *                left/top of the centre by that many pixels
 167  *              - if a coordinate is positive it will be used unchnaged.
 168  * @return 0 if OK, -ve on error
 169  */
 170 int video_bmp_display(struct udevice *dev, ulong bmp_image, int x, int y,
 171                       bool align);
 172
 173 /**
 174  * video_get_xsize() - Get the width of the display in pixels
 175  *
 176  * @dev:        Device to check
 177  * @return device frame buffer width in pixels
 178  */
 179 int video_get_xsize(struct udevice *dev);
 180
 181 /**
 182  * video_get_ysize() - Get the height of the display in pixels
 183  *
 184  * @dev:        Device to check
 185  * @return device frame buffer height in pixels
 186  */
 187 int video_get_ysize(struct udevice *dev);
 188
 189 /**
 190  * Set whether we need to flush the dcache when changing the image. This
 191  * defaults to off.
 192  *
 193  * @param flush         non-zero to flush cache after update, 0 to skip
 194  */
 195 void video_set_flush_dcache(struct udevice *dev, bool flush);
 196
 197 /**
 198  * Set default colors and attributes
 199  *
 200  * @dev:        video device
 201  * @invert      true to invert colours
 202  */
 203 void video_set_default_colors(struct udevice *dev, bool invert);
 204
 205 #endif /* CONFIG_DM_VIDEO */
 206
 207 #ifndef CONFIG_DM_VIDEO
 208
 209 /* Video functions */
 210
 211 /**
 212  * Display a BMP format bitmap on the screen
 213  *
 214  * @param bmp_image     Address of BMP image
 215  * @param x             X position to draw image
 216  * @param y             Y position to draw image
 217  */
 218 int video_display_bitmap(ulong bmp_image, int x, int y);
 219
 220 /**
 221  * Get the width of the screen in pixels
 222  *
 223  * @return width of screen in pixels
 224  */
 225 int video_get_pixel_width(void);
 226
 227 /**
 228  * Get the height of the screen in pixels
 229  *
 230  * @return height of screen in pixels
 231  */
 232 int video_get_pixel_height(void);
 233
 234 /**
 235  * Get the number of text lines/rows on the screen
 236  *
 237  * @return number of rows
 238  */
 239 int video_get_screen_rows(void);
 240
 241 /**
 242  * Get the number of text columns on the screen
 243  *
 244  * @return number of columns
 245  */
 246 int video_get_screen_columns(void);
 247
 248 /**
 249  * Set the position of the text cursor
 250  *
 251  * @param col   Column to place cursor (0 = left side)
 252  * @param row   Row to place cursor (0 = top line)
 253  */
 254 void video_position_cursor(unsigned col, unsigned row);
 255
 256 /* Clear the display */
 257 void video_clear(void);
 258
 259 #if defined(CONFIG_FORMIKE)
 260 int kwh043st20_f01_spi_startup(unsigned int bus, unsigned int cs,
 261         unsigned int max_hz, unsigned int spi_mode);
 262 #endif
 263 #if defined(CONFIG_LG4573)
 264 int lg4573_spi_startup(unsigned int bus, unsigned int cs,
 265         unsigned int max_hz, unsigned int spi_mode);
 266 #endif
 267
 268 /*
 269  * video_get_info_str() - obtain a board string: type, speed, etc.
 270  *
 271  * This is called if CONFIG_CONSOLE_EXTRA_INFO is enabled.
 272  *
 273  * line_number: location to place info string beside logo
 274  * info:        buffer for info string (empty if nothing to display on this
 275  * line)
 276  */
 277 void video_get_info_str(int line_number, char *info);
 278
 279 #endif /* !CONFIG_DM_VIDEO */
 280
 281 #endif