Branch data     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 fbcon_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                 :            : 
      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 color, 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 fbcon_display *p;
      72                 :            :         struct fb_info *info;
      73                 :            :         int    currcon;                 /* Current VC. */
      74                 :            :         int    cur_blink_jiffies;
      75                 :            :         int    cursor_flash;
      76                 :            :         int    cursor_reset;
      77                 :            :         int    blank_state;
      78                 :            :         int    graphics;
      79                 :            :         int    save_graphics; /* for debug enter/leave */
      80                 :            :         int    flags;
      81                 :            :         int    rotate;
      82                 :            :         int    cur_rotate;
      83                 :            :         char  *cursor_data;
      84                 :            :         u8    *fontbuffer;
      85                 :            :         u8    *fontdata;
      86                 :            :         u8    *cursor_src;
      87                 :            :         u32    cursor_size;
      88                 :            :         u32    fd_size;
      89                 :            : };
      90                 :            :     /*
      91                 :            :      *  Attribute Decoding
      92                 :            :      */
      93                 :            : 
      94                 :            : /* Color */
      95                 :            : #define attr_fgcol(fgshift,s)    \
      96                 :            :         (((s) >> (fgshift)) & 0x0f)
      97                 :            : #define attr_bgcol(bgshift,s)    \
      98                 :            :         (((s) >> (bgshift)) & 0x0f)
      99                 :            : 
     100                 :            : /* Monochrome */
     101                 :            : #define attr_bold(s) \
     102                 :            :         ((s) & 0x200)
     103                 :            : #define attr_reverse(s) \
     104                 :            :         ((s) & 0x800)
     105                 :            : #define attr_underline(s) \
     106                 :            :         ((s) & 0x400)
     107                 :            : #define attr_blink(s) \
     108                 :            :         ((s) & 0x8000)
     109                 :            :         
     110                 :            : 
     111                 :            : static inline int mono_col(const struct fb_info *info)
     112                 :            : {
     113                 :            :         __u32 max_len;
     114                 :          0 :         max_len = max(info->var.green.length, info->var.red.length);
     115                 :          0 :         max_len = max(info->var.blue.length, max_len);
     116                 :          0 :         return (~(0xfff << max_len)) & 0xff;
     117                 :            : }
     118                 :            : 
     119                 :          0 : static inline int attr_col_ec(int shift, struct vc_data *vc,
     120                 :            :                               struct fb_info *info, int is_fg)
     121                 :            : {
     122                 :            :         int is_mono01;
     123                 :            :         int col;
     124                 :            :         int fg;
     125                 :            :         int bg;
     126                 :            : 
     127                 :          0 :         if (!vc)
     128                 :            :                 return 0;
     129                 :            : 
     130                 :          0 :         if (vc->vc_can_do_color)
     131                 :          0 :                 return is_fg ? attr_fgcol(shift,vc->vc_video_erase_char)
     132                 :            :                         : attr_bgcol(shift,vc->vc_video_erase_char);
     133                 :            : 
     134                 :          0 :         if (!info)
     135                 :            :                 return 0;
     136                 :            : 
     137                 :            :         col = mono_col(info);
     138                 :          0 :         is_mono01 = info->fix.visual == FB_VISUAL_MONO01;
     139                 :            : 
     140                 :          0 :         if (attr_reverse(vc->vc_video_erase_char)) {
     141                 :          0 :                 fg = is_mono01 ? col : 0;
     142                 :          0 :                 bg = is_mono01 ? 0 : col;
     143                 :            :         }
     144                 :            :         else {
     145                 :          0 :                 fg = is_mono01 ? 0 : col;
     146                 :          0 :                 bg = is_mono01 ? col : 0;
     147                 :            :         }
     148                 :            : 
     149                 :          0 :         return is_fg ? fg : bg;
     150                 :            : }
     151                 :            : 
     152                 :            : #define attr_bgcol_ec(bgshift, vc, info) attr_col_ec(bgshift, vc, info, 0)
     153                 :            : #define attr_fgcol_ec(fgshift, vc, info) attr_col_ec(fgshift, vc, info, 1)
     154                 :            : 
     155                 :            : /* Font */
     156                 :            : #define REFCOUNT(fd)    (((int *)(fd))[-1])
     157                 :            : #define FNTSIZE(fd)     (((int *)(fd))[-2])
     158                 :            : #define FNTCHARCNT(fd)  (((int *)(fd))[-3])
     159                 :            : #define FNTSUM(fd)      (((int *)(fd))[-4])
     160                 :            : #define FONT_EXTRA_WORDS 4
     161                 :            : 
     162                 :            :     /*
     163                 :            :      *  Scroll Method
     164                 :            :      */
     165                 :            :      
     166                 :            : /* There are several methods fbcon can use to move text around the screen:
     167                 :            :  *
     168                 :            :  *                     Operation   Pan    Wrap
     169                 :            :  *---------------------------------------------
     170                 :            :  * SCROLL_MOVE         copyarea    No     No
     171                 :            :  * SCROLL_PAN_MOVE     copyarea    Yes    No
     172                 :            :  * SCROLL_WRAP_MOVE    copyarea    No     Yes
     173                 :            :  * SCROLL_REDRAW       imageblit   No     No
     174                 :            :  * SCROLL_PAN_REDRAW   imageblit   Yes    No
     175                 :            :  * SCROLL_WRAP_REDRAW  imageblit   No     Yes
     176                 :            :  *
     177                 :            :  * (SCROLL_WRAP_REDRAW is not implemented yet)
     178                 :            :  *
     179                 :            :  * In general, fbcon will choose the best scrolling
     180                 :            :  * method based on the rule below:
     181                 :            :  *
     182                 :            :  * Pan/Wrap > accel imageblit > accel copyarea >
     183                 :            :  * soft imageblit > (soft copyarea)
     184                 :            :  *
     185                 :            :  * Exception to the rule: Pan + accel copyarea is
     186                 :            :  * preferred over Pan + accel imageblit.
     187                 :            :  *
     188                 :            :  * The above is typical for PCI/AGP cards. Unless
     189                 :            :  * overridden, fbcon will never use soft copyarea.
     190                 :            :  *
     191                 :            :  * If you need to override the above rule, set the
     192                 :            :  * appropriate flags in fb_info->flags.  For example,
     193                 :            :  * to prefer copyarea over imageblit, set
     194                 :            :  * FBINFO_READS_FAST.
     195                 :            :  *
     196                 :            :  * Other notes:
     197                 :            :  * + use the hardware engine to move the text
     198                 :            :  *    (hw-accelerated copyarea() and fillrect())
     199                 :            :  * + use hardware-supported panning on a large virtual screen
     200                 :            :  * + amifb can not only pan, but also wrap the display by N lines
     201                 :            :  *    (i.e. visible line i = physical line (i+N) % yres).
     202                 :            :  * + read what's already rendered on the screen and
     203                 :            :  *     write it in a different place (this is cfb_copyarea())
     204                 :            :  * + re-render the text to the screen
     205                 :            :  *
     206                 :            :  * Whether to use wrapping or panning can only be figured out at
     207                 :            :  * runtime (when we know whether our font height is a multiple
     208                 :            :  * of the pan/wrap step)
     209                 :            :  *
     210                 :            :  */
     211                 :            : 
     212                 :            : #define SCROLL_MOVE        0x001
     213                 :            : #define SCROLL_PAN_MOVE    0x002
     214                 :            : #define SCROLL_WRAP_MOVE   0x003
     215                 :            : #define SCROLL_REDRAW      0x004
     216                 :            : #define SCROLL_PAN_REDRAW  0x005
     217                 :            : 
     218                 :            : #ifdef CONFIG_FB_TILEBLITTING
     219                 :            : extern void fbcon_set_tileops(struct vc_data *vc, struct fb_info *info);
     220                 :            : #endif
     221                 :            : extern void fbcon_set_bitops(struct fbcon_ops *ops);
     222                 :            : extern int  soft_cursor(struct fb_info *info, struct fb_cursor *cursor);
     223                 :            : 
     224                 :            : #define FBCON_ATTRIBUTE_UNDERLINE 1
     225                 :            : #define FBCON_ATTRIBUTE_REVERSE   2
     226                 :            : #define FBCON_ATTRIBUTE_BOLD      4
     227                 :            : 
     228                 :            : static inline int real_y(struct fbcon_display *p, int ypos)
     229                 :            : {
     230                 :          3 :         int rows = p->vrows;
     231                 :            : 
     232                 :          3 :         ypos += p->yscroll;
     233                 :          3 :         return ypos < rows ? ypos : ypos - rows;
     234                 :            : }
     235                 :            : 
     236                 :            : 
     237                 :          3 : static inline int get_attribute(struct fb_info *info, u16 c)
     238                 :            : {
     239                 :            :         int attribute = 0;
     240                 :            : 
     241                 :          3 :         if (fb_get_color_depth(&info->var, &info->fix) == 1) {
     242                 :          0 :                 if (attr_underline(c))
     243                 :            :                         attribute |= FBCON_ATTRIBUTE_UNDERLINE;
     244                 :          0 :                 if (attr_reverse(c))
     245                 :          0 :                         attribute |= FBCON_ATTRIBUTE_REVERSE;
     246                 :          0 :                 if (attr_bold(c))
     247                 :          0 :                         attribute |= FBCON_ATTRIBUTE_BOLD;
     248                 :            :         }
     249                 :            : 
     250                 :          3 :         return attribute;
     251                 :            : }
     252                 :            : 
     253                 :            : #define FBCON_SWAP(i,r,v) ({ \
     254                 :            :         typeof(r) _r = (r);  \
     255                 :            :         typeof(v) _v = (v);  \
     256                 :            :         (void) (&_r == &_v); \
     257                 :            :         (i == FB_ROTATE_UR || i == FB_ROTATE_UD) ? _r : _v; })
     258                 :            : 
     259                 :            : #ifdef CONFIG_FRAMEBUFFER_CONSOLE_ROTATION
     260                 :            : extern void fbcon_set_rotate(struct fbcon_ops *ops);
     261                 :            : #else
     262                 :            : #define fbcon_set_rotate(x) do {} while(0)
     263                 :            : #endif /* CONFIG_FRAMEBUFFER_CONSOLE_ROTATION */
     264                 :            : 
     265                 :            : #endif /* _VIDEO_FBCON_H */