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

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

嵌入式Linux

开发平台：

Unix_Linux

fbcon-mac.c：源码内容
  1. /*
  2.  *  linux/drivers/video/fbcon-mac.c -- Low level frame buffer operations for 
  3.  *        x bpp packed pixels, font width != 8
  4.  *
  5.  * Created 26 Dec 1997 by Michael Schmitz
  6.  * Based on the old macfb.c 6x11 code by Randy Thelen
  7.  *
  8.  * This driver is significantly slower than the 8bit font drivers 
  9.  * and would probably benefit from splitting into drivers for each depth.
  10.  *
  11.  *  This file is subject to the terms and conditions of the GNU General Public
  12.  *  License.  See the file COPYING in the main directory of this archive for
  13.  */
  15. #include <linux/module.h>
  16. #include <linux/tty.h>
  17. #include <linux/console.h>
  18. #include <linux/string.h>
  19. #include <linux/fb.h>
  20. #include <linux/delay.h>
  22. #include <video/fbcon.h>
  23. #include <video/fbcon-mac.h>
  26.     /*
  27.      *  variable bpp packed pixels
  28.      */
  30. static void plot_pixel_mac(struct display *p, int bw, int pixel_x,
  31.    int pixel_y);
  32. static int get_pixel_mac(struct display *p, int pixel_x, int pixel_y);
  34. void fbcon_mac_setup(struct display *p)
  35. {
  36.     if (p->line_length)
  37. p->next_line = p->line_length;
  38.     else
  39.      p->next_line = p->var.xres_virtual>>3;
  40.     p->next_plane = 0;
  41. }
  44.    /*
  45.     *    Macintosh
  46.     */
  47. #define PIXEL_BLACK_MAC          0
  48. #define PIXEL_WHITE_MAC          1
  49. #define PIXEL_INVERT_MAC         2
  51. void fbcon_mac_bmove(struct display *p, int sy, int sx, int dy, int dx,
  52.      int height, int width)
  53. {
  54.    int i, j;
  55.    u8 *dest, *src;
  56.    int l,r,t,b,w,lo,s;
  57.    int dl,dr,dt,db,dw,dlo;
  58.    int move_up;
  60.    src = (u8 *) (p->screen_base + sy * fontheight(p) * p->next_line);
  61.    dest = (u8 *) (p->screen_base + dy * fontheight(p) * p->next_line);
  63.    if( sx == 0 && width == p->conp->vc_cols) {
  64.      s = height * fontheight(p) * p->next_line;
  65.      fb_memmove(dest, src, s);
  66.      return;
  67.    }
  68.    
  69.    l = sx * fontwidth(p);
  70.    r = l + width * fontwidth(p);
  71.    t = sy * fontheight(p);
  72.    b = t + height * fontheight(p);
  74.    dl = dx * fontwidth(p);
  75.    dr = dl + width * fontwidth(p);
  76.    dt = dy * fontheight(p);
  77.    db = dt + height * fontheight(p);
  79.    /* w is the # pixels between two long-aligned points, left and right */
  80.    w = (r&~31) - ((l+31)&~31);
  81.    dw = (dr&~31) - ((dl+31)&~31);
  82.    /* lo is the # pixels between the left edge and a long-aligned left pixel */
  83.    lo = ((l+31)&~31) - l;
  84.    dlo = ((dl+31)&~31) - dl;
  85.    
  86.    /* if dx != sx then, logic has to align the left and right edges for fast moves */
  87.    if (lo != dlo) {
  88.      lo = ((l+7)&~7) - l;
  89.      dlo = ((dl+7)&~7) - dl;
  90.      w = (r&~7) - ((l+7)&~7);
  91.      dw = (dr&~7) - ((dl+7)&~7);
  92.      if (lo != dlo) {
  93.        unsigned char err_str[128];
  94.        unsigned short err_buf[256];
  95.        unsigned long cnt, len;
  96.        sprintf( err_str, "ERROR: Shift algorithm: sx=%d,sy=%d,dx=%d,dy=%d,w=%d,h=%d,bpp=%d",
  97. sx,sy,dx,dy,width,height,p->var.bits_per_pixel);
  98.        len = strlen(err_str);
  99.        for (cnt = 0; cnt < len; cnt++)
  100.          err_buf[cnt] = 0x700 | err_str[cnt];
  101.        fbcon_mac_putcs(p->conp, p, err_buf, len, 0, 0);
  102.        /* pause for the user */
  103.        printk( "ERROR: shift algorithm...n" );
  104.        mdelay(5000);
  105.        return;
  106.      }
  107.    }
  109.    s = 0;
  110.    switch (p->var.bits_per_pixel) {
  111.    case 1:
  112.      s = w >> 3;
  113.      src += lo >> 3;
  114.      dest += lo >> 3;
  115.      break;
  116.    case 2:
  117.      s = w >> 2;
  118.      src += lo >> 2;
  119.      dest += lo >> 2;
  120.      break;
  121.    case 4:
  122.      s = w >> 1;
  123.      src += lo >> 1;
  124.      dest += lo >> 1;
  125.      break;
  126.    case 8:
  127.      s = w;
  128.      src += lo;
  129.      dest += lo;
  130.      break;
  131.    case 16:
  132.      s = w << 1;
  133.      src += lo << 1;
  134.      dest += lo << 1;
  135.      break;
  136.    case 32:
  137.      s = w << 2;
  138.      src += lo << 2;
  139.      dest += lo << 2;
  140.      break;
  141.    }
  143.    if (sy <= sx) {
  144.      i = b;
  145.      move_up = 0;
  146.      src += height * fontheight(p);
  147.      dest += height * fontheight(p);
  148.    } else {
  149.      i = t;
  150.      move_up = 1;
  151.    }
  153.    while (1) {
  154.      for (i = t; i < b; i++) {
  155.        j = l;
  157.        for (; j & 31 && j < r; j++)
  158.  plot_pixel_mac(p, get_pixel_mac(p, j+(dx-sx), i+(dy-sy)), j, i);
  160.        if (j < r) {
  161.  fb_memmove(dest, src, s);
  162.  if (move_up) {
  163.    dest += p->next_line;
  164.    src += p->next_line;
  165.  } else {
  166.    dest -= p->next_line;
  167.    src -= p->next_line;
  168.  }
  169.  j += w;
  170.        }
  171.      
  172.        for (; j < r; j++)
  173.  plot_pixel_mac(p, get_pixel_mac(p, j+(dx-sx), i+(dy-sy)), j, i);
  174.      }
  176.      if (move_up) {
  177.        i++;
  178.        if (i >= b)
  179.  break;
  180.      } else {
  181.        i--;
  182.        if (i < t)
  183.  break;
  184.      }
  185.    }
  186. }
  189. void fbcon_mac_clear(struct vc_data *conp, struct display *p, int sy, int sx,
  190.      int height, int width)
  191. {
  192.    int pixel;
  193.    int i, j;
  194.    int inverse;
  195.    u8 *dest;
  196.    int l,r,t,b,w,lo,s;
  198.    inverse = conp ? attr_reverse(p,conp->vc_attr) : 0;
  199.    pixel = inverse ? PIXEL_WHITE_MAC : PIXEL_BLACK_MAC;
  200.    dest = (u8 *) (p->screen_base + sy * fontheight(p) * p->next_line);
  202.    if( sx == 0 && width == p->conp->vc_cols) {
  203.      s = height * fontheight(p) * p->next_line;
  204.      if (inverse)
  205.        fb_memclear(dest, s);
  206.      else
  207.        fb_memset255(dest, s);
  208.    }
  209.    
  210.    l = sx * fontwidth(p);
  211.    r = l + width * fontwidth(p);
  212.    t = sy * fontheight(p);
  213.    b = t + height * fontheight(p);
  214.    /* w is the # pixels between two long-aligned points, left and right */
  215.    w = (r&~31) - ((l+31)&~31);
  216.    /* lo is the # pixels between the left edge and a long-aligned left pixel */
  217.    lo = ((l+31)&~31) - l;
  218.    s = 0;
  219.    switch (p->var.bits_per_pixel) {
  220.    case 1:
  221.      s = w >> 3;
  222.      dest += lo >> 3;
  223.      break;
  224.    case 2:
  225.      s = w >> 2;
  226.      dest += lo >> 2;
  227.      break;
  228.    case 4:
  229.      s = w >> 1;
  230.      dest += lo >> 1;
  231.      break;
  232.    case 8:
  233.      s = w;
  234.      dest += lo;
  235.      break;
  236.    case 16:
  237.      s = w << 1;
  238.      dest += lo << 1;
  239.      break;
  240.    case 32:
  241.      s = w << 2;
  242.      dest += lo << 2;
  243.      break;
  244.    }
  246.    for (i = t; i < b; i++) {
  247.      j = l;
  249.      for (; j & 31 && j < r; j++)
  250.        plot_pixel_mac(p, pixel, j, i);
  252.      if (j < r) {
  253.        if (PIXEL_WHITE_MAC == pixel)
  254.  fb_memclear(dest, s);
  255.        else
  256.  fb_memset255(dest, s);
  257.        dest += p->next_line;
  258.        j += w;
  259.      }
  260.      
  261.      for (; j < r; j++)
  262.        plot_pixel_mac(p, pixel, j, i);
  263.    }
  264. }
  267. void fbcon_mac_putc(struct vc_data *conp, struct display *p, int c, int yy,
  268.     int xx)
  269. {
  270.    u8 *cdat;
  271.    u_int rows, bold, ch_reverse, ch_underline;
  272.    u8 d;
  273.    int j;
  275.    cdat = p->fontdata+(c&p->charmask)*fontheight(p);
  276.    bold = attr_bold(p,c);
  277.    ch_reverse = attr_reverse(p,c);
  278.    ch_underline = attr_underline(p,c);
  280.    for (rows = 0; rows < fontheight(p); rows++) {
  281.       d = *cdat++;
  282.       if (!conp->vc_can_do_color) {
  283. if (ch_underline && rows == (fontheight(p)-2))
  284.   d = 0xff;
  285. else if (bold)
  286.   d |= d>>1;
  287. if (ch_reverse)
  288.   d = ~d;
  289.       }
  290.       for (j = 0; j < fontwidth(p); j++) {
  291. plot_pixel_mac(p, (d & 0x80) >> 7, (xx*fontwidth(p)) + j, (yy*fontheight(p)) + rows);
  292. d <<= 1;
  293.       }
  294.    }
  295. }
  298. void fbcon_mac_putcs(struct vc_data *conp, struct display *p, 
  299.      const unsigned short *s, int count, int yy, int xx)
  300. {
  301.    u16 c;
  303.    while (count--) {
  304.       c = scr_readw(s++);
  305.       fbcon_mac_putc(conp, p, c, yy, xx++);
  306.    }
  307. }
  310. void fbcon_mac_revc(struct display *p, int xx, int yy)
  311. {
  312.    u_int rows, j;
  314.    for (rows = 0; rows < fontheight(p); rows++) {
  315.      for (j = 0; j < fontwidth(p); j++) {
  316.        plot_pixel_mac (p, PIXEL_INVERT_MAC, (xx*fontwidth(p))+j, (yy*fontheight(p))+rows);
  317.      }
  318.    }
  319. }
  321. static inline void plot_helper(u8 *dest, u8 bit, int bw)
  322. {
  323.     switch (bw) {
  324.     case PIXEL_BLACK_MAC:
  325.       fb_writeb( fb_readb(dest) | bit, dest );
  326.       break;
  327.     case PIXEL_WHITE_MAC:
  328.       fb_writeb( fb_readb(dest) & (~bit), dest );
  329.       break;
  330.     case PIXEL_INVERT_MAC:
  331.       fb_writeb( fb_readb(dest) ^ bit, dest );
  332.       break;
  333.     default:
  334.       printk( "ERROR: Unknown pixel value in plot_pixel_macn");
  335.     }
  336. }
  338. /*
  339.  * plot_pixel_mac
  340.  */
  341. static void plot_pixel_mac(struct display *p, int bw, int pixel_x, int pixel_y)
  342. {
  343.   u8 *dest, bit;
  344.   u16 *dest16, pix16;
  345.   u32 *dest32, pix32;
  347.   /* There *are* 68k Macs that support more than 832x624, you know :-) */
  348.   if (pixel_x < 0 || pixel_y < 0 || pixel_x >= p->var.xres || pixel_y >= p->var.yres) {
  349.     printk ("ERROR: pixel_x == %d, pixel_y == %d", pixel_x, pixel_y);
  350.     mdelay(1000);
  351.     return;
  352.   }
  354.   switch (p->var.bits_per_pixel) {
  355.   case 1:
  356.     dest = (u8 *) ((pixel_x >> 3) + p->screen_base + pixel_y * p->next_line);
  357.     bit = 0x80 >> (pixel_x & 7);
  358.     plot_helper(dest, bit, bw);
  359.     break;
  361.   case 2:
  362.     dest = (u8 *) ((pixel_x >> 2) + p->screen_base + pixel_y * p->next_line);
  363.     bit = 0xC0 >> ((pixel_x & 3) << 1);
  364.     plot_helper(dest, bit, bw);
  365.     break;
  367.   case 4:
  368.     dest = (u8 *) ((pixel_x >> 1) + p->screen_base + pixel_y * p->next_line);
  369.     bit = 0xF0 >> ((pixel_x & 1) << 2);
  370.     plot_helper(dest, bit, bw);
  371.     break;
  373.   case 8:
  374.     dest = (u8 *) (pixel_x + p->screen_base + pixel_y * p->next_line);
  375.     bit = 0xFF;
  376.     plot_helper(dest, bit, bw);
  377.     break;
  379. /* FIXME: You can't access framebuffer directly like this! */
  380.   case 16:
  381.     dest16 = (u16 *) ((pixel_x *2) + p->screen_base + pixel_y * p->next_line);
  382.     pix16 = 0xFFFF;
  383.     switch (bw) {
  384.     case PIXEL_BLACK_MAC:  *dest16 = ~pix16; break;
  385.     case PIXEL_WHITE_MAC:  *dest16 = pix16;  break;
  386.     case PIXEL_INVERT_MAC: *dest16 ^= pix16; break;
  387.     default: printk( "ERROR: Unknown pixel value in plot_pixel_macn");
  388.     }
  389.     break;
  391.   case 32:
  392.     dest32 = (u32 *) ((pixel_x *4) + p->screen_base + pixel_y * p->next_line);
  393.     pix32 = 0xFFFFFFFF;
  394.     switch (bw) {
  395.     case PIXEL_BLACK_MAC:  *dest32 = ~pix32; break;
  396.     case PIXEL_WHITE_MAC:  *dest32 = pix32;  break;
  397.     case PIXEL_INVERT_MAC: *dest32 ^= pix32; break;
  398.     default: printk( "ERROR: Unknown pixel value in plot_pixel_macn");
  399.     }
  400.     break;
  401.   }
  402. }
  404. static int get_pixel_mac(struct display *p, int pixel_x, int pixel_y)
  405. {
  406.   u8 *dest, bit;
  407.   u16 *dest16;
  408.   u32 *dest32;
  409.   u8 pixel=0;
  411.   switch (p->var.bits_per_pixel) {
  412.   case 1:
  413.     dest = (u8 *) ((pixel_x / 8) + p->screen_base + pixel_y * p->next_line);
  414.     bit = 0x80 >> (pixel_x & 7);
  415.     pixel = *dest & bit;
  416.     break;
  417.   case 2:
  418.     dest = (u8 *) ((pixel_x / 4) + p->screen_base + pixel_y * p->next_line);
  419.     bit = 0xC0 >> (pixel_x & 3);
  420.     pixel = *dest & bit;
  421.     break;
  422.   case 4:
  423.     dest = (u8 *) ((pixel_x / 2) + p->screen_base + pixel_y * p->next_line);
  424.     bit = 0xF0 >> (pixel_x & 1);
  425.     pixel = *dest & bit;
  426.     break;
  427.   case 8:
  428.     dest = (u8 *) (pixel_x + p->screen_base + pixel_y * p->next_line);
  429.     pixel = *dest;
  430.     break;
  431.   case 16:
  432.     dest16 = (u16 *) ((pixel_x *2) + p->screen_base + pixel_y * p->next_line);
  433.     pixel = *dest16 ? 1 : 0;
  434.     break;
  435.   case 32:
  436.     dest32 = (u32 *) ((pixel_x *4) + p->screen_base + pixel_y * p->next_line);
  437.     pixel = *dest32 ? 1 : 0;
  438.     break;
  439.   }
  441.   return pixel ? PIXEL_BLACK_MAC : PIXEL_WHITE_MAC;
  442. }
  445.     /*
  446.      *  `switch' for the low level operations
  447.      */
  449. struct display_switch fbcon_mac = {
  450.     setup: fbcon_mac_setup,
  451.     bmove: fbcon_redraw_bmove,
  452.     clear: fbcon_redraw_clear,
  453.     putc: fbcon_mac_putc,
  454.     putcs: fbcon_mac_putcs,
  455.     revc: fbcon_mac_revc,
  456.     fontwidthmask: FONTWIDTHRANGE(1,8)
  457. };
  460. #ifdef MODULE
  461. MODULE_LICENSE("GPL");
  463. int init_module(void)
  464. {
  465.     return 0;
  466. }
  468. void cleanup_module(void)
  469. {}
  470. #endif /* MODULE */
  473.     /*
  474.      *  Visible symbols for modules
  475.      */
  477. EXPORT_SYMBOL(fbcon_mac);
  478. EXPORT_SYMBOL(fbcon_mac_setup);
  479. EXPORT_SYMBOL(fbcon_mac_bmove);
  480. EXPORT_SYMBOL(fbcon_mac_clear);
  481. EXPORT_SYMBOL(fbcon_mac_putc);
  482. EXPORT_SYMBOL(fbcon_mac_putcs);
  483. EXPORT_SYMBOL(fbcon_mac_revc);