开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
fbcon.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：70k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

fbcon.c：源码内容
  1. /*
  2.  *  linux/drivers/video/fbcon.c -- Low level frame buffer based console driver
  3.  *
  4.  * Copyright (C) 1995 Geert Uytterhoeven
  5.  *
  6.  *
  7.  *  This file is based on the original Amiga console driver (amicon.c):
  8.  *
  9.  * Copyright (C) 1993 Hamish Macdonald
  10.  *    Greg Harp
  11.  * Copyright (C) 1994 David Carter [carter@compsci.bristol.ac.uk]
  12.  *
  13.  *       with work by William Rucklidge (wjr@cs.cornell.edu)
  14.  *    Geert Uytterhoeven
  15.  *    Jes Sorensen (jds@kom.auc.dk)
  16.  *    Martin Apel
  17.  *
  18.  *  and on the original Atari console driver (atacon.c):
  19.  *
  20.  * Copyright (C) 1993 Bjoern Brauel
  21.  *    Roman Hodek
  22.  *
  23.  *       with work by Guenther Kelleter
  24.  *    Martin Schaller
  25.  *    Andreas Schwab
  26.  *
  27.  *  Hardware cursor support added by Emmanuel Marty (core@ggi-project.org)
  28.  *  Smart redraw scrolling, arbitrary font width support, 512char font support
  29.  *  and software scrollback added by 
  30.  *                         Jakub Jelinek (jj@ultra.linux.cz)
  31.  *
  32.  *  Random hacking by Martin Mares <mj@ucw.cz>
  33.  *
  34.  * 2001 - Documented with DocBook
  35.  * - Brad Douglas <brad@neruo.com>
  36.  *
  37.  *  The low level operations for the various display memory organizations are
  38.  *  now in separate source files.
  39.  *
  40.  *  Currently the following organizations are supported:
  41.  *
  42.  *    o afb Amiga bitplanes
  43.  *    o cfb{2,4,8,16,24,32} Packed pixels
  44.  *    o ilbm Amiga interleaved bitplanes
  45.  *    o iplan2p[248] Atari interleaved bitplanes
  46.  *    o mfb Monochrome
  47.  *    o vga VGA characters/attributes
  48.  *
  49.  *  To do:
  50.  *
  51.  *    - Implement 16 plane mode (iplan2p16)
  52.  *
  53.  *
  54.  *  This file is subject to the terms and conditions of the GNU General Public
  55.  *  License.  See the file COPYING in the main directory of this archive for
  56.  *  more details.
  57.  */
  59. #undef FBCONDEBUG
  61. #include <linux/config.h>
  62. #include <linux/module.h>
  63. #include <linux/types.h>
  64. #include <linux/sched.h>
  65. #include <linux/fs.h>
  66. #include <linux/kernel.h>
  67. #include <linux/delay.h> /* MSch: for IRQ probe */
  68. #include <linux/tty.h>
  69. #include <linux/console.h>
  70. #include <linux/string.h>
  71. #include <linux/kd.h>
  72. #include <linux/slab.h>
  73. #include <linux/fb.h>
  74. #include <linux/vt_kern.h>
  75. #include <linux/selection.h>
  76. #include <linux/smp.h>
  77. #include <linux/init.h>
  78. #include <linux/pm.h>
  80. #include <asm/irq.h>
  81. #include <asm/system.h>
  82. #include <asm/uaccess.h>
  83. #ifdef CONFIG_AMIGA
  84. #include <asm/amigahw.h>
  85. #include <asm/amigaints.h>
  86. #endif /* CONFIG_AMIGA */
  87. #ifdef CONFIG_ATARI
  88. #include <asm/atariints.h>
  89. #endif
  90. #ifdef CONFIG_MAC
  91. #include <asm/macints.h>
  92. #endif
  93. #if defined(__mc68000__) || defined(CONFIG_APUS)
  94. #include <asm/machdep.h>
  95. #include <asm/setup.h>
  96. #endif
  97. #ifdef CONFIG_FBCON_VGA_PLANES
  98. #include <asm/io.h>
  99. #endif
  100. #define INCLUDE_LINUX_LOGO_DATA
  101. #define FBCON_LINUX_LOGO
  102. #include <asm/linux_logo.h> 
  104. #include <video/fbcon.h>
  105. #include <video/fbcon-mac.h> /* for 6x11 font on mac */
  106. #include <video/font.h>
  108. #ifdef FBCONDEBUG
  109. #  define DPRINTK(fmt, args...) printk(KERN_DEBUG "%s: " fmt, __FUNCTION__ , ## args)
  110. #else
  111. #  define DPRINTK(fmt, args...)
  112. #endif
  114. struct display fb_display[MAX_NR_CONSOLES];
  115. char con2fb_map[MAX_NR_CONSOLES];
  116. static int logo_lines;
  117. static int logo_shown = -1;
  118. /* Software scrollback */
  119. int fbcon_softback_size = 32768;
  120. static unsigned long softback_buf, softback_curr;
  121. static unsigned long softback_in;
  122. static unsigned long softback_top, softback_end;
  123. static int softback_lines;
  125. #define REFCOUNT(fd) (((int *)(fd))[-1])
  126. #define FNTSIZE(fd) (((int *)(fd))[-2])
  127. #define FNTCHARCNT(fd) (((int *)(fd))[-3])
  128. #define FNTSUM(fd) (((int *)(fd))[-4])
  129. #define FONT_EXTRA_WORDS 4
  131. #define CM_SOFTBACK (8)
  133. #define advance_row(p, delta) (unsigned short *)((unsigned long)(p) + (delta) * conp->vc_size_row)
  135. static void fbcon_free_font(struct display *);
  136. static int fbcon_set_origin(struct vc_data *);
  138. #ifdef CONFIG_PM
  139. static int pm_fbcon_request(struct pm_dev *dev, pm_request_t rqst, void *data);
  140. static struct pm_dev *pm_fbcon;
  141. static int fbcon_sleeping;
  142. #endif
  144. /*
  145.  * Emmanuel: fbcon will now use a hardware cursor if the
  146.  * low-level driver provides a non-NULL dispsw->cursor pointer,
  147.  * in which case the hardware should do blinking, etc.
  148.  *
  149.  * if dispsw->cursor is NULL, use Atari alike software cursor
  150.  */
  152. static int cursor_drawn;
  154. #define CURSOR_DRAW_DELAY (1)
  156. /* # VBL ints between cursor state changes */
  157. #define ARM_CURSOR_BLINK_RATE (10)
  158. #define AMIGA_CURSOR_BLINK_RATE (20)
  159. #define ATARI_CURSOR_BLINK_RATE (42)
  160. #define MAC_CURSOR_BLINK_RATE (32)
  161. #define DEFAULT_CURSOR_BLINK_RATE (20)
  163. static int vbl_cursor_cnt;
  164. static int cursor_on;
  165. static int cursor_blink_rate;
  167. static inline void cursor_undrawn(void)
  168. {
  169.     vbl_cursor_cnt = 0;
  170.     cursor_drawn = 0;
  171. }
  174. #define divides(a, b) ((!(a) || (b)%(a)) ? 0 : 1)
  177. /*
  178.  *  Interface used by the world
  179.  */
  181. static const char *fbcon_startup(void);
  182. static void fbcon_init(struct vc_data *conp, int init);
  183. static void fbcon_deinit(struct vc_data *conp);
  184. static int fbcon_changevar(int con);
  185. static void fbcon_clear(struct vc_data *conp, int sy, int sx, int height,
  186.        int width);
  187. static void fbcon_putc(struct vc_data *conp, int c, int ypos, int xpos);
  188. static void fbcon_putcs(struct vc_data *conp, const unsigned short *s, int count,
  189. int ypos, int xpos);
  190. static void fbcon_cursor(struct vc_data *conp, int mode);
  191. static int fbcon_scroll(struct vc_data *conp, int t, int b, int dir,
  192.  int count);
  193. static void fbcon_bmove(struct vc_data *conp, int sy, int sx, int dy, int dx,
  194. int height, int width);
  195. static int fbcon_switch(struct vc_data *conp);
  196. static int fbcon_blank(struct vc_data *conp, int blank);
  197. static int fbcon_font_op(struct vc_data *conp, struct console_font_op *op);
  198. static int fbcon_set_palette(struct vc_data *conp, unsigned char *table);
  199. static int fbcon_scrolldelta(struct vc_data *conp, int lines);
  202. /*
  203.  *  Internal routines
  204.  */
  206. static void fbcon_setup(int con, int init, int logo);
  207. static __inline__ int real_y(struct display *p, int ypos);
  208. static void fbcon_vbl_handler(int irq, void *dummy, struct pt_regs *fp);
  209. static __inline__ void updatescrollmode(struct display *p);
  210. static __inline__ void ywrap_up(int unit, struct vc_data *conp,
  211. struct display *p, int count);
  212. static __inline__ void ywrap_down(int unit, struct vc_data *conp,
  213.   struct display *p, int count);
  214. static __inline__ void ypan_up(int unit, struct vc_data *conp,
  215.        struct display *p, int count);
  216. static __inline__ void ypan_down(int unit, struct vc_data *conp,
  217.  struct display *p, int count);
  218. static void fbcon_bmove_rec(struct display *p, int sy, int sx, int dy, int dx,
  219.     int height, int width, u_int y_break);
  221. static int fbcon_show_logo(void);
  223. #ifdef CONFIG_MAC
  224. /*
  225.  * On the Macintoy, there may or may not be a working VBL int. We need to probe
  226.  */
  227. static int vbl_detected;
  229. static void fbcon_vbl_detect(int irq, void *dummy, struct pt_regs *fp)
  230. {
  231.       vbl_detected++;
  232. }
  233. #endif
  235. static void cursor_timer_handler(unsigned long dev_addr);
  237. static struct timer_list cursor_timer = {
  238.     function: cursor_timer_handler
  239. };
  240. static int use_timer_cursor;
  242. static void cursor_timer_handler(unsigned long dev_addr)
  243. {
  244.       fbcon_vbl_handler(0, NULL, NULL);
  245.       cursor_timer.expires = jiffies+HZ/50;
  246.       add_timer(&cursor_timer);
  247. }
  250. /**
  251.  * PROC_CONSOLE - find the attached tty or visible console
  252.  * @info: frame buffer info structure
  253.  *
  254.  * Finds the tty attached to the process or visible console if
  255.  * the process is not directly attached to a tty (e.g. remote
  256.  * user) for device @info.
  257.  *
  258.  * Returns -1 errno on error, or tty/visible console number
  259.  * on success.
  260.  *
  261.  */
  263. int PROC_CONSOLE(const struct fb_info *info)
  264. {
  265.         int fgc;
  266.         
  267.         if (info->display_fg != NULL)
  268.                 fgc = info->display_fg->vc_num;
  269.         else
  270.                 return -1;
  271.                 
  272.         if (!current->tty)
  273.                 return fgc;
  275.         if (current->tty->driver.type != TTY_DRIVER_TYPE_CONSOLE)
  276.                 /* XXX Should report error here? */
  277.                 return fgc;
  279.         if (MINOR(current->tty->device) < 1)
  280.                 return fgc;
  282.         return MINOR(current->tty->device) - 1;
  283. }
  286. /**
  287.  * set_all_vcs - set all virtual consoles to match
  288.  * @fbidx: frame buffer index (e.g. fb0, fb1, ...)
  289.  * @fb: frame buffer ops structure
  290.  * @var: frame buffer screen structure to set
  291.  * @info: frame buffer info structure
  292.  *
  293.  * Set all virtual consoles to match screen info set in @var
  294.  * for device @info.
  295.  *
  296.  * Returns negative errno on error, or zero on success.
  297.  *
  298.  */
  300. int set_all_vcs(int fbidx, struct fb_ops *fb, struct fb_var_screeninfo *var,
  301.                 struct fb_info *info)
  302. {
  303.     int unit, err;
  305.     var->activate |= FB_ACTIVATE_TEST;
  306.     err = fb->fb_set_var(var, PROC_CONSOLE(info), info);
  307.     var->activate &= ~FB_ACTIVATE_TEST;
  308.     if (err)
  309.             return err;
  310.     for (unit = 0; unit < MAX_NR_CONSOLES; unit++)
  311.             if (fb_display[unit].conp && con2fb_map[unit] == fbidx)
  312.                     fb->fb_set_var(var, unit, info);
  313.     return 0;
  314. }
  317. /**
  318.  * set_con2fb_map - map console to frame buffer device
  319.  * @unit: virtual console number to map
  320.  * @newidx: frame buffer index to map virtual console to
  321.  *
  322.  * Maps a virtual console @unit to a frame buffer device
  323.  * @newidx.
  324.  *
  325.  */
  327. void set_con2fb_map(int unit, int newidx)
  328. {
  329.     int oldidx = con2fb_map[unit];
  330.     struct fb_info *oldfb, *newfb;
  331.     struct vc_data *conp;
  332.     char *fontdata;
  333.     unsigned short fontwidth, fontheight, fontwidthlog, fontheightlog;
  334.     int userfont;
  336.     if (newidx != con2fb_map[unit]) {
  337.        oldfb = registered_fb[oldidx];
  338.        newfb = registered_fb[newidx];
  339. if (newfb->fbops->owner)
  340. __MOD_INC_USE_COUNT(newfb->fbops->owner);
  341. if (newfb->fbops->fb_open && newfb->fbops->fb_open(newfb,0)) {
  342. if (newfb->fbops->owner)
  343. __MOD_DEC_USE_COUNT(newfb->fbops->owner);
  344. return;
  345. }
  346. if (oldfb->fbops->fb_release)
  347. oldfb->fbops->fb_release(oldfb,0);
  348. if (oldfb->fbops->owner)
  349. __MOD_DEC_USE_COUNT(oldfb->fbops->owner);
  350.        conp = fb_display[unit].conp;
  351.        fontdata = fb_display[unit].fontdata;
  352.        fontwidth = fb_display[unit]._fontwidth;
  353.        fontheight = fb_display[unit]._fontheight;
  354.        fontwidthlog = fb_display[unit]._fontwidthlog;
  355.        fontheightlog = fb_display[unit]._fontheightlog;
  356.        userfont = fb_display[unit].userfont;
  357.        con2fb_map[unit] = newidx;
  358.        fb_display[unit] = *(newfb->disp);
  359.        fb_display[unit].conp = conp;
  360.        fb_display[unit].fontdata = fontdata;
  361.        fb_display[unit]._fontwidth = fontwidth;
  362.        fb_display[unit]._fontheight = fontheight;
  363.        fb_display[unit]._fontwidthlog = fontwidthlog;
  364.        fb_display[unit]._fontheightlog = fontheightlog;
  365.        fb_display[unit].userfont = userfont;
  366.        fb_display[unit].fb_info = newfb;
  367.        if (conp)
  368.    conp->vc_display_fg = &newfb->display_fg;
  369.        if (!newfb->display_fg)
  370.    newfb->display_fg = conp;
  371.        if (!newfb->changevar)
  372.            newfb->changevar = oldfb->changevar;
  373.        /* tell console var has changed */
  374.        if (newfb->changevar)
  375.            newfb->changevar(unit);
  376.    }
  377. }
  379. /*
  380.  *  Low Level Operations
  381.  */
  383. struct display_switch fbcon_dummy;
  385. /* NOTE: fbcon cannot be __init: it may be called from take_over_console later */
  387. static const char *fbcon_startup(void)
  388. {
  389.     const char *display_desc = "frame buffer device";
  390.     int irqres = 1;
  391.     static int done = 0;
  393.     /*
  394.      *  If num_registered_fb is zero, this is a call for the dummy part.
  395.      *  The frame buffer devices weren't initialized yet.
  396.      */
  397.     if (!num_registered_fb || done)
  398. return display_desc;
  399.     done = 1;
  401. #ifdef CONFIG_AMIGA
  402.     if (MACH_IS_AMIGA) {
  403. cursor_blink_rate = AMIGA_CURSOR_BLINK_RATE;
  404. irqres = request_irq(IRQ_AMIGA_VERTB, fbcon_vbl_handler, 0,
  405.      "console/cursor", fbcon_vbl_handler);
  406.     }
  407. #endif /* CONFIG_AMIGA */
  408. #ifdef CONFIG_ATARI
  409.     if (MACH_IS_ATARI) {
  410. cursor_blink_rate = ATARI_CURSOR_BLINK_RATE;
  411. irqres = request_irq(IRQ_AUTO_4, fbcon_vbl_handler, IRQ_TYPE_PRIO,
  412.      "console/cursor", fbcon_vbl_handler);
  413.     }
  414. #endif /* CONFIG_ATARI */
  416. #ifdef CONFIG_MAC
  417.     /*
  418.      * On a Macintoy, the VBL interrupt may or may not be active. 
  419.      * As interrupt based cursor is more reliable and race free, we 
  420.      * probe for VBL interrupts.
  421.      */
  422.     if (MACH_IS_MAC) {
  423. int ct = 0;
  424. /*
  425.  * Probe for VBL: set temp. handler ...
  426.  */
  427. irqres = request_irq(IRQ_MAC_VBL, fbcon_vbl_detect, 0,
  428.      "console/cursor", fbcon_vbl_detect);
  429. vbl_detected = 0;
  431. /*
  432.  * ... and spin for 20 ms ...
  433.  */
  434. while (!vbl_detected && ++ct<1000)
  435.     udelay(20);
  436.  
  437. if(ct==1000)
  438.     printk("fbcon_startup: No VBL detected, using timer based cursor.n");
  439.  
  440. free_irq(IRQ_MAC_VBL, fbcon_vbl_detect);
  442. if (vbl_detected) {
  443.     /*
  444.      * interrupt based cursor ok
  445.      */
  446.     cursor_blink_rate = MAC_CURSOR_BLINK_RATE;
  447.     irqres = request_irq(IRQ_MAC_VBL, fbcon_vbl_handler, 0,
  448.  "console/cursor", fbcon_vbl_handler);
  449. } else {
  450.     /*
  451.      * VBL not detected: fall through, use timer based cursor
  452.      */
  453.     irqres = 1;
  454. }
  455.     }
  456. #endif /* CONFIG_MAC */
  458. #if defined(__arm__) && defined(IRQ_VSYNCPULSE)
  459.     cursor_blink_rate = ARM_CURSOR_BLINK_RATE;
  460.     irqres = request_irq(IRQ_VSYNCPULSE, fbcon_vbl_handler, SA_SHIRQ,
  461.  "console/cursor", fbcon_vbl_handler);
  462. #endif
  464.     if (irqres) {
  465. use_timer_cursor = 1;
  466. cursor_blink_rate = DEFAULT_CURSOR_BLINK_RATE;
  467. cursor_timer.expires = jiffies+HZ/50;
  468. add_timer(&cursor_timer);
  469.     }
  471. #ifdef CONFIG_PM
  472.     pm_fbcon = pm_register(PM_SYS_DEV, PM_SYS_VGA, pm_fbcon_request);
  473. #endif
  475.     return display_desc;
  476. }
  479. static void fbcon_init(struct vc_data *conp, int init)
  480. {
  481.     int unit = conp->vc_num;
  482.     struct fb_info *info;
  484.     /* on which frame buffer will we open this console? */
  485.     info = registered_fb[(int)con2fb_map[unit]];
  487.     info->changevar = &fbcon_changevar;
  488.     fb_display[unit] = *(info->disp); /* copy from default */
  489.     DPRINTK("mode:   %sn",info->modename);
  490.     DPRINTK("visual: %dn",fb_display[unit].visual);
  491.     DPRINTK("res:    %dx%d-%dn",fb_display[unit].var.xres,
  492.                      fb_display[unit].var.yres,
  493.                      fb_display[unit].var.bits_per_pixel);
  494.     fb_display[unit].conp = conp;
  495.     fb_display[unit].fb_info = info;
  496.     /* clear out the cmap so we don't have dangling pointers */
  497.     fb_display[unit].cmap.len = 0;
  498.     fb_display[unit].cmap.red = 0;
  499.     fb_display[unit].cmap.green = 0;
  500.     fb_display[unit].cmap.blue = 0;
  501.     fb_display[unit].cmap.transp = 0;
  502.     fbcon_setup(unit, init, !init);
  503.     /* Must be done after fbcon_setup to prevent excess updates */
  504.     conp->vc_display_fg = &info->display_fg;
  505.     if (!info->display_fg)
  506.         info->display_fg = conp;
  507. }
  510. static void fbcon_deinit(struct vc_data *conp)
  511. {
  512.     int unit = conp->vc_num;
  513.     struct display *p = &fb_display[unit];
  515.     fbcon_free_font(p);
  516.     p->dispsw = &fbcon_dummy;
  517.     p->conp = 0;
  518. }
  521. static int fbcon_changevar(int con)
  522. {
  523.     if (fb_display[con].conp)
  524.     fbcon_setup(con, 0, 0);
  525.     return 0;
  526. }
  529. static __inline__ void updatescrollmode(struct display *p)
  530. {
  531.     int m;
  532.     if (p->scrollmode & __SCROLL_YFIXED)
  533.      return;
  534.     if (divides(p->ywrapstep, fontheight(p)) &&
  535. divides(fontheight(p), p->var.yres_virtual))
  536. m = __SCROLL_YWRAP;
  537.     else if (divides(p->ypanstep, fontheight(p)) &&
  538.      p->var.yres_virtual >= p->var.yres+fontheight(p))
  539. m = __SCROLL_YPAN;
  540.     else if (p->scrollmode & __SCROLL_YNOMOVE)
  541.      m = __SCROLL_YREDRAW;
  542.     else
  543. m = __SCROLL_YMOVE;
  544.     p->scrollmode = (p->scrollmode & ~__SCROLL_YMASK) | m;
  545. }
  547. static void fbcon_font_widths(struct display *p)
  548. {
  549.     int i;
  550.     
  551.     p->_fontwidthlog = 0;
  552.     for (i = 2; i <= 6; i++)
  553.      if (fontwidth(p) == (1 << i))
  554.     p->_fontwidthlog = i;
  555.     p->_fontheightlog = 0;
  556.     for (i = 2; i <= 6; i++)
  557.      if (fontheight(p) == (1 << i))
  558.     p->_fontheightlog = i;
  559. }
  561. #define fontwidthvalid(p,w) ((p)->dispsw->fontwidthmask & FONTWIDTH(w))
  563. static void fbcon_setup(int con, int init, int logo)
  564. {
  565.     struct display *p = &fb_display[con];
  566.     struct vc_data *conp = p->conp;
  567.     int nr_rows, nr_cols;
  568.     int old_rows, old_cols;
  569.     unsigned short *save = NULL, *r, *q;
  570.     int i, charcnt = 256;
  571.     struct fbcon_font_desc *font;
  572.     
  573.     if (con != fg_console || (p->fb_info->flags & FBINFO_FLAG_MODULE) ||
  574.         p->type == FB_TYPE_TEXT)
  575.      logo = 0;
  577.     p->var.xoffset = p->var.yoffset = p->yscroll = 0;  /* reset wrap/pan */
  579.     if (con == fg_console && p->type != FB_TYPE_TEXT) {   
  580. if (fbcon_softback_size) {
  581.     if (!softback_buf) {
  582. softback_buf = (unsigned long)kmalloc(fbcon_softback_size, GFP_KERNEL);
  583. if (!softback_buf) {
  584.                  fbcon_softback_size = 0;
  585.                  softback_top = 0;
  586.      }
  587.          }
  588. } else {
  589.     if (softback_buf) {
  590. kfree((void *)softback_buf);
  591. softback_buf = 0;
  592. softback_top = 0;
  593.     }
  594. }
  595. if (softback_buf)
  596.     softback_in = softback_top = softback_curr = softback_buf;
  597. softback_lines = 0;
  598.     }
  599.     
  600.     for (i = 0; i < MAX_NR_CONSOLES; i++)
  601.      if (i != con && fb_display[i].fb_info == p->fb_info &&
  602.          fb_display[i].conp && fb_display[i].fontdata)
  603.      break;
  605.     fbcon_free_font(p);    
  606.     if (i < MAX_NR_CONSOLES) {
  607.      struct display *q = &fb_display[i];
  609.         if (fontwidthvalid(p,fontwidth(q))) {
  610.             /* If we are not the first console on this
  611.                fb, copy the font from that console */
  612.     p->_fontwidth = q->_fontwidth;
  613.     p->_fontheight = q->_fontheight;
  614.          p->_fontwidthlog = q->_fontwidthlog;
  615.          p->_fontheightlog = q->_fontheightlog;
  616.          p->fontdata = q->fontdata;
  617.          p->userfont = q->userfont; 
  618.          if (p->userfont) {
  619.      REFCOUNT(p->fontdata)++;
  620.      charcnt = FNTCHARCNT(p->fontdata);
  621.          }
  622.          con_copy_unimap(con, i);
  623.      }
  624.     }
  626.     if (!p->fontdata) {
  627.         if (!p->fb_info->fontname[0] ||
  628.     !(font = fbcon_find_font(p->fb_info->fontname)))
  629.         font = fbcon_get_default_font(p->var.xres, p->var.yres);
  630.         p->_fontwidth = font->width;
  631.         p->_fontheight = font->height;
  632.         p->fontdata = font->data;
  633.         fbcon_font_widths(p);
  634.     }
  635.     
  636.     if (!fontwidthvalid(p,fontwidth(p))) {
  637. #ifdef CONFIG_MAC
  638. if (MACH_IS_MAC)
  639.     /* ++Geert: hack to make 6x11 fonts work on mac */
  640.     p->dispsw = &fbcon_mac;
  641. else
  642. #endif
  643. {
  644.     /* ++Geert: changed from panic() to `correct and continue' */
  645.     printk(KERN_ERR "fbcon_setup: No support for fontwidth %dn", fontwidth(p));
  646.     p->dispsw = &fbcon_dummy;
  647. }
  648.     }
  649.     if (p->dispsw->set_font)
  650.      p->dispsw->set_font(p, fontwidth(p), fontheight(p));
  651.     updatescrollmode(p);
  652.     
  653.     old_cols = conp->vc_cols;
  654.     old_rows = conp->vc_rows;
  655.     
  656.     nr_cols = p->var.xres/fontwidth(p);
  657.     nr_rows = p->var.yres/fontheight(p);
  658.     
  659.     if (logo) {
  660.      /* Need to make room for the logo */
  661. int cnt;
  662. int step;
  663.     
  664.      logo_lines = (LOGO_H + fontheight(p) - 1) / fontheight(p);
  665.      q = (unsigned short *)(conp->vc_origin + conp->vc_size_row * old_rows);
  666.      step = logo_lines * old_cols;
  667.      for (r = q - logo_lines * old_cols; r < q; r++)
  668.          if (scr_readw(r) != conp->vc_video_erase_char)
  669.           break;
  670. if (r != q && nr_rows >= old_rows + logo_lines) {
  671.          save = kmalloc(logo_lines * nr_cols * 2, GFP_KERNEL);
  672.          if (save) {
  673.              int i = old_cols < nr_cols ? old_cols : nr_cols;
  674.           scr_memsetw(save, conp->vc_video_erase_char, logo_lines * nr_cols * 2);
  675.           r = q - step;
  676.           for (cnt = 0; cnt < logo_lines; cnt++, r += i)
  677.           scr_memcpyw(save + cnt * nr_cols, r, 2 * i);
  678.           r = q;
  679.          }
  680.      }
  681.      if (r == q) {
  682.          /* We can scroll screen down */
  683.     r = q - step - old_cols;
  684.          for (cnt = old_rows - logo_lines; cnt > 0; cnt--) {
  685.           scr_memcpyw(r + step, r, conp->vc_size_row);
  686.           r -= old_cols;
  687.          }
  688.          if (!save) {
  689.      conp->vc_y += logo_lines;
  690.      conp->vc_pos += logo_lines * conp->vc_size_row;
  691.          }
  692.      }
  693.      scr_memsetw((unsigned short *)conp->vc_origin,
  694.     conp->vc_video_erase_char, 
  695.     conp->vc_size_row * logo_lines);
  696.     }
  697.     
  698.     /*
  699.      *  ++guenther: console.c:vc_allocate() relies on initializing
  700.      *  vc_{cols,rows}, but we must not set those if we are only
  701.      *  resizing the console.
  702.      */
  703.     if (init) {
  704. conp->vc_cols = nr_cols;
  705. conp->vc_rows = nr_rows;
  706.     }
  707.     p->vrows = p->var.yres_virtual/fontheight(p);
  708.     if ((p->var.yres % fontheight(p)) &&
  709. (p->var.yres_virtual % fontheight(p) < p->var.yres % fontheight(p)))
  710. p->vrows--;
  711.     conp->vc_can_do_color = p->var.bits_per_pixel != 1;
  712.     conp->vc_complement_mask = conp->vc_can_do_color ? 0x7700 : 0x0800;
  713.     if (charcnt == 256) {
  714.      conp->vc_hi_font_mask = 0;
  715.      p->fgshift = 8;
  716.      p->bgshift = 12;
  717.      p->charmask = 0xff;
  718.     } else {
  719.      conp->vc_hi_font_mask = 0x100;
  720.      if (conp->vc_can_do_color)
  721.     conp->vc_complement_mask <<= 1;
  722.      p->fgshift = 9;
  723.      p->bgshift = 13;
  724.      p->charmask = 0x1ff;
  725.     }
  727.     if (p->dispsw == &fbcon_dummy)
  728. printk(KERN_WARNING "fbcon_setup: type %d (aux %d, depth %d) not "
  729.        "supportedn", p->type, p->type_aux, p->var.bits_per_pixel);
  730.     p->dispsw->setup(p);
  732.     p->fgcol = p->var.bits_per_pixel > 2 ? 7 : (1<<p->var.bits_per_pixel)-1;
  733.     p->bgcol = 0;
  735.     if (!init) {
  736. if (conp->vc_cols != nr_cols || conp->vc_rows != nr_rows)
  737.     vc_resize_con(nr_rows, nr_cols, con);
  738. else if (CON_IS_VISIBLE(conp) &&
  739.  vt_cons[conp->vc_num]->vc_mode == KD_TEXT) {
  740.     if (p->dispsw->clear_margins)
  741. p->dispsw->clear_margins(conp, p, 0);
  742.     update_screen(con);
  743. }
  744. if (save) {
  745.          q = (unsigned short *)(conp->vc_origin + conp->vc_size_row * old_rows);
  746.     scr_memcpyw(q, save, logo_lines * nr_cols * 2);
  747.     conp->vc_y += logo_lines;
  748.          conp->vc_pos += logo_lines * conp->vc_size_row;
  749.          kfree(save);
  750. }
  751.     }
  753.     if (logo) {
  754. logo_shown = -2;
  755.      conp->vc_top = logo_lines;
  756.     }
  757.     
  758.     if (con == fg_console && softback_buf) {
  759.      int l = fbcon_softback_size / conp->vc_size_row;
  760.      if (l > 5)
  761.          softback_end = softback_buf + l * conp->vc_size_row;
  762.      else {
  763.          /* Smaller scrollback makes no sense, and 0 would screw
  764.             the operation totally */
  765.          softback_top = 0;
  766.      }
  767.     }
  768. }
  771. /* ====================================================================== */
  773. /*  fbcon_XXX routines - interface used by the world
  774.  *
  775.  *  This system is now divided into two levels because of complications
  776.  *  caused by hardware scrolling. Top level functions:
  777.  *
  778.  * fbcon_bmove(), fbcon_clear(), fbcon_putc()
  779.  *
  780.  *  handles y values in range [0, scr_height-1] that correspond to real
  781.  *  screen positions. y_wrap shift means that first line of bitmap may be
  782.  *  anywhere on this display. These functions convert lineoffsets to
  783.  *  bitmap offsets and deal with the wrap-around case by splitting blits.
  784.  *
  785.  * fbcon_bmove_physical_8()    -- These functions fast implementations
  786.  * fbcon_clear_physical_8()    -- of original fbcon_XXX fns.
  787.  * fbcon_putc_physical_8()     -- (fontwidth != 8) may be added later
  788.  *
  789.  *  WARNING:
  790.  *
  791.  *  At the moment fbcon_putc() cannot blit across vertical wrap boundary
  792.  *  Implies should only really hardware scroll in rows. Only reason for
  793.  *  restriction is simplicity & efficiency at the moment.
  794.  */
  796. static __inline__ int real_y(struct display *p, int ypos)
  797. {
  798.     int rows = p->vrows;
  800.     ypos += p->yscroll;
  801.     return ypos < rows ? ypos : ypos-rows;
  802. }
  805. static void fbcon_clear(struct vc_data *conp, int sy, int sx, int height,
  806. int width)
  807. {
  808.     int unit = conp->vc_num;
  809.     struct display *p = &fb_display[unit];
  810.     u_int y_break;
  811.     int redraw_cursor = 0;
  813. #ifdef CONFIG_CONSOLE_PM // bushi
  814.     if (!p->can_soft_blank && console_blanked)
  815. return;
  816. #endif
  818.     if (!height || !width)
  819. return;
  821.     if ((sy <= p->cursor_y) && (p->cursor_y < sy+height) &&
  822. (sx <= p->cursor_x) && (p->cursor_x < sx+width)) {
  823. cursor_undrawn();
  824. redraw_cursor = 1;
  825.     }
  827.     /* Split blits that cross physical y_wrap boundary */
  829.     y_break = p->vrows-p->yscroll;
  830.     if (sy < y_break && sy+height-1 >= y_break) {
  831. u_int b = y_break-sy;
  832. p->dispsw->clear(conp, p, real_y(p, sy), sx, b, width);
  833. p->dispsw->clear(conp, p, real_y(p, sy+b), sx, height-b, width);
  834.     } else
  835. p->dispsw->clear(conp, p, real_y(p, sy), sx, height, width);
  837.     if (redraw_cursor)
  838. vbl_cursor_cnt = CURSOR_DRAW_DELAY;
  839. }
  842. static void fbcon_putc(struct vc_data *conp, int c, int ypos, int xpos)
  843. {
  844.     int unit = conp->vc_num;
  845.     struct display *p = &fb_display[unit];
  846.     int redraw_cursor = 0;
  848. #ifdef CONFIG_CONSOLE_PM // bushi
  849.     if (!p->can_soft_blank && console_blanked)
  850.     return;
  851. #endif
  852.     
  853.     if (vt_cons[unit]->vc_mode != KD_TEXT)
  854.          return;
  856.     if ((p->cursor_x == xpos) && (p->cursor_y == ypos)) {
  857.     cursor_undrawn();
  858.     redraw_cursor = 1;
  859.     }
  861.     p->dispsw->putc(conp, p, c, real_y(p, ypos), xpos);
  863.     if (redraw_cursor)
  864.     vbl_cursor_cnt = CURSOR_DRAW_DELAY;
  865. }
  868. static void fbcon_putcs(struct vc_data *conp, const unsigned short *s, int count,
  869.        int ypos, int xpos)
  870. {
  871.     int unit = conp->vc_num;
  872.     struct display *p = &fb_display[unit];
  873.     int redraw_cursor = 0;
  875. #ifdef CONFIG_CONSOLE_PM // bushi
  876.     if (!p->can_soft_blank && console_blanked)
  877.     return;
  878. #endif
  880.     if (vt_cons[unit]->vc_mode != KD_TEXT)
  881.          return;
  883.     if ((p->cursor_y == ypos) && (xpos <= p->cursor_x) &&
  884. (p->cursor_x < (xpos + count))) {
  885.     cursor_undrawn();
  886.     redraw_cursor = 1;
  887.     }
  888.     p->dispsw->putcs(conp, p, s, count, real_y(p, ypos), xpos);
  889.     if (redraw_cursor)
  890.     vbl_cursor_cnt = CURSOR_DRAW_DELAY;
  891. }
  894. static void fbcon_cursor(struct vc_data *conp, int mode)
  895. {
  896.     int unit = conp->vc_num;
  897.     struct display *p = &fb_display[unit];
  898.     int y = conp->vc_y;
  899.     
  900.     if (mode & CM_SOFTBACK) {
  901.      mode &= ~CM_SOFTBACK;
  902.      if (softback_lines) {
  903.          if (y + softback_lines >= conp->vc_rows)
  904.      mode = CM_ERASE;
  905.          else
  906.              y += softback_lines;
  907.      }
  908.     } else if (softback_lines)
  909.         fbcon_set_origin(conp);
  911.     /* do we have a hardware cursor ? */
  912.     if (p->dispsw->cursor) {
  913. p->cursor_x = conp->vc_x;
  914. p->cursor_y = y;
  915. p->dispsw->cursor(p, mode, p->cursor_x, real_y(p, p->cursor_y));
  916. return;
  917.     }
  919.     /* Avoid flickering if there's no real change. */
  920.     if (p->cursor_x == conp->vc_x && p->cursor_y == y &&
  921. (mode == CM_ERASE) == !cursor_on)
  922. return;
  924.     cursor_on = 0;
  925.     if (cursor_drawn)
  926.         p->dispsw->revc(p, p->cursor_x, real_y(p, p->cursor_y));
  928.     p->cursor_x = conp->vc_x;
  929.     p->cursor_y = y;
  931.     switch (mode) {
  932.         case CM_ERASE:
  933.             cursor_drawn = 0;
  934.             break;
  935.         case CM_MOVE:
  936.         case CM_DRAW:
  937.             if (cursor_drawn)
  938.         p->dispsw->revc(p, p->cursor_x, real_y(p, p->cursor_y));
  939.             vbl_cursor_cnt = CURSOR_DRAW_DELAY;
  940.             cursor_on = 1;
  941.             break;
  942.         }
  943. }
  946. static void fbcon_vbl_handler(int irq, void *dummy, struct pt_regs *fp)
  947. {
  948.     struct display *p;
  950.     if (!cursor_on)
  951. return;
  953.     if (vbl_cursor_cnt && --vbl_cursor_cnt == 0) {
  954. p = &fb_display[fg_console];
  955. if (p->dispsw->revc)
  956. p->dispsw->revc(p, p->cursor_x, real_y(p, p->cursor_y));
  957. cursor_drawn ^= 1;
  958. vbl_cursor_cnt = cursor_blink_rate;
  959.     }
  960. }
  962. static int scrollback_phys_max = 0;
  963. static int scrollback_max = 0;
  964. static int scrollback_current = 0;
  966. static __inline__ void ywrap_up(int unit, struct vc_data *conp,
  967. struct display *p, int count)
  968. {
  969.     p->yscroll += count;
  970.     if (p->yscroll >= p->vrows) /* Deal with wrap */
  971. p->yscroll -= p->vrows;
  972.     p->var.xoffset = 0;
  973.     p->var.yoffset = p->yscroll*fontheight(p);
  974.     p->var.vmode |= FB_VMODE_YWRAP;
  975.     p->fb_info->updatevar(unit, p->fb_info);
  976.     scrollback_max += count;
  977.     if (scrollback_max > scrollback_phys_max)
  978. scrollback_max = scrollback_phys_max;
  979.     scrollback_current = 0;
  980. }
  983. static __inline__ void ywrap_down(int unit, struct vc_data *conp,
  984.   struct display *p, int count)
  985. {
  986.     p->yscroll -= count;
  987.     if (p->yscroll < 0) /* Deal with wrap */
  988. p->yscroll += p->vrows;
  989.     p->var.xoffset = 0;
  990.     p->var.yoffset = p->yscroll*fontheight(p);
  991.     p->var.vmode |= FB_VMODE_YWRAP;
  992.     p->fb_info->updatevar(unit, p->fb_info);
  993.     scrollback_max -= count;
  994.     if (scrollback_max < 0)
  995. scrollback_max = 0;
  996.     scrollback_current = 0;
  997. }
  1000. static __inline__ void ypan_up(int unit, struct vc_data *conp,
  1001.        struct display *p, int count)
  1002. {
  1003.     p->yscroll += count;
  1004.     if (p->yscroll > p->vrows-conp->vc_rows) {
  1005. p->dispsw->bmove(p, p->vrows-conp->vc_rows, 0, 0, 0,
  1006.  conp->vc_rows, conp->vc_cols);
  1007. p->yscroll -= p->vrows-conp->vc_rows;
  1008.     }
  1009.     p->var.xoffset = 0;
  1010.     p->var.yoffset = p->yscroll*fontheight(p);
  1011.     p->var.vmode &= ~FB_VMODE_YWRAP;
  1012.     p->fb_info->updatevar(unit, p->fb_info);
  1013.     if (p->dispsw->clear_margins)
  1014. p->dispsw->clear_margins(conp, p, 1);
  1015.     scrollback_max += count;
  1016.     if (scrollback_max > scrollback_phys_max)
  1017. scrollback_max = scrollback_phys_max;
  1018.     scrollback_current = 0;
  1019. }
  1022. static __inline__ void ypan_down(int unit, struct vc_data *conp,
  1023.  struct display *p, int count)
  1024. {
  1025.     p->yscroll -= count;
  1026.     if (p->yscroll < 0) {
  1027. p->dispsw->bmove(p, 0, 0, p->vrows-conp->vc_rows, 0,
  1028.  conp->vc_rows, conp->vc_cols);
  1029. p->yscroll += p->vrows-conp->vc_rows;
  1030.     }
  1031.     p->var.xoffset = 0;
  1032.     p->var.yoffset = p->yscroll*fontheight(p);
  1033.     p->var.vmode &= ~FB_VMODE_YWRAP;
  1034.     p->fb_info->updatevar(unit, p->fb_info);
  1035.     if (p->dispsw->clear_margins)
  1036. p->dispsw->clear_margins(conp, p, 1);
  1037.     scrollback_max -= count;
  1038.     if (scrollback_max < 0)
  1039. scrollback_max = 0;
  1040.     scrollback_current = 0;
  1041. }
  1043. static void fbcon_redraw_softback(struct vc_data *conp, struct display *p, long delta)
  1044. {
  1045.     unsigned short *d, *s;
  1046.     unsigned long n;
  1047.     int line = 0;
  1048.     int count = conp->vc_rows;
  1049.     
  1050.     d = (u16 *)softback_curr;
  1051.     if (d == (u16 *)softback_in)
  1052. d = (u16 *)conp->vc_origin;
  1053.     n = softback_curr + delta * conp->vc_size_row;
  1054.     softback_lines -= delta;
  1055.     if (delta < 0) {
  1056.         if (softback_curr < softback_top && n < softback_buf) {
  1057.             n += softback_end - softback_buf;
  1058.     if (n < softback_top) {
  1059. softback_lines -= (softback_top - n) / conp->vc_size_row;
  1060. n = softback_top;
  1061.     }
  1062.         } else if (softback_curr >= softback_top && n < softback_top) {
  1063.     softback_lines -= (softback_top - n) / conp->vc_size_row;
  1064.     n = softback_top;
  1065.         }
  1066.     } else {
  1067.      if (softback_curr > softback_in && n >= softback_end) {
  1068.          n += softback_buf - softback_end;
  1069.     if (n > softback_in) {
  1070. n = softback_in;
  1071. softback_lines = 0;
  1072.     }
  1073. } else if (softback_curr <= softback_in && n > softback_in) {
  1074.     n = softback_in;
  1075.     softback_lines = 0;
  1076. }
  1077.     }
  1078.     if (n == softback_curr)
  1079.      return;
  1080.     softback_curr = n;
  1081.     s = (u16 *)softback_curr;
  1082.     if (s == (u16 *)softback_in)
  1083. s = (u16 *)conp->vc_origin;
  1084.     while (count--) {
  1085. unsigned short *start;
  1086. unsigned short *le;
  1087. unsigned short c;
  1088. int x = 0;
  1089. unsigned short attr = 1;
  1091. start = s;
  1092. le = advance_row(s, 1);
  1093. do {
  1094.     c = scr_readw(s);
  1095.     if (attr != (c & 0xff00)) {
  1096. attr = c & 0xff00;
  1097. if (s > start) {
  1098.     p->dispsw->putcs(conp, p, start, s - start,
  1099.      real_y(p, line), x);
  1100.     x += s - start;
  1101.     start = s;
  1102. }
  1103.     }
  1104.     if (c == scr_readw(d)) {
  1105.      if (s > start) {
  1106.          p->dispsw->putcs(conp, p, start, s - start,
  1107.      real_y(p, line), x);
  1108.     x += s - start + 1;
  1109.     start = s + 1;
  1110.      } else {
  1111.          x++;
  1112.          start++;
  1113.      }
  1114.     }
  1115.     s++;
  1116.     d++;
  1117. } while (s < le);
  1118. if (s > start)
  1119.     p->dispsw->putcs(conp, p, start, s - start, real_y(p, line), x);
  1120. line++;
  1121. if (d == (u16 *)softback_end)
  1122.     d = (u16 *)softback_buf;
  1123. if (d == (u16 *)softback_in)
  1124.     d = (u16 *)conp->vc_origin;
  1125. if (s == (u16 *)softback_end)
  1126.     s = (u16 *)softback_buf;
  1127. if (s == (u16 *)softback_in)
  1128.     s = (u16 *)conp->vc_origin;
  1129.     }
  1130. }
  1132. static void fbcon_redraw(struct vc_data *conp, struct display *p, 
  1133.  int line, int count, int offset)
  1134. {
  1135.     unsigned short *d = (unsigned short *)
  1136. (conp->vc_origin + conp->vc_size_row * line);
  1137.     unsigned short *s = d + offset;
  1139.     while (count--) {
  1140. unsigned short *start = s;
  1141. unsigned short *le = advance_row(s, 1);
  1142. unsigned short c;
  1143. int x = 0;
  1144. unsigned short attr = 1;
  1146. do {
  1147.     c = scr_readw(s);
  1148.     if (attr != (c & 0xff00)) {
  1149. attr = c & 0xff00;
  1150. if (s > start) {
  1151.     p->dispsw->putcs(conp, p, start, s - start,
  1152.      real_y(p, line), x);
  1153.     x += s - start;
  1154.     start = s;
  1155. }
  1156.     }
  1157.     if (c == scr_readw(d)) {
  1158.      if (s > start) {
  1159.          p->dispsw->putcs(conp, p, start, s - start,
  1160.      real_y(p, line), x);
  1161.     x += s - start + 1;
  1162.     start = s + 1;
  1163.      } else {
  1164.          x++;
  1165.          start++;
  1166.      }
  1167.     }
  1168.     scr_writew(c, d);
  1169.     console_conditional_schedule();
  1170.     s++;
  1171.     d++;
  1172. } while (s < le);
  1173. if (s > start)
  1174.     p->dispsw->putcs(conp, p, start, s - start, real_y(p, line), x);
  1175. console_conditional_schedule();
  1176. if (offset > 0)
  1177. line++;
  1178. else {
  1179. line--;
  1180. /* NOTE: We subtract two lines from these pointers */
  1181. s -= conp->vc_size_row;
  1182. d -= conp->vc_size_row;
  1183. }
  1184.     }
  1185. }
  1187. /**
  1188.  * fbcon_redraw_clear - clear area of the screen
  1189.  * @conp: stucture pointing to current active virtual console
  1190.  * @p: display structure
  1191.  * @sy: starting Y coordinate
  1192.  * @sx: starting X coordinate
  1193.  * @height: height of area to clear
  1194.  * @width: width of area to clear
  1195.  *
  1196.  * Clears a specified area of the screen.  All dimensions are in
  1197.  * pixels.
  1198.  *
  1199.  */
  1201. void fbcon_redraw_clear(struct vc_data *conp, struct display *p, int sy, int sx,
  1202.      int height, int width)
  1203. {
  1204.     int x, y;
  1205.     for (y=0; y<height; y++)
  1206. for (x=0; x<width; x++)
  1207.     fbcon_putc(conp, ' ', sy+y, sx+x);
  1208. }
  1211. /**
  1212.  * fbcon_redraw_bmove - copy area of screen to another area
  1213.  * @p: display structure
  1214.  * @sy: origin Y coordinate
  1215.  * @sx: origin X coordinate
  1216.  * @dy: destination Y coordinate
  1217.  * @dx: destination X coordinate
  1218.  * @h: height of area to copy
  1219.  * @w: width of area to copy
  1220.  *
  1221.  * Copies an area of the screen to another area of the same screen.
  1222.  * All dimensions are in pixels.
  1223.  *
  1224.  * Note that this function cannot be used together with ypan or
  1225.  * ywrap.
  1226.  *
  1227.  */
  1229. void fbcon_redraw_bmove(struct display *p, int sy, int sx, int dy, int dx, int h, int w)
  1230. {
  1231.     if (sy != dy)
  1232.      panic("fbcon_redraw_bmove width sy != dy");
  1233.     /* h will be always 1, but it does not matter if we are more generic */
  1235.     while (h-- > 0) {
  1236. struct vc_data *conp = p->conp;
  1237. unsigned short *d = (unsigned short *)
  1238. (conp->vc_origin + conp->vc_size_row * dy + dx * 2);
  1239. unsigned short *s = d + (dx - sx);
  1240. unsigned short *start = d;
  1241. unsigned short *ls = d;
  1242. unsigned short *le = d + w;
  1243. unsigned short c;
  1244. int x = dx;
  1245. unsigned short attr = 1;
  1247. do {
  1248.     c = scr_readw(d);
  1249.     if (attr != (c & 0xff00)) {
  1250. attr = c & 0xff00;
  1251. if (d > start) {
  1252.     p->dispsw->putcs(conp, p, start, d - start, dy, x);
  1253.     x += d - start;
  1254.     start = d;
  1255. }
  1256.     }
  1257.     if (s >= ls && s < le && c == scr_readw(s)) {
  1258. if (d > start) {
  1259.     p->dispsw->putcs(conp, p, start, d - start, dy, x);
  1260.     x += d - start + 1;
  1261.     start = d + 1;
  1262. } else {
  1263.     x++;
  1264.     start++;
  1265. }
  1266.     }
  1267.     s++;
  1268.     d++;
  1269. } while (d < le);
  1270. if (d > start)
  1271.     p->dispsw->putcs(conp, p, start, d - start, dy, x);
  1272. sy++;
  1273. dy++;
  1274.     }
  1275. }
  1277. static inline void fbcon_softback_note(struct vc_data *conp, int t, int count)
  1278. {
  1279.     unsigned short *p;
  1281.     if (conp->vc_num != fg_console)
  1282. return;
  1283.     p = (unsigned short *)(conp->vc_origin + t * conp->vc_size_row);
  1285.     while (count) {
  1286.      scr_memcpyw((u16 *)softback_in, p, conp->vc_size_row);
  1287.      count--;
  1288.      p = advance_row(p, 1);
  1289.      softback_in += conp->vc_size_row;
  1290.      if (softback_in == softback_end)
  1291.          softback_in = softback_buf;
  1292.      if (softback_in == softback_top) {
  1293.          softback_top += conp->vc_size_row;
  1294.          if (softback_top == softback_end)
  1295.           softback_top = softback_buf;
  1296.      }
  1297.     }
  1298.     softback_curr = softback_in;
  1299. }
  1301. static int fbcon_scroll(struct vc_data *conp, int t, int b, int dir,
  1302. int count)
  1303. {
  1304.     int unit = conp->vc_num;
  1305.     struct display *p = &fb_display[unit];
  1306.     int scroll_partial = !(p->scrollmode & __SCROLL_YNOPARTIAL);
  1308. #ifdef CONFIG_CONSOLE_PM
  1309.     if (!p->can_soft_blank && console_blanked)
  1310. return 0;
  1311. #endif
  1313.     if (!count || vt_cons[unit]->vc_mode != KD_TEXT)
  1314. return 0;
  1316.     fbcon_cursor(conp, CM_ERASE);
  1317.     
  1318.     /*
  1319.      * ++Geert: Only use ywrap/ypan if the console is in text mode
  1320.      * ++Andrew: Only use ypan on hardware text mode when scrolling the
  1321.      *           whole screen (prevents flicker).
  1322.      */
  1324.     switch (dir) {
  1325. case SM_UP:
  1326.     if (count > conp->vc_rows) /* Maximum realistic size */
  1327. count = conp->vc_rows;
  1328.     if (softback_top)
  1329.         fbcon_softback_note(conp, t, count);
  1330.     if (logo_shown >= 0) goto redraw_up;
  1331.     switch (p->scrollmode & __SCROLL_YMASK) {
  1332.     case __SCROLL_YMOVE:
  1333. p->dispsw->bmove(p, t+count, 0, t, 0, b-t-count,
  1334.  conp->vc_cols);
  1335. p->dispsw->clear(conp, p, b-count, 0, count,
  1336.  conp->vc_cols);
  1337. break;
  1339.     case __SCROLL_YWRAP:
  1340. if (b-t-count > 3*conp->vc_rows>>2) {
  1341.     if (t > 0)
  1342. fbcon_bmove(conp, 0, 0, count, 0, t,
  1343.     conp->vc_cols);
  1344. ywrap_up(unit, conp, p, count);
  1345.     if (conp->vc_rows-b > 0)
  1346. fbcon_bmove(conp, b-count, 0, b, 0,
  1347.     conp->vc_rows-b, conp->vc_cols);
  1348. } else if (p->scrollmode & __SCROLL_YPANREDRAW)
  1349.     goto redraw_up;
  1350. else
  1351.     fbcon_bmove(conp, t+count, 0, t, 0, b-t-count,
  1352. conp->vc_cols);
  1353. fbcon_clear(conp, b-count, 0, count, conp->vc_cols);
  1354. break;
  1356.     case __SCROLL_YPAN:
  1357. if (( p->yscroll + count <= 2 * (p->vrows - conp->vc_rows)) &&
  1358.     (( !scroll_partial && (b-t == conp->vc_rows)) ||
  1359.      ( scroll_partial  && (b-t-count > 3*conp->vc_rows>>2)))) {
  1360.     if (t > 0)
  1361. fbcon_bmove(conp, 0, 0, count, 0, t,
  1362.     conp->vc_cols);
  1363.     ypan_up(unit, conp, p, count);
  1364.     if (conp->vc_rows-b > 0)
  1365. fbcon_bmove(conp, b-count, 0, b, 0,
  1366.     conp->vc_rows-b, conp->vc_cols);
  1367. } else if (p->scrollmode & __SCROLL_YPANREDRAW)
  1368.     goto redraw_up;
  1369. else
  1370.     fbcon_bmove(conp, t+count, 0, t, 0, b-t-count,
  1371. conp->vc_cols);
  1372. fbcon_clear(conp, b-count, 0, count, conp->vc_cols);
  1373. break;
  1375.     case __SCROLL_YREDRAW:
  1376.     redraw_up:
  1377. fbcon_redraw(conp, p, t, b-t-count, count*conp->vc_cols);
  1378. p->dispsw->clear(conp, p, real_y(p, b-count), 0,
  1379.  count, conp->vc_cols);
  1380. scr_memsetw((unsigned short *)(conp->vc_origin + 
  1381.          conp->vc_size_row * (b-count)), 
  1382.          conp->vc_video_erase_char,
  1383.          conp->vc_size_row * count);
  1384. return 1;
  1385.     }
  1386.     break;
  1388. case SM_DOWN:
  1389.     if (count > conp->vc_rows) /* Maximum realistic size */
  1390. count = conp->vc_rows;
  1391.     switch (p->scrollmode & __SCROLL_YMASK) {
  1392.     case __SCROLL_YMOVE:
  1393. p->dispsw->bmove(p, t, 0, t+count, 0, b-t-count,
  1394.  conp->vc_cols);
  1395. p->dispsw->clear(conp, p, t, 0,
  1396.  count, conp->vc_cols);
  1397. break;
  1399.     case __SCROLL_YWRAP:
  1400. if (b-t-count > 3*conp->vc_rows>>2) {
  1401.     if (conp->vc_rows-b > 0)
  1402. fbcon_bmove(conp, b, 0, b-count, 0,
  1403.     conp->vc_rows-b, conp->vc_cols);
  1404.     ywrap_down(unit, conp, p, count);
  1405.     if (t > 0)
  1406. fbcon_bmove(conp, count, 0, 0, 0, t,
  1407.     conp->vc_cols);
  1408. } else if (p->scrollmode & __SCROLL_YPANREDRAW)
  1409.     goto redraw_down;
  1410. else
  1411.     fbcon_bmove(conp, t, 0, t+count, 0, b-t-count,
  1412. conp->vc_cols);
  1413. fbcon_clear(conp, t, 0, count, conp->vc_cols);
  1414. break;
  1416.     case __SCROLL_YPAN:
  1417. if (( count-p->yscroll <= p->vrows-conp->vc_rows) &&
  1418.     (( !scroll_partial && (b-t == conp->vc_rows)) ||
  1419.      ( scroll_partial  && (b-t-count > 3*conp->vc_rows>>2)))) {
  1420.     if (conp->vc_rows-b > 0)
  1421. fbcon_bmove(conp, b, 0, b-count, 0,
  1422.     conp->vc_rows-b, conp->vc_cols);
  1423.     ypan_down(unit, conp, p, count);
  1424.     if (t > 0)
  1425. fbcon_bmove(conp, count, 0, 0, 0, t,
  1426.     conp->vc_cols);
  1427. } else if (p->scrollmode & __SCROLL_YPANREDRAW)
  1428.     goto redraw_down;
  1429. else
  1430.     fbcon_bmove(conp, t, 0, t+count, 0, b-t-count,
  1431. conp->vc_cols);
  1432. fbcon_clear(conp, t, 0, count, conp->vc_cols);
  1433. break;
  1435.     case __SCROLL_YREDRAW:
  1436.     redraw_down:
  1437. fbcon_redraw(conp, p, b - 1, b-t-count, -count*conp->vc_cols);
  1438. p->dispsw->clear(conp, p, real_y(p, t), 0,
  1439.  count, conp->vc_cols);
  1440.      scr_memsetw((unsigned short *)(conp->vc_origin + 
  1441.          conp->vc_size_row * t), 
  1442.          conp->vc_video_erase_char,
  1443.          conp->vc_size_row * count);
  1444.      return 1;
  1445.     }
  1446.     }
  1447.     return 0;
  1448. }
  1451. static void fbcon_bmove(struct vc_data *conp, int sy, int sx, int dy, int dx,
  1452. int height, int width)
  1453. {
  1454.     int unit = conp->vc_num;
  1455.     struct display *p = &fb_display[unit];
  1456.     
  1457. #ifdef CONFIG_CONSOLE_PM // bushi
  1458.     if (!p->can_soft_blank && console_blanked)
  1459. return;
  1460. #endif
  1462.     if (!width || !height)
  1463. return;
  1465.     if (((sy <= p->cursor_y) && (p->cursor_y < sy+height) &&
  1466.   (sx <= p->cursor_x) && (p->cursor_x < sx+width)) ||
  1467.  ((dy <= p->cursor_y) && (p->cursor_y < dy+height) &&
  1468.   (dx <= p->cursor_x) && (p->cursor_x < dx+width)))
  1469. fbcon_cursor(conp, CM_ERASE|CM_SOFTBACK);
  1471.     /*  Split blits that cross physical y_wrap case.
  1472.      *  Pathological case involves 4 blits, better to use recursive
  1473.      *  code rather than unrolled case
  1474.      *
  1475.      *  Recursive invocations don't need to erase the cursor over and
  1476.      *  over again, so we use fbcon_bmove_rec()
  1477.      */
  1478.     fbcon_bmove_rec(p, sy, sx, dy, dx, height, width, p->vrows-p->yscroll);
  1479. }
  1481. static void fbcon_bmove_rec(struct display *p, int sy, int sx, int dy, int dx,
  1482.     int height, int width, u_int y_break)
  1483. {
  1484.     u_int b;
  1486.     if (sy < y_break && sy+height > y_break) {
  1487. b = y_break-sy;
  1488. if (dy < sy) { /* Avoid trashing self */
  1489.     fbcon_bmove_rec(p, sy, sx, dy, dx, b, width, y_break);
  1490.     fbcon_bmove_rec(p, sy+b, sx, dy+b, dx, height-b, width, y_break);
  1491. } else {
  1492.     fbcon_bmove_rec(p, sy+b, sx, dy+b, dx, height-b, width, y_break);
  1493.     fbcon_bmove_rec(p, sy, sx, dy, dx, b, width, y_break);
  1494. }
  1495. return;
  1496.     }
  1498.     if (dy < y_break && dy+height > y_break) {
  1499. b = y_break-dy;
  1500. if (dy < sy) { /* Avoid trashing self */
  1501.     fbcon_bmove_rec(p, sy, sx, dy, dx, b, width, y_break);
  1502.     fbcon_bmove_rec(p, sy+b, sx, dy+b, dx, height-b, width, y_break);
  1503. } else {
  1504.     fbcon_bmove_rec(p, sy+b, sx, dy+b, dx, height-b, width, y_break);
  1505.     fbcon_bmove_rec(p, sy, sx, dy, dx, b, width, y_break);
  1506. }
  1507. return;
  1508.     }
  1509.     p->dispsw->bmove(p, real_y(p, sy), sx, real_y(p, dy), dx, height, width);
  1510. }
  1513. static int fbcon_switch(struct vc_data *conp)
  1514. {
  1515.     int unit = conp->vc_num;
  1516.     struct display *p = &fb_display[unit];
  1517.     struct fb_info *info = p->fb_info;
  1519.     if (softback_top) {
  1520.      int l = fbcon_softback_size / conp->vc_size_row;
  1521. if (softback_lines)
  1522.     fbcon_set_origin(conp);
  1523.         softback_top = softback_curr = softback_in = softback_buf;
  1524.         softback_lines = 0;
  1526. if (l > 5)
  1527.     softback_end = softback_buf + l * conp->vc_size_row;
  1528. else {
  1529.     /* Smaller scrollback makes no sense, and 0 would screw
  1530.        the operation totally */
  1531.     softback_top = 0;
  1532. }
  1533.     }
  1534.     if (logo_shown >= 0) {
  1535.      struct vc_data *conp2 = vc_cons[logo_shown].d;
  1536.     
  1537.      if (conp2->vc_top == logo_lines && conp2->vc_bottom == conp2->vc_rows)
  1538.      conp2->vc_top = 0;
  1539.      logo_shown = -1;
  1540.     }
  1541.     p->var.yoffset = p->yscroll = 0;
  1542.     switch (p->scrollmode & __SCROLL_YMASK) {
  1543. case __SCROLL_YWRAP:
  1544.     scrollback_phys_max = p->vrows-conp->vc_rows;
  1545.     break;
  1546. case __SCROLL_YPAN:
  1547.     scrollback_phys_max = p->vrows-2*conp->vc_rows;
  1548.     if (scrollback_phys_max < 0)
  1549. scrollback_phys_max = 0;
  1550.     break;
  1551. default:
  1552.     scrollback_phys_max = 0;
  1553.     break;
  1554.     }
  1555.     scrollback_max = 0;
  1556.     scrollback_current = 0;
  1558.     if (info && info->switch_con)
  1559. (*info->switch_con)(unit, info);
  1560.     if (p->dispsw->clear_margins && vt_cons[unit]->vc_mode == KD_TEXT)
  1561. p->dispsw->clear_margins(conp, p, 0);
  1562.     if (logo_shown == -2) {
  1563. logo_shown = fg_console;
  1564. fbcon_show_logo(); /* This is protected above by initmem_freed */
  1565. update_region(fg_console,
  1566.       conp->vc_origin + conp->vc_size_row * conp->vc_top,
  1567.       conp->vc_size_row * (conp->vc_bottom - conp->vc_top) / 2);
  1568. return 0;
  1569.     }
  1570.     return 1;
  1571. }
  1574. static int fbcon_blank(struct vc_data *conp, int blank)
  1575. {
  1576.     struct display *p = &fb_display[conp->vc_num];
  1577.     struct fb_info *info = p->fb_info;
  1579. #ifdef CONFIG_MIZI
  1580.     return 0; /* disable blank-function */
  1581. #endif
  1582.     if (blank < 0) /* Entering graphics mode */
  1583. return 0;
  1584. #ifdef CONFIG_PM
  1585.     if (fbcon_sleeping)
  1586.      return 0;
  1587. #endif /* CONFIG_PM */
  1589.     fbcon_cursor(p->conp, blank ? CM_ERASE : CM_DRAW);
  1591.     if (!p->can_soft_blank) {
  1592. if (blank) {
  1593.     if (p->visual == FB_VISUAL_MONO01) {
  1594. if (p->screen_base)
  1595.     fb_memset255(p->screen_base,
  1596.  p->var.xres_virtual*p->var.yres_virtual*
  1597.  p->var.bits_per_pixel>>3);
  1598.     } else {
  1599.      unsigned short oldc;
  1600.      u_int height;
  1601.      u_int y_break;
  1603.      oldc = conp->vc_video_erase_char;
  1604.      conp->vc_video_erase_char &= p->charmask;
  1605.      height = conp->vc_rows;
  1606. y_break = p->vrows-p->yscroll;
  1607. if (height > y_break) {
  1608. p->dispsw->clear(conp, p, real_y(p, 0), 0, y_break, conp->vc_cols);
  1609. p->dispsw->clear(conp, p, real_y(p, y_break), 0, height-y_break, conp->vc_cols);
  1610. } else
  1611. p->dispsw->clear(conp, p, real_y(p, 0), 0, height, conp->vc_cols);
  1612. conp->vc_video_erase_char = oldc;
  1613.     }
  1614.     return 0;
  1615. } else {
  1616.     /* Tell console.c that it has to restore the screen itself */
  1617.     return 1;
  1618. }
  1619.     }
  1620.     (*info->blank)(blank, info);
  1621.     return 0;
  1622. }
  1624. static void fbcon_free_font(struct display *p)
  1625. {
  1626.     if (p->userfont && p->fontdata &&
  1627.         (--REFCOUNT(p->fontdata) == 0))
  1628. kfree(p->fontdata - FONT_EXTRA_WORDS*sizeof(int));
  1629.     p->fontdata = NULL;
  1630.     p->userfont = 0;
  1631. }
  1633. static inline int fbcon_get_font(int unit, struct console_font_op *op)
  1634. {
  1635.     struct display *p = &fb_display[unit];
  1636.     u8 *data = op->data;
  1637.     u8 *fontdata = p->fontdata;
  1638.     int i, j;
  1640. #ifdef CONFIG_FBCON_FONTWIDTH8_ONLY
  1641.     if (fontwidth(p) != 8) return -EINVAL;
  1642. #endif
  1643.     op->width = fontwidth(p);
  1644.     op->height = fontheight(p);
  1645.     op->charcount = (p->charmask == 0x1ff) ? 512 : 256;
  1646.     if (!op->data) return 0;
  1647.     
  1648.     if (op->width <= 8) {
  1649. j = fontheight(p);
  1650.      for (i = 0; i < op->charcount; i++) {
  1651.     memcpy(data, fontdata, j);
  1652.     memset(data+j, 0, 32-j);
  1653.     data += 32;
  1654.     fontdata += j;
  1655. }
  1656.     }
  1657. #ifndef CONFIG_FBCON_FONTWIDTH8_ONLY
  1658.     else if (op->width <= 16) {
  1659. j = fontheight(p) * 2;
  1660. for (i = 0; i < op->charcount; i++) {
  1661.     memcpy(data, fontdata, j);
  1662.     memset(data+j, 0, 64-j);
  1663.     data += 64;
  1664.     fontdata += j;
  1665. }
  1666.     } else if (op->width <= 24) {
  1667. for (i = 0; i < op->charcount; i++) {
  1668.     for (j = 0; j < fontheight(p); j++) {
  1669. *data++ = fontdata[0];
  1670. *data++ = fontdata[1];
  1671. *data++ = fontdata[2];
  1672. fontdata += sizeof(u32);
  1673.     }
  1674.     memset(data, 0, 3*(32-j));
  1675.     data += 3 * (32 - j);
  1676. }
  1677.     } else {
  1678. j = fontheight(p) * 4;
  1679. for (i = 0; i < op->charcount; i++) {
  1680.     memcpy(data, fontdata, j);
  1681.     memset(data+j, 0, 128-j);
  1682.     data += 128;
  1683.     fontdata += j;
  1684. }
  1685.     }
  1686. #endif
  1687.     return 0;
  1688. }
  1690. static int fbcon_do_set_font(int unit, struct console_font_op *op, u8 *data, int userfont)
  1691. {
  1692.     struct display *p = &fb_display[unit];
  1693.     int resize;
  1694.     int w = op->width;
  1695.     int h = op->height;
  1696.     int cnt;
  1697.     char *old_data = NULL;
  1699.     if (!fontwidthvalid(p,w)) {
  1700.         if (userfont && op->op != KD_FONT_OP_COPY)
  1701.     kfree(data - FONT_EXTRA_WORDS*sizeof(int));
  1702. return -ENXIO;
  1703.     }
  1705.     if (CON_IS_VISIBLE(p->conp) && softback_lines)
  1706. fbcon_set_origin(p->conp);
  1708.     resize = (w != fontwidth(p)) || (h != fontheight(p));
  1709.     if (p->userfont)
  1710.         old_data = p->fontdata;
  1711.     if (userfont)
  1712.         cnt = FNTCHARCNT(data);
  1713.     else
  1714.      cnt = 256;
  1715.     p->fontdata = data;
  1716.     if ((p->userfont = userfont))
  1717.         REFCOUNT(data)++;
  1718.     p->_fontwidth = w;
  1719.     p->_fontheight = h;
  1720.     if (p->conp->vc_hi_font_mask && cnt == 256) {
  1721.      p->conp->vc_hi_font_mask = 0;
  1722.      if (p->conp->vc_can_do_color)
  1723.     p->conp->vc_complement_mask >>= 1;
  1724.      p->fgshift--;
  1725.      p->bgshift--;
  1726.      p->charmask = 0xff;
  1728. /* ++Edmund: reorder the attribute bits */
  1729. if (p->conp->vc_can_do_color) {
  1730.     struct vc_data *conp = p->conp;
  1731.     unsigned short *cp = (unsigned short *) conp->vc_origin;
  1732.     int count = conp->vc_screenbuf_size/2;
  1733.     unsigned short c;
  1734.     for (; count > 0; count--, cp++) {
  1735.         c = scr_readw(cp);
  1736. scr_writew(((c & 0xfe00) >> 1) | (c & 0xff), cp);
  1737.     }
  1738.     c = conp->vc_video_erase_char;
  1739.     conp->vc_video_erase_char = ((c & 0xfe00) >> 1) | (c & 0xff);
  1740.     conp->vc_attr >>= 1;
  1741. }
  1743.     } else if (!p->conp->vc_hi_font_mask && cnt == 512) {
  1744.      p->conp->vc_hi_font_mask = 0x100;
  1745.      if (p->conp->vc_can_do_color)
  1746.     p->conp->vc_complement_mask <<= 1;
  1747.      p->fgshift++;
  1748.      p->bgshift++;
  1749.      p->charmask = 0x1ff;
  1751. /* ++Edmund: reorder the attribute bits */
  1752. {
  1753.     struct vc_data *conp = p->conp;
  1754.     unsigned short *cp = (unsigned short *) conp->vc_origin;
  1755.     int count = conp->vc_screenbuf_size/2;
  1756.     unsigned short c;
  1757.     for (; count > 0; count--, cp++) {
  1758.         unsigned short newc;
  1759.         c = scr_readw(cp);
  1760. if (conp->vc_can_do_color)
  1761.     newc = ((c & 0xff00) << 1) | (c & 0xff);
  1762. else
  1763.     newc = c & ~0x100;
  1764. scr_writew(newc, cp);
  1765.     }
  1766.     c = conp->vc_video_erase_char;
  1767.     if (conp->vc_can_do_color) {
  1768. conp->vc_video_erase_char = ((c & 0xff00) << 1) | (c & 0xff);
  1769. conp->vc_attr <<= 1;
  1770.     } else
  1771.         conp->vc_video_erase_char = c & ~0x100;
  1772. }
  1774.     }
  1775.     fbcon_font_widths(p);
  1777.     if (resize) {
  1778.      struct vc_data *conp = p->conp;
  1779. /* reset wrap/pan */
  1780. p->var.xoffset = p->var.yoffset = p->yscroll = 0;
  1781. p->vrows = p->var.yres_virtual/h;
  1782. if ((p->var.yres % h) && (p->var.yres_virtual % h < p->var.yres % h))
  1783.     p->vrows--;
  1784. updatescrollmode(p);
  1785. vc_resize_con( p->var.yres/h, p->var.xres/w, unit );
  1786.         if (CON_IS_VISIBLE(conp) && softback_buf) {
  1787.     int l = fbcon_softback_size / conp->vc_size_row;
  1788.     if (l > 5)
  1789. softback_end = softback_buf + l * conp->vc_size_row;
  1790.     else {
  1791. /* Smaller scrollback makes no sense, and 0 would screw
  1792.    the operation totally */
  1793. softback_top = 0;
  1794.          }
  1795.      }
  1796.     } else if (CON_IS_VISIBLE(p->conp) && vt_cons[unit]->vc_mode == KD_TEXT) {
  1797. if (p->dispsw->clear_margins)
  1798.     p->dispsw->clear_margins(p->conp, p, 0);
  1799. update_screen(unit);
  1800.     }
  1802.     if (old_data && (--REFCOUNT(old_data) == 0))
  1803. kfree(old_data - FONT_EXTRA_WORDS*sizeof(int));
  1805.     return 0;
  1806. }
  1808. static inline int fbcon_copy_font(int unit, struct console_font_op *op)
  1809. {
  1810.     struct display *od, *p = &fb_display[unit];
  1811.     int h = op->height;
  1813.     if (h < 0 || !vc_cons_allocated( h ))
  1814.         return -ENOTTY;
  1815.     if (h == unit)
  1816.         return 0; /* nothing to do */
  1817.     od = &fb_display[h];
  1818.     if (od->fontdata == p->fontdata)
  1819.         return 0; /* already the same font... */
  1820.     op->width = fontwidth(od);
  1821.     op->height = fontheight(od);
  1822.     return fbcon_do_set_font(unit, op, od->fontdata, od->userfont);
  1823. }
  1825. static inline int fbcon_set_font(int unit, struct console_font_op *op)
  1826. {
  1827.     int w = op->width;
  1828.     int h = op->height;
  1829.     int size = h;
  1830.     int i, k;
  1831.     u8 *new_data, *data = op->data, *p;
  1833. #ifdef CONFIG_FBCON_FONTWIDTH8_ONLY
  1834.     if (w != 8)
  1835.      return -EINVAL;
  1836. #endif
  1837.     if ((w <= 0) || (w > 32) || (op->charcount != 256 && op->charcount != 512))
  1838.         return -EINVAL;
  1839.     
  1840.     if (w > 8) { 
  1841.      if (w <= 16)
  1842.      size *= 2;
  1843.      else
  1844.      size *= 4;
  1845.     }
  1846.     size *= op->charcount;
  1847.        
  1848.     if (!(new_data = kmalloc(FONT_EXTRA_WORDS*sizeof(int)+size, GFP_USER)))
  1849.         return -ENOMEM;
  1850.     new_data += FONT_EXTRA_WORDS*sizeof(int);
  1851.     FNTSIZE(new_data) = size;
  1852.     FNTCHARCNT(new_data) = op->charcount;
  1853.     REFCOUNT(new_data) = 0; /* usage counter */
  1854.     p = new_data;
  1855.     if (w <= 8) {
  1856. for (i = 0; i < op->charcount; i++) {
  1857.     memcpy(p, data, h);
  1858.     data += 32;
  1859.     p += h;
  1860. }
  1861.     }
  1862. #ifndef CONFIG_FBCON_FONTWIDTH8_ONLY
  1863.     else if (w <= 16) {
  1864. h *= 2;
  1865. for (i = 0; i < op->charcount; i++) {
  1866.     memcpy(p, data, h);
  1867.     data += 64;
  1868.     p += h;
  1869. }
  1870.     } else if (w <= 24) {
  1871. for (i = 0; i < op->charcount; i++) {
  1872.     int j;
  1873.     for (j = 0; j < h; j++) {
  1874.         memcpy(p, data, 3);
  1875. p[3] = 0;
  1876. data += 3;
  1877. p += sizeof(u32);
  1878.     }
  1879.     data += 3*(32 - h);
  1880. }
  1881.     } else {
  1882. h *= 4;
  1883. for (i = 0; i < op->charcount; i++) {
  1884.     memcpy(p, data, h);
  1885.     data += 128;
  1886.     p += h;
  1887. }
  1888.     }
  1889. #endif
  1890.     /* we can do it in u32 chunks because of charcount is 256 or 512, so
  1891.        font length must be multiple of 256, at least. And 256 is multiple
  1892.        of 4 */
  1893.     k = 0;
  1894.     while (p > new_data) k += *--(u32 *)p;
  1895.     FNTSUM(new_data) = k;
  1896.     /* Check if the same font is on some other console already */
  1897.     for (i = 0; i < MAX_NR_CONSOLES; i++) {
  1898.      if (fb_display[i].userfont &&
  1899.          fb_display[i].fontdata &&
  1900.          FNTSUM(fb_display[i].fontdata) == k &&
  1901.          FNTSIZE(fb_display[i].fontdata) == size &&
  1902.          fontwidth(&fb_display[i]) == w &&
  1903.     !memcmp(fb_display[i].fontdata, new_data, size)) {
  1904.     kfree(new_data - FONT_EXTRA_WORDS*sizeof(int));
  1905.     new_data = fb_display[i].fontdata;
  1906.     break;
  1907.      }
  1908.     }
  1909.     return fbcon_do_set_font(unit, op, new_data, 1);
  1910. }
  1912. static inline int fbcon_set_def_font(int unit, struct console_font_op *op)
  1913. {
  1914.     char name[MAX_FONT_NAME];
  1915.     struct fbcon_font_desc *f;
  1916.     struct display *p = &fb_display[unit];
  1918.     if (!op->data)
  1919. f = fbcon_get_default_font(p->var.xres, p->var.yres);
  1920.     else if (strncpy_from_user(name, op->data, MAX_FONT_NAME-1) < 0)
  1921. return -EFAULT;
  1922.     else {
  1923. name[MAX_FONT_NAME-1] = 0;
  1924. if (!(f = fbcon_find_font(name)))
  1925.     return -ENOENT;
  1926.     }
  1927.     op->width = f->width;
  1928.     op->height = f->height;
  1929.     return fbcon_do_set_font(unit, op, f->data, 0);
  1930. }
  1932. static int fbcon_font_op(struct vc_data *conp, struct console_font_op *op)
  1933. {
  1934.     int unit = conp->vc_num;
  1936.     switch (op->op) {
  1937. case KD_FONT_OP_SET:
  1938.     return fbcon_set_font(unit, op);
  1939. case KD_FONT_OP_GET:
  1940.     return fbcon_get_font(unit, op);
  1941. case KD_FONT_OP_SET_DEFAULT:
  1942.     return fbcon_set_def_font(unit, op);
  1943. case KD_FONT_OP_COPY:
  1944.     return fbcon_copy_font(unit, op);
  1945. default:
  1946.     return -ENOSYS;
  1947.     }
  1948. }
  1950. static u16 palette_red[16];
  1951. static u16 palette_green[16];
  1952. static u16 palette_blue[16];
  1954. static struct fb_cmap palette_cmap  = {
  1955.     0, 16, palette_red, palette_green, palette_blue, NULL
  1956. };
  1958. static int fbcon_set_palette(struct vc_data *conp, unsigned char *table)
  1959. {
  1960.     int unit = conp->vc_num;
  1961.     struct display *p = &fb_display[unit];
  1962.     int i, j, k;
  1963.     u8 val;
  1965. #ifdef CONFIG_CONSOLE_PM // bushi
  1966.     if (!conp->vc_can_do_color || (!p->can_soft_blank && console_blanked))
  1967. return -EINVAL;
  1968. #endif
  1969.     for (i = j = 0; i < 16; i++) {
  1970. k = table[i];
  1971. val = conp->vc_palette[j++];
  1972. palette_red[k] = (val<<8)|val;
  1973. val = conp->vc_palette[j++];
  1974. palette_green[k] = (val<<8)|val;
  1975. val = conp->vc_palette[j++];
  1976. palette_blue[k] = (val<<8)|val;
  1977.     }
  1978.     if (p->var.bits_per_pixel <= 4)
  1979. palette_cmap.len = 1<<p->var.bits_per_pixel;
  1980.     else
  1981. palette_cmap.len = 16;
  1982.     palette_cmap.start = 0;
  1983.     return p->fb_info->fbops->fb_set_cmap(&palette_cmap, 1, unit, p->fb_info);
  1984. }
  1986. static u16 *fbcon_screen_pos(struct vc_data *conp, int offset)
  1987. {
  1988.     int line;
  1989.     unsigned long p;
  1991.     if (conp->vc_num != fg_console || !softback_lines)
  1992.      return (u16 *)(conp->vc_origin + offset);
  1993.     line = offset / conp->vc_size_row;
  1994.     if (line >= softback_lines)
  1995.      return (u16 *)(conp->vc_origin + offset - softback_lines * conp->vc_size_row);
  1996.     p = softback_curr + offset;
  1997.     if (p >= softback_end)
  1998.      p += softback_buf - softback_end;
  1999.     return (u16 *)p;
  2000. }
  2002. static unsigned long fbcon_getxy(struct vc_data *conp, unsigned long pos, int *px, int *py)
  2003. {
  2004.     int x, y;
  2005.     unsigned long ret;
  2006.     if (pos >= conp->vc_origin && pos < conp->vc_scr_end) {
  2007.      unsigned long offset = (pos - conp->vc_origin) / 2;
  2008.     
  2009.      x = offset % conp->vc_cols;
  2010.      y = offset / conp->vc_cols;
  2011.      if (conp->vc_num == fg_console)
  2012.          y += softback_lines;
  2013.      ret = pos + (conp->vc_cols - x) * 2;
  2014.     } else if (conp->vc_num == fg_console && softback_lines) {
  2015.      unsigned long offset = pos - softback_curr;
  2016.     
  2017.      if (pos < softback_curr)
  2018.          offset += softback_end - softback_buf;
  2019.      offset /= 2;
  2020.      x = offset % conp->vc_cols;
  2021.      y = offset / conp->vc_cols;
  2022. ret = pos + (conp->vc_cols - x) * 2;
  2023. if (ret == softback_end)
  2024.     ret = softback_buf;
  2025. if (ret == softback_in)
  2026.     ret = conp->vc_origin;
  2027.     } else {
  2028.      /* Should not happen */
  2029.      x = y = 0;
  2030.      ret = conp->vc_origin;
  2031.     }
  2032.     if (px) *px = x;
  2033.     if (py) *py = y;
  2034.     return ret;
  2035. }
  2037. /* As we might be inside of softback, we may work with non-contiguous buffer,
  2038.    that's why we have to use a separate routine. */
  2039. static void fbcon_invert_region(struct vc_data *conp, u16 *p, int cnt)
  2040. {
  2041.     while (cnt--) {
  2042. u16 a = scr_readw(p);
  2043. if (!conp->vc_can_do_color)
  2044.     a ^= 0x0800;
  2045. else if (conp->vc_hi_font_mask == 0x100)
  2046.     a = ((a) & 0x11ff) | (((a) & 0xe000) >> 4) | (((a) & 0x0e00) << 4);
  2047. else
  2048.     a = ((a) & 0x88ff) | (((a) & 0x7000) >> 4) | (((a) & 0x0700) << 4);
  2049. scr_writew(a, p++);
  2050. if (p == (u16 *)softback_end)
  2051.     p = (u16 *)softback_buf;
  2052. if (p == (u16 *)softback_in)
  2053.     p = (u16 *)conp->vc_origin;
  2054.     }
  2055. }
  2057. static int fbcon_scrolldelta(struct vc_data *conp, int lines)
  2058. {
  2059.     int unit, offset, limit, scrollback_old;
  2060.     struct display *p;
  2061.     
  2062.     unit = fg_console;
  2063.     p = &fb_display[unit];
  2064.     if (softback_top) {
  2065.      if (conp->vc_num != unit)
  2066.          return 0;
  2067.      if (vt_cons[unit]->vc_mode != KD_TEXT || !lines)
  2068.          return 0;
  2069.      if (logo_shown >= 0) {
  2070. struct vc_data *conp2 = vc_cons[logo_shown].d;
  2071.     
  2072. if (conp2->vc_top == logo_lines && conp2->vc_bottom == conp2->vc_rows)
  2073.          conp2->vc_top = 0;
  2074.      if (logo_shown == unit) {
  2075.          unsigned long p, q;
  2076.          int i;
  2077.          
  2078.          p = softback_in;
  2079.          q = conp->vc_origin + logo_lines * conp->vc_size_row;
  2080.          for (i = 0; i < logo_lines; i++) {
  2081.           if (p == softback_top) break;
  2082.           if (p == softback_buf) p = softback_end;
  2083.           p -= conp->vc_size_row;
  2084.           q -= conp->vc_size_row;
  2085.           scr_memcpyw((u16 *)q, (u16 *)p, conp->vc_size_row);
  2086.          }
  2087.          softback_in = p;
  2088.          update_region(unit, conp->vc_origin, logo_lines * conp->vc_cols);
  2089.      }
  2090. logo_shown = -1;
  2091. }
  2092.      fbcon_cursor(conp, CM_ERASE|CM_SOFTBACK);
  2093.      fbcon_redraw_softback(conp, p, lines);
  2094.      fbcon_cursor(conp, CM_DRAW|CM_SOFTBACK);
  2095.      return 0;
  2096.     }
  2098.     if (!scrollback_phys_max)
  2099. return -ENOSYS;
  2101.     scrollback_old = scrollback_current;
  2102.     scrollback_current -= lines;
  2103.     if (scrollback_current < 0)
  2104. scrollback_current = 0;
  2105.     else if (scrollback_current > scrollback_max)
  2106. scrollback_current = scrollback_max;
  2107.     if (scrollback_current == scrollback_old)
  2108. return 0;
  2110. #ifdef CONFIG_CONSOLE_PM // bushi
  2111.     if (!p->can_soft_blank &&
  2112. (console_blanked || vt_cons[unit]->vc_mode != KD_TEXT || !lines))
  2113. return 0;
  2114. #endif
  2115.     fbcon_cursor(conp, CM_ERASE);
  2117.     offset = p->yscroll-scrollback_current;
  2118.     limit = p->vrows;
  2119.     switch (p->scrollmode && __SCROLL_YMASK) {
  2120. case __SCROLL_YWRAP:
  2121.     p->var.vmode |= FB_VMODE_YWRAP;
  2122.     break;
  2123. case __SCROLL_YPAN:
  2124.     limit -= conp->vc_rows;
  2125.     p->var.vmode &= ~FB_VMODE_YWRAP;
  2126.     break;
  2127.     }
  2128.     if (offset < 0)
  2129. offset += limit;
  2130.     else if (offset >= limit)
  2131. offset -= limit;
  2132.     p->var.xoffset = 0;
  2133.     p->var.yoffset = offset*fontheight(p);
  2134.     p->fb_info->updatevar(unit, p->fb_info);
  2135.     if (!scrollback_current)
  2136. fbcon_cursor(conp, CM_DRAW);
  2137.     return 0;
  2138. }
  2140. static int fbcon_set_origin(struct vc_data *conp)
  2141. {
  2142. #ifdef CONFIG_CONSOLE_PM // bushi
  2143.     if (softback_lines && !console_blanked)
  2144. #endif
  2145.         fbcon_scrolldelta(conp, softback_lines);
  2146.     return 0;
  2147. }
  2149. static inline unsigned safe_shift(unsigned d,int n)
  2150. {
  2151.     return n<0 ? d>>-n : d<<n;
  2152. }
  2154. static int __init fbcon_show_logo( void )
  2155. {
  2156.     struct display *p = &fb_display[fg_console]; /* draw to vt in foreground */
  2157.     int depth = p->var.bits_per_pixel;
  2158.     int line = p->next_line;
  2159.     unsigned char *fb = p->screen_base;
  2160.     unsigned char *logo;
  2161.     unsigned char *dst, *src;
  2162.     int i, j, n, x1, y1, x;
  2163.     int logo_depth, done = 0;
  2165.     /* Return if the frame buffer is not mapped */
  2166.     if (!fb)
  2167. return 0;
  2169.     /*
  2170.      * Set colors if visual is PSEUDOCOLOR and we have enough colors, or for
  2171.      * DIRECTCOLOR
  2172.      * We don't have to set the colors for the 16-color logo, since that logo
  2173.      * uses the standard VGA text console palette
  2174.      */
  2175.     if ((p->visual == FB_VISUAL_PSEUDOCOLOR && depth >= 8) ||
  2176. (p->visual == FB_VISUAL_DIRECTCOLOR && depth >= 24))
  2177. for (i = 0; i < LINUX_LOGO_COLORS; i += n) {
  2178.     n = LINUX_LOGO_COLORS - i;
  2179.     if (n > 16)
  2180. /* palette_cmap provides space for only 16 colors at once */
  2181. n = 16;
  2182.     palette_cmap.start = i;
  2183.     palette_cmap.len   = n;
  2184.     for( j = 0; j < n; ++j ) {
  2185. palette_cmap.red[j]   = (linux_logo_red[i+j] << 8) |
  2186. linux_logo_red[i+j];
  2187. palette_cmap.green[j] = (linux_logo_green[i+j] << 8) |
  2188. linux_logo_green[i+j];
  2189. palette_cmap.blue[j]  = (linux_logo_blue[i+j] << 8) |
  2190. linux_logo_blue[i+j];
  2191.     }
  2192.     p->fb_info->fbops->fb_set_cmap(&palette_cmap, 1, fg_console,
  2193.    p->fb_info);
  2194. }
  2196.     if (depth >= 8) {
  2197. logo = linux_logo;
  2198. logo_depth = 8;
  2199.     }
  2200.     else if (depth >= 4) {
  2201. logo = linux_logo16;
  2202. logo_depth = 4;
  2203.     }
  2204.     else {
  2205. logo = linux_logo_bw;
  2206. logo_depth = 1;
  2207.     }
  2208.     
  2209.     if (p->fb_info->fbops->fb_rasterimg)
  2210.      p->fb_info->fbops->fb_rasterimg(p->fb_info, 1);
  2212.     for (x = 0; x < smp_num_cpus * (LOGO_W + 8) &&
  2213.       x < p->var.xres - (LOGO_W + 8); x += (LOGO_W + 8)) {
  2214.       
  2215. #if defined(CONFIG_FBCON_CFB16) || defined(CONFIG_FBCON_CFB24) || 
  2216.     defined(CONFIG_FBCON_CFB32) || defined(CONFIG_FB_SBUS)
  2217.         if (p->visual == FB_VISUAL_DIRECTCOLOR) {
  2218.     unsigned int val; /* max. depth 32! */
  2219.     int bdepth;
  2220.     int redshift, greenshift, blueshift;
  2222.     /* Bug: Doesn't obey msb_right ... (who needs that?) */
  2223.     redshift   = p->var.red.offset;
  2224.     greenshift = p->var.green.offset;
  2225.     blueshift  = p->var.blue.offset;
  2227.     if (depth >= 24 && (depth % 8) == 0) {
  2228. /* have at least 8 bits per color */
  2229. src = logo;
  2230. bdepth = depth/8;
  2231. for( y1 = 0; y1 < LOGO_H; y1++ ) {
  2232.     dst = fb + y1*line + x*bdepth;
  2233.     for( x1 = 0; x1 < LOGO_W; x1++, src++ ) {
  2234. val = (*src << redshift) |
  2235.       (*src << greenshift) |
  2236.       (*src << blueshift);
  2237. if (bdepth == 4 && !((long)dst & 3)) {
  2238.     /* Some cards require 32bit access */
  2239.     fb_writel (val, dst);
  2240.     dst += 4;
  2241. } else if (bdepth == 2 && !((long)dst & 1)) {
  2242.     /* others require 16bit access */
  2243.     fb_writew (val,dst);
  2244.     dst +=2;
  2245. } else {
  2246. #ifdef __LITTLE_ENDIAN
  2247.     for( i = 0; i < bdepth; ++i )
  2248. #else
  2249.     for( i = bdepth-1; i >= 0; --i )
  2250. #endif
  2251.         fb_writeb (val >> (i*8), dst++);
  2252. }
  2253.     }
  2254. }
  2255.     }
  2256.     else if (depth >= 12 && depth <= 23) {
  2257.         /* have 4..7 bits per color, using 16 color image */
  2258. unsigned int pix;
  2259. src = linux_logo16;
  2260. bdepth = (depth+7)/8;
  2261. for( y1 = 0; y1 < LOGO_H; y1++ ) {
  2262.     dst = fb + y1*line + x*bdepth;
  2263.     for( x1 = 0; x1 < LOGO_W/2; x1++, src++ ) {
  2264. pix = *src >> 4; /* upper nibble */
  2265. val = (pix << redshift) |
  2266.       (pix << greenshift) |
  2267.       (pix << blueshift);
  2268. #ifdef __LITTLE_ENDIAN
  2269. for( i = 0; i < bdepth; ++i )
  2270. #else
  2271. for( i = bdepth-1; i >= 0; --i )
  2272. #endif
  2273.     fb_writeb (val >> (i*8), dst++);
  2274. pix = *src & 0x0f; /* lower nibble */
  2275. val = (pix << redshift) |
  2276.       (pix << greenshift) |
  2277.       (pix << blueshift);
  2278. #ifdef __LITTLE_ENDIAN
  2279. for( i = 0; i < bdepth; ++i )
  2280. #else
  2281. for( i = bdepth-1; i >= 0; --i )
  2282. #endif
  2283.     fb_writeb (val >> (i*8), dst++);
  2284.     }
  2285. }
  2286.     }
  2287.     done = 1;
  2288.         }
  2289. #endif
  2290. #if defined(CONFIG_FBCON_CFB16) || defined(CONFIG_FBCON_CFB24) || 
  2291.     defined(CONFIG_FBCON_CFB32) || defined(CONFIG_FB_SBUS)
  2292. if ((depth % 8 == 0) && (p->visual == FB_VISUAL_TRUECOLOR)) {
  2293.     /* Modes without color mapping, needs special data transformation... */
  2294.     unsigned int val; /* max. depth 32! */
  2295.     int bdepth = depth/8;
  2296.     unsigned char mask[9] = { 0,0x80,0xc0,0xe0,0xf0,0xf8,0xfc,0xfe,0xff };
  2297.     unsigned char redmask, greenmask, bluemask;
  2298.     int redshift, greenshift, blueshift;
  2300.     /* Bug: Doesn't obey msb_right ... (who needs that?) */
  2301.     redmask   = mask[p->var.red.length   < 8 ? p->var.red.length   : 8];
  2302.     greenmask = mask[p->var.green.length < 8 ? p->var.green.length : 8];
  2303.     bluemask  = mask[p->var.blue.length  < 8 ? p->var.blue.length  : 8];
  2304.     redshift   = p->var.red.offset   - (8-p->var.red.length);
  2305.     greenshift = p->var.green.offset - (8-p->var.green.length);
  2306.     blueshift  = p->var.blue.offset  - (8-p->var.blue.length);
  2308.     src = logo;
  2309.     for( y1 = 0; y1 < LOGO_H; y1++ ) {
  2310. dst = fb + y1*line + x*bdepth;
  2311. for( x1 = 0; x1 < LOGO_W; x1++, src++ ) {
  2312.     val = safe_shift((linux_logo_red[*src]   & redmask), redshift) |
  2313.           safe_shift((linux_logo_green[*src] & greenmask), greenshift) |
  2314.           safe_shift((linux_logo_blue[*src]  & bluemask), blueshift);
  2315.     if (bdepth == 4 && !((long)dst & 3)) {
  2316. /* Some cards require 32bit access */
  2317. fb_writel (val, dst);
  2318. dst += 4;
  2319.     } else if (bdepth == 2 && !((long)dst & 1)) {
  2320. /* others require 16bit access */
  2321. fb_writew (val,dst);
  2322. dst +=2;
  2323.     } else {
  2324. #ifdef __LITTLE_ENDIAN
  2325. for( i = 0; i < bdepth; ++i )
  2326. #else
  2327. for( i = bdepth-1; i >= 0; --i )
  2328. #endif
  2329.     fb_writeb (val >> (i*8), dst++);
  2330.     }
  2331. }
  2332.     }
  2333.     done = 1;
  2334. }
  2335. #endif
  2336. #if defined(CONFIG_FBCON_CFB4)
  2337. if (depth == 4 && p->type == FB_TYPE_PACKED_PIXELS) {
  2338. src = logo;
  2339. for( y1 = 0; y1 < LOGO_H; y1++) {
  2340. dst = fb + y1*line + x/2;
  2341. for( x1 = 0; x1 < LOGO_W/2; x1++) {
  2342. u8 q = *src++;
  2343. q = (q << 4) | (q >> 4);
  2344. fb_writeb (q, dst++);
  2345. }
  2346. }
  2347. done = 1;
  2348. }
  2349. #endif
  2350. #if defined(CONFIG_FBCON_CFB8) || defined(CONFIG_FB_SBUS)
  2351. if (depth == 8 && p->type == FB_TYPE_PACKED_PIXELS) {
  2352.     /* depth 8 or more, packed, with color registers */
  2354.     src = logo;
  2355.     for( y1 = 0; y1 < LOGO_H; y1++ ) {
  2356. dst = fb + y1*line + x;
  2357. for( x1 = 0; x1 < LOGO_W; x1++ )
  2358.     fb_writeb (*src++, dst++);
  2359.     }
  2360.     done = 1;
  2361. }
  2362. #endif
  2363. #if defined(CONFIG_FBCON_AFB) || defined(CONFIG_FBCON_ILBM) || 
  2364.     defined(CONFIG_FBCON_IPLAN2P2) || defined(CONFIG_FBCON_IPLAN2P4) || 
  2365.     defined(CONFIG_FBCON_IPLAN2P8)
  2366. if (depth >= 2 && (p->type == FB_TYPE_PLANES ||
  2367.    p->type == FB_TYPE_INTERLEAVED_PLANES)) {
  2368.     /* planes (normal or interleaved), with color registers */
  2369.     int bit;
  2370.     unsigned char val, mask;
  2371.     int plane = p->next_plane;
  2373. #if defined(CONFIG_FBCON_IPLAN2P2) || defined(CONFIG_FBCON_IPLAN2P4) || 
  2374.     defined(CONFIG_FBCON_IPLAN2P8)
  2375.     int line_length = p->line_length;
  2377.     /* for support of Atari interleaved planes */
  2378. #define MAP_X(x) (line_length ? (x) : ((x) & ~1)*depth + ((x) & 1))
  2379. #else
  2380. #define MAP_X(x) (x)
  2381. #endif
  2382.     /* extract a bit from the source image */
  2383. #define BIT(p,pix,bit) (p[pix*logo_depth/8] & 
  2384.  (1 << ((8-((pix*logo_depth)&7)-logo_depth) + bit)))
  2386.     src = logo;
  2387.     for( y1 = 0; y1 < LOGO_H; y1++ ) {
  2388. for( x1 = 0; x1 < LOGO_LINE; x1++, src += logo_depth ) {
  2389.     dst = fb + y1*line + MAP_X(x/8+x1);
  2390.     for( bit = 0; bit < logo_depth; bit++ ) {
  2391. val = 0;
  2392. for( mask = 0x80, i = 0; i < 8; mask >>= 1, i++ ) {
  2393.     if (BIT( src, i, bit ))
  2394. val |= mask;
  2395. }
  2396. *dst = val;
  2397. dst += plane;
  2398.     }
  2399. }
  2400.     }
  2402.     /* fill remaining planes */
  2403.     if (depth > logo_depth) {
  2404. for( y1 = 0; y1 < LOGO_H; y1++ ) {
  2405.     for( x1 = 0; x1 < LOGO_LINE; x1++ ) {
  2406. dst = fb + y1*line + MAP_X(x/8+x1) + logo_depth*plane;
  2407. for( i = logo_depth; i < depth; i++, dst += plane )
  2408.     *dst = 0x00;
  2409.     }
  2410. }
  2411.     }
  2412.     done = 1;
  2413.     break;
  2414. }
  2415. #endif
  2416. #if defined(CONFIG_FBCON_MFB) || defined(CONFIG_FBCON_AFB) || 
  2417.     defined(CONFIG_FBCON_ILBM) || defined(CONFIG_FBCON_HGA)
  2419. if (depth == 1 && (p->type == FB_TYPE_PACKED_PIXELS ||
  2420.    p->type == FB_TYPE_PLANES ||
  2421.    p->type == FB_TYPE_INTERLEAVED_PLANES)) {
  2423.     /* monochrome */
  2424.     unsigned char inverse = p->inverse || p->visual == FB_VISUAL_MONO01
  2425. ? 0x00 : 0xff;
  2427.     int is_hga = !strncmp(p->fb_info->modename, "HGA", 3);
  2428.     /* can't use simply memcpy because need to apply inverse */
  2429.     for( y1 = 0; y1 < LOGO_H; y1++ ) {
  2430. src = logo + y1*LOGO_LINE;
  2431. if (is_hga)
  2432.     dst = fb + (y1%4)*8192 + (y1>>2)*line + x/8;
  2433. else
  2434.     dst = fb + y1*line + x/8;
  2435. for( x1 = 0; x1 < LOGO_LINE; ++x1 )
  2436.     fb_writeb(fb_readb(src++) ^ inverse, dst++);
  2437.     }
  2438.     done = 1;
  2439. }
  2440. #endif
  2441. #if defined(CONFIG_FBCON_VGA_PLANES)
  2442. if (depth == 4 && p->type == FB_TYPE_VGA_PLANES) {
  2443. outb_p(1,0x3ce); outb_p(0xf,0x3cf);
  2444. outb_p(3,0x3ce); outb_p(0,0x3cf);
  2445. outb_p(5,0x3ce); outb_p(0,0x3cf);
  2447. src = logo;
  2448. for (y1 = 0; y1 < LOGO_H; y1++) {
  2449. for (x1 = 0; x1 < LOGO_W / 2; x1++) {
  2450. dst = fb + y1*line + x1/4 + x/8;
  2452. outb_p(0,0x3ce);
  2453. outb_p(*src >> 4,0x3cf);
  2454. outb_p(8,0x3ce);
  2455. outb_p(1 << (7 - x1 % 4 * 2),0x3cf);
  2456. fb_readb (dst);
  2457. fb_writeb (0, dst);
  2459. outb_p(0,0x3ce);
  2460. outb_p(*src & 0xf,0x3cf);
  2461. outb_p(8,0x3ce);
  2462. outb_p(1 << (7 - (1 + x1 % 4 * 2)),0x3cf);
  2463. fb_readb (dst);
  2464. fb_writeb (0, dst);
  2466. src++;
  2467. }
  2468. }
  2469. done = 1;
  2470. }
  2471. #endif
  2472.     }
  2473.     
  2474.     if (p->fb_info->fbops->fb_rasterimg)
  2475.      p->fb_info->fbops->fb_rasterimg(p->fb_info, 0);
  2477.     /* Modes not yet supported: packed pixels with depth != 8 (does such a
  2478.      * thing exist in reality?) */
  2480.     return done ? (LOGO_H + fontheight(p) - 1) / fontheight(p) : 0 ;
  2481. }
  2483. #ifdef CONFIG_PM
  2484. /* console.c doesn't do enough here */
  2485. static int
  2486. pm_fbcon_request(struct pm_dev *dev, pm_request_t rqst, void *data)
  2487. {
  2488. unsigned long flags;
  2490. switch (rqst)
  2491. {
  2492. case PM_RESUME:
  2493. acquire_console_sem();
  2494. fbcon_sleeping = 0;
  2495. if (use_timer_cursor) {
  2496. cursor_timer.expires = jiffies+HZ/50;
  2497. add_timer(&cursor_timer);
  2498. }
  2499. release_console_sem();
  2500. break;
  2501. case PM_SUSPEND:
  2502. acquire_console_sem();
  2503. save_flags(flags);
  2504. cli();
  2505. if (use_timer_cursor)
  2506. del_timer(&cursor_timer);
  2507. fbcon_sleeping = 1;
  2508. restore_flags(flags);
  2509. release_console_sem();
  2510. break;
  2511. }
  2512. return 0;
  2513. }
  2514. #endif /* CONFIG_PM */
  2516. /*
  2517.  *  The console `switch' structure for the frame buffer based console
  2518.  */
  2519.  
  2520. const struct consw fb_con = {
  2521.     con_startup:  fbcon_startup, 
  2522.     con_init:  fbcon_init,
  2523.     con_deinit:  fbcon_deinit,
  2524.     con_clear:  fbcon_clear,
  2525.     con_putc:  fbcon_putc,
  2526.     con_putcs:  fbcon_putcs,
  2527.     con_cursor:  fbcon_cursor,
  2528.     con_scroll:  fbcon_scroll,
  2529.     con_bmove:  fbcon_bmove,
  2530.     con_switch:  fbcon_switch,
  2531.     con_blank:  fbcon_blank,
  2532.     con_font_op: fbcon_font_op,
  2533.     con_set_palette:  fbcon_set_palette,
  2534.     con_scrolldelta:  fbcon_scrolldelta,
  2535.     con_set_origin:  fbcon_set_origin,
  2536.     con_invert_region: fbcon_invert_region,
  2537.     con_screen_pos: fbcon_screen_pos,
  2538.     con_getxy: fbcon_getxy,
  2539. };
  2542. /*
  2543.  *  Dummy Low Level Operations
  2544.  */
  2546. static void fbcon_dummy_op(void) {}
  2548. #define DUMMY (void *)fbcon_dummy_op
  2550. struct display_switch fbcon_dummy = {
  2551.     setup: DUMMY,
  2552.     bmove: DUMMY,
  2553.     clear: DUMMY,
  2554.     putc: DUMMY,
  2555.     putcs: DUMMY,
  2556.     revc: DUMMY,
  2557. };
  2560. /*
  2561.  *  Visible symbols for modules
  2562.  */
  2564. EXPORT_SYMBOL(fb_display);
  2565. EXPORT_SYMBOL(fbcon_redraw_bmove);
  2566. EXPORT_SYMBOL(fbcon_redraw_clear);
  2567. EXPORT_SYMBOL(fbcon_dummy);
  2568. EXPORT_SYMBOL(fb_con);
  2570. MODULE_LICENSE("GPL");