LCOV - code coverage report
Current view: top level - drivers/video/console - fbcon.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 9 9 100.0 %
Date: 2017-01-25 Functions: 2 2 100.0 %

          Line data    Source code
       1             : /*
       2             :  *  linux/drivers/video/console/fbcon.h -- Low level frame buffer based console driver
       3             :  *
       4             :  *      Copyright (C) 1997 Geert Uytterhoeven
       5             :  *
       6             :  *  This file is subject to the terms and conditions of the GNU General Public
       7             :  *  License.  See the file COPYING in the main directory of this archive
       8             :  *  for more details.
       9             :  */
      10             : 
      11             : #ifndef _VIDEO_FBCON_H
      12             : #define _VIDEO_FBCON_H
      13             : 
      14             : #include <linux/types.h>
      15             : #include <linux/vt_buffer.h>
      16             : #include <linux/vt_kern.h>
      17             : 
      18             : #include <asm/io.h>
      19             : 
      20             : #define FBCON_FLAGS_INIT         1
      21             : #define FBCON_FLAGS_CURSOR_TIMER 2
      22             : 
      23             :    /*
      24             :     *    This is the interface between the low-level console driver and the
      25             :     *    low-level frame buffer device
      26             :     */
      27             : 
      28             : struct display {
      29             :     /* Filled in by the low-level console driver */
      30             :     const u_char *fontdata;
      31             :     int userfont;                   /* != 0 if fontdata kmalloc()ed */
      32             :     u_short scrollmode;             /* Scroll Method */
      33             :     u_short inverse;                /* != 0 text black on white as default */
      34             :     short yscroll;                  /* Hardware scrolling */
      35             :     int vrows;                      /* number of virtual rows */
      36             :     int cursor_shape;
      37             :     int con_rotate;
      38             :     u32 xres_virtual;
      39             :     u32 yres_virtual;
      40             :     u32 height;
      41             :     u32 width;
      42             :     u32 bits_per_pixel;
      43             :     u32 grayscale;
      44             :     u32 nonstd;
      45             :     u32 accel_flags;
      46             :     u32 rotate;
      47             :     struct fb_bitfield red;
      48             :     struct fb_bitfield green;
      49             :     struct fb_bitfield blue;
      50             :     struct fb_bitfield transp;
      51             :     const struct fb_videomode *mode;
      52             : };
      53           1 : 
      54             : struct fbcon_ops {
      55             :         void (*bmove)(struct vc_data *vc, struct fb_info *info, int sy,
      56             :                       int sx, int dy, int dx, int height, int width);
      57             :         void (*clear)(struct vc_data *vc, struct fb_info *info, int sy,
      58             :                       int sx, int height, int width);
      59             :         void (*putcs)(struct vc_data *vc, struct fb_info *info,
      60             :                       const unsigned short *s, int count, int yy, int xx,
      61             :                       int fg, int bg);
      62             :         void (*clear_margins)(struct vc_data *vc, struct fb_info *info,
      63             :                               int bottom_only);
      64             :         void (*cursor)(struct vc_data *vc, struct fb_info *info, int mode,
      65             :                        int softback_lines, int fg, int bg);
      66             :         int  (*update_start)(struct fb_info *info);
      67             :         int  (*rotate_font)(struct fb_info *info, struct vc_data *vc);
      68             :         struct fb_var_screeninfo var;  /* copy of the current fb_var_screeninfo */
      69             :         struct timer_list cursor_timer; /* Cursor timer */
      70             :         struct fb_cursor cursor_state;
      71             :         struct display *p;
      72             :         int    currcon;                 /* Current VC. */
      73             :         int    cursor_flash;
      74             :         int    cursor_reset;
      75             :         int    blank_state;
      76             :         int    graphics;
      77             :         int    flags;
      78             :         int    rotate;
      79             :         int    cur_rotate;
      80             :         char  *cursor_data;
      81             :         u8    *fontbuffer;
      82             :         u8    *fontdata;
      83             :         u8    *cursor_src;
      84             :         u32    cursor_size;
      85             :         u32    fd_size;
      86             : };
      87             :     /*
      88             :      *  Attribute Decoding
      89             :      */
      90             : 
      91             : /* Color */
      92             : #define attr_fgcol(fgshift,s)    \
      93             :         (((s) >> (fgshift)) & 0x0f)
      94             : #define attr_bgcol(bgshift,s)    \
      95             :         (((s) >> (bgshift)) & 0x0f)
      96             : 
      97             : /* Monochrome */
      98             : #define attr_bold(s) \
      99             :         ((s) & 0x200)
     100             : #define attr_reverse(s) \
     101             :         ((s) & 0x800)
     102             : #define attr_underline(s) \
     103             :         ((s) & 0x400)
     104             : #define attr_blink(s) \
     105             :         ((s) & 0x8000)
     106             :         
     107             : 
     108             : static inline int mono_col(const struct fb_info *info)
     109             : {
     110         422 :         __u32 max_len;
     111        3798 :         max_len = max(info->var.green.length, info->var.red.length);
     112        3798 :         max_len = max(info->var.blue.length, max_len);
     113         844 :         return (~(0xfff << max_len)) & 0xff;
     114         422 : }
     115             : 
     116             : static inline int attr_col_ec(int shift, struct vc_data *vc,
     117             :                               struct fb_info *info, int is_fg)
     118             : {
     119             :         int is_mono01;
     120             :         int col;
     121             :         int fg;
     122             :         int bg;
     123             : 
     124             :         if (!vc)
     125             :                 return 0;
     126             : 
     127             :         if (vc->vc_can_do_color)
     128             :                 return is_fg ? attr_fgcol(shift,vc->vc_video_erase_char)
     129             :                         : attr_bgcol(shift,vc->vc_video_erase_char);
     130             : 
     131             :         if (!info)
     132             :                 return 0;
     133             : 
     134             :         col = mono_col(info);
     135             :         is_mono01 = info->fix.visual == FB_VISUAL_MONO01;
     136             : 
     137             :         if (attr_reverse(vc->vc_video_erase_char)) {
     138             :                 fg = is_mono01 ? col : 0;
     139             :                 bg = is_mono01 ? 0 : col;
     140             :         }
     141             :         else {
     142             :                 fg = is_mono01 ? 0 : col;
     143             :                 bg = is_mono01 ? col : 0;
     144             :         }
     145             : 
     146             :         return is_fg ? fg : bg;
     147             : }
     148             : 
     149             : #define attr_bgcol_ec(bgshift, vc, info) attr_col_ec(bgshift, vc, info, 0)
     150             : #define attr_fgcol_ec(fgshift, vc, info) attr_col_ec(fgshift, vc, info, 1)
     151             : 
     152             : /* Font */
     153             : #define REFCOUNT(fd)    (((int *)(fd))[-1])
     154             : #define FNTSIZE(fd)     (((int *)(fd))[-2])
     155             : #define FNTCHARCNT(fd)  (((int *)(fd))[-3])
     156             : #define FNTSUM(fd)      (((int *)(fd))[-4])
     157             : #define FONT_EXTRA_WORDS 4
     158             : 
     159             :     /*
     160             :      *  Scroll Method
     161             :      */
     162             :      
     163             : /* There are several methods fbcon can use to move text around the screen:
     164             :  *
     165             :  *                     Operation   Pan    Wrap
     166             :  *---------------------------------------------
     167             :  * SCROLL_MOVE         copyarea    No     No
     168             :  * SCROLL_PAN_MOVE     copyarea    Yes    No
     169             :  * SCROLL_WRAP_MOVE    copyarea    No     Yes
     170             :  * SCROLL_REDRAW       imageblit   No     No
     171             :  * SCROLL_PAN_REDRAW   imageblit   Yes    No
     172             :  * SCROLL_WRAP_REDRAW  imageblit   No     Yes
     173             :  *
     174             :  * (SCROLL_WRAP_REDRAW is not implemented yet)
     175             :  *
     176             :  * In general, fbcon will choose the best scrolling
     177             :  * method based on the rule below:
     178             :  *
     179             :  * Pan/Wrap > accel imageblit > accel copyarea >
     180             :  * soft imageblit > (soft copyarea)
     181             :  *
     182             :  * Exception to the rule: Pan + accel copyarea is
     183             :  * preferred over Pan + accel imageblit.
     184             :  *
     185             :  * The above is typical for PCI/AGP cards. Unless
     186             :  * overridden, fbcon will never use soft copyarea.
     187             :  *
     188             :  * If you need to override the above rule, set the
     189             :  * appropriate flags in fb_info->flags.  For example,
     190             :  * to prefer copyarea over imageblit, set
     191             :  * FBINFO_READS_FAST.
     192             :  *
     193             :  * Other notes:
     194             :  * + use the hardware engine to move the text
     195             :  *    (hw-accelerated copyarea() and fillrect())
     196             :  * + use hardware-supported panning on a large virtual screen
     197             :  * + amifb can not only pan, but also wrap the display by N lines
     198             :  *    (i.e. visible line i = physical line (i+N) % yres).
     199             :  * + read what's already rendered on the screen and
     200             :  *     write it in a different place (this is cfb_copyarea())
     201             :  * + re-render the text to the screen
     202             :  *
     203             :  * Whether to use wrapping or panning can only be figured out at
     204             :  * runtime (when we know whether our font height is a multiple
     205             :  * of the pan/wrap step)
     206             :  *
     207             :  */
     208             : 
     209             : #define SCROLL_MOVE        0x001
     210             : #define SCROLL_PAN_MOVE    0x002
     211             : #define SCROLL_WRAP_MOVE   0x003
     212             : #define SCROLL_REDRAW      0x004
     213             : #define SCROLL_PAN_REDRAW  0x005
     214             : 
     215             : #ifdef CONFIG_FB_TILEBLITTING
     216             : extern void fbcon_set_tileops(struct vc_data *vc, struct fb_info *info);
     217             : #endif
     218             : extern void fbcon_set_bitops(struct fbcon_ops *ops);
     219             : extern int  soft_cursor(struct fb_info *info, struct fb_cursor *cursor);
     220             : 
     221             : #define FBCON_ATTRIBUTE_UNDERLINE 1
     222             : #define FBCON_ATTRIBUTE_REVERSE   2
     223             : #define FBCON_ATTRIBUTE_BOLD      4
     224             : 
     225             : static inline int real_y(struct display *p, int ypos)
     226             : {
     227         498 :         int rows = p->vrows;
     228             : 
     229         498 :         ypos += p->yscroll;
     230        1494 :         return ypos < rows ? ypos : ypos - rows;
     231             : }
     232             : 
     233             : 
     234             : static inline int get_attribute(struct fb_info *info, u16 c)
     235             : {
     236             :         int attribute = 0;
     237             : 
     238             :         if (fb_get_color_depth(&info->var, &info->fix) == 1) {
     239             :                 if (attr_underline(c))
     240             :                         attribute |= FBCON_ATTRIBUTE_UNDERLINE;
     241             :                 if (attr_reverse(c))
     242             :                         attribute |= FBCON_ATTRIBUTE_REVERSE;
     243             :                 if (attr_bold(c))
     244             :                         attribute |= FBCON_ATTRIBUTE_BOLD;
     245             :         }
     246             : 
     247             :         return attribute;
     248             : }
     249             : 
     250             : #define FBCON_SWAP(i,r,v) ({ \
     251             :         typeof(r) _r = (r);  \
     252             :         typeof(v) _v = (v);  \
     253             :         (void) (&_r == &_v); \
     254             :         (i == FB_ROTATE_UR || i == FB_ROTATE_UD) ? _r : _v; })
     255             : 
     256             : #ifdef CONFIG_FRAMEBUFFER_CONSOLE_ROTATION
     257             : extern void fbcon_set_rotate(struct fbcon_ops *ops);
     258             : #else
     259             : #define fbcon_set_rotate(x) do {} while(0)
     260             : #endif /* CONFIG_FRAMEBUFFER_CONSOLE_ROTATION */
     261             : 
     262             : #endif /* _VIDEO_FBCON_H */
     263             : 

Generated by: LCOV version 1.10