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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
fm2fb.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：14k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

fm2fb.c：源码内容
  1. /*
  2.  *  linux/drivers/video/fm2fb.c -- BSC FrameMaster II/Rainbow II frame buffer
  3.  *    device
  4.  *
  5.  * Copyright (C) 1998 Steffen A. Mork (mork@ls7.cs.uni-dortmund.de)
  6.  * Copyright (C) 1999 Geert Uytterhoeven
  7.  *
  8.  *  Written for 2.0.x by Steffen A. Mork
  9.  *  Ported to 2.1.x by Geert Uytterhoeven
  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.  *  more details.
  14.  */
  16. #include <linux/module.h>
  17. #include <linux/mm.h>
  18. #include <linux/fb.h>
  19. #include <linux/init.h>
  20. #include <linux/zorro.h>
  22. #include <asm/io.h>
  24. #include <video/fbcon.h>
  25. #include <video/fbcon-cfb32.h>
  28. /*
  29.  * Some technical notes:
  30.  *
  31.  * The BSC FrameMaster II (or Rainbow II) is a simple very dumb
  32.  * frame buffer which allows to display 24 bit true color images.
  33.  * Each pixel is 32 bit width so it's very easy to maintain the
  34.  * frame buffer. One long word has the following layout:
  35.  * AARRGGBB which means: AA the alpha channel byte, RR the red
  36.  * channel, GG the green channel and BB the blue channel.
  37.  *
  38.  * The FrameMaster II supports the following video modes.
  39.  * - PAL/NTSC
  40.  * - interlaced/non interlaced
  41.  * - composite sync/sync/sync over green
  42.  *
  43.  * The resolution is to the following both ones:
  44.  * - 768x576 (PAL)
  45.  * - 768x480 (NTSC)
  46.  *
  47.  * This means that pixel access per line is fixed due to the
  48.  * fixed line width. In case of maximal resolution the frame
  49.  * buffer needs an amount of memory of 1.769.472 bytes which
  50.  * is near to 2 MByte (the allocated address space of Zorro2).
  51.  * The memory is channel interleaved. That means every channel
  52.  * owns four VRAMs. Unfortunatly most FrameMasters II are
  53.  * not assembled with memory for the alpha channel. In this
  54.  * case it could be possible to add the frame buffer into the
  55.  * normal memory pool.
  56.  *
  57.  * At relative address 0x1ffff8 of the frame buffers base address
  58.  * there exists a control register with the number of
  59.  * four control bits. They have the following meaning:
  60.  * bit value meaning
  61.  *
  62.  *  0    1   0=interlaced/1=non interlaced
  63.  *  1    2   0=video out disabled/1=video out enabled
  64.  *  2    4   0=normal mode as jumpered via JP8/1=complement mode
  65.  *  3    8   0=read  onboard ROM/1 normal operation (required)
  66.  *
  67.  * As mentioned above there are several jumper. I think there
  68.  * is not very much information about the FrameMaster II in
  69.  * the world so I add these information for completeness.
  70.  *
  71.  * JP1  interlace selection (1-2 non interlaced/2-3 interlaced) 
  72.  * JP2  wait state creation (leave as is!)
  73.  * JP3  wait state creation (leave as is!)
  74.  * JP4  modulate composite sync on green output (1-2 composite
  75.  *      sync on green channel/2-3 normal composite sync)
  76.  * JP5  create test signal, shorting this jumper will create
  77.  *      a white screen
  78.  * JP6  sync creation (1-2 composite sync/2-3 H-sync output)
  79.  * JP8  video mode (1-2 PAL/2-3 NTSC)
  80.  *
  81.  * With the following jumpering table you can connect the
  82.  * FrameMaster II to a normal TV via SCART connector:
  83.  * JP1:  2-3
  84.  * JP4:  2-3
  85.  * JP6:  2-3
  86.  * JP8:  1-2 (means PAL for Europe)
  87.  *
  88.  * NOTE:
  89.  * There is no other possibility to change the video timings
  90.  * except the interlaced/non interlaced, sync control and the
  91.  * video mode PAL (50 Hz)/NTSC (60 Hz). Inside this
  92.  * FrameMaster II driver are assumed values to avoid anomalies
  93.  * to a future X server. Except the pixel clock is really
  94.  * constant at 30 MHz.
  95.  *
  96.  * 9 pin female video connector:
  97.  *
  98.  * 1  analog red 0.7 Vss
  99.  * 2  analog green 0.7 Vss
  100.  * 3  analog blue 0.7 Vss
  101.  * 4  H-sync TTL
  102.  * 5  V-sync TTL
  103.  * 6  ground
  104.  * 7  ground
  105.  * 8  ground
  106.  * 9  ground
  107.  *
  108.  * Some performance notes:
  109.  * The FrameMaster II was not designed to display a console
  110.  * this driver would do! It was designed to display still true
  111.  * color images. Imagine: When scroll up a text line there
  112.  * must copied ca. 1.7 MBytes to another place inside this
  113.  * frame buffer. This means 1.7 MByte read and 1.7 MByte write
  114.  * over the slow 16 bit wide Zorro2 bus! A scroll of one
  115.  * line needs 1 second so do not expect to much from this
  116.  * driver - he is at the limit!
  117.  *
  118.  */
  121. /*
  122.  * definitions
  123.  */
  125. #define FRAMEMASTER_SIZE 0x200000
  126. #define FRAMEMASTER_REG 0x1ffff8
  128. #define FRAMEMASTER_NOLACE 1
  129. #define FRAMEMASTER_ENABLE 2
  130. #define FRAMEMASTER_COMPL 4
  131. #define FRAMEMASTER_ROM 8
  134. struct FrameMaster_fb_par
  135. {
  136. int xres;
  137. int yres;
  138. int bpp;
  139. int pixclock;
  140. };
  142. static unsigned long fm2fb_mem_phys;
  143. static void *fm2fb_mem;
  144. static unsigned long fm2fb_reg_phys;
  145. static volatile unsigned char *fm2fb_reg;
  147. static int currcon = 0;
  148. static struct display disp;
  149. static struct fb_info fb_info;
  150. static struct { u_char red, green, blue, pad; } palette[16];
  151. #ifdef FBCON_HAS_CFB32
  152. static u32 fbcon_cfb32_cmap[16];
  153. #endif
  155. static struct fb_fix_screeninfo fb_fix;
  156. static struct fb_var_screeninfo fb_var;
  158. static int fm2fb_mode __initdata = -1;
  160. #define FM2FB_MODE_PAL 0
  161. #define FM2FB_MODE_NTSC 1
  163. static struct fb_var_screeninfo fb_var_modes[] __initdata = {
  164.     {
  165. /* 768 x 576, 32 bpp (PAL) */
  166. 768, 576, 768, 576, 0, 0, 32, 0,
  167. { 16, 8, 0 }, { 8, 8, 0 }, { 0, 8, 0 }, { 24, 8, 0 },
  168. 0, FB_ACTIVATE_NOW, -1, -1, FB_ACCEL_NONE,
  169. 33333, 10, 102, 10, 5, 80, 34, FB_SYNC_COMP_HIGH_ACT, 0
  170.     }, {
  171. /* 768 x 480, 32 bpp (NTSC - not supported yet */
  172. 768, 480, 768, 480, 0, 0, 32, 0,
  173. { 16, 8, 0 }, { 8, 8, 0 }, { 0, 8, 0 }, { 24, 8, 0 },
  174. 0, FB_ACTIVATE_NOW, -1, -1, FB_ACCEL_NONE,
  175. 33333, 10, 102, 10, 5, 80, 34, FB_SYNC_COMP_HIGH_ACT, 0
  176.     }
  177. };
  180.     /*
  181.      *  Interface used by the world
  182.      */
  184. static int fm2fb_get_fix(struct fb_fix_screeninfo *fix, int con,
  185.  struct fb_info *info);
  186. static int fm2fb_get_var(struct fb_var_screeninfo *var, int con,
  187.  struct fb_info *info);
  188. static int fm2fb_set_var(struct fb_var_screeninfo *var, int con,
  189.  struct fb_info *info);
  190. static int fm2fb_get_cmap(struct fb_cmap *cmap, int kspc, int con,
  191.   struct fb_info *info);
  192. static int fm2fb_set_cmap(struct fb_cmap *cmap, int kspc, int con,
  193.   struct fb_info *info);
  196.     /*
  197.      *  Interface to the low level console driver
  198.      */
  200. int fm2fb_init(void);
  201. static int fm2fbcon_switch(int con, struct fb_info *info);
  202. static int fm2fbcon_updatevar(int con, struct fb_info *info);
  203. static void fm2fbcon_blank(int blank, struct fb_info *info);
  206.     /*
  207.      *  Internal routines
  208.      */
  210. static int fm2fb_getcolreg(u_int regno, u_int *red, u_int *green, u_int *blue,
  211.    u_int *transp, struct fb_info *info);
  212. static int fm2fb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
  213.    u_int transp, struct fb_info *info);
  214. static void do_install_cmap(int con, struct fb_info *info);
  217. static struct fb_ops fm2fb_ops = {
  218. owner: THIS_MODULE,
  219. fb_get_fix: fm2fb_get_fix,
  220. fb_get_var: fm2fb_get_var,
  221. fb_set_var: fm2fb_set_var,
  222. fb_get_cmap: fm2fb_get_cmap,
  223. fb_set_cmap: fm2fb_set_cmap,
  224. };
  226.     /*
  227.      *  Get the Fixed Part of the Display
  228.      */
  230. static int fm2fb_get_fix(struct fb_fix_screeninfo *fix, int con,
  231.  struct fb_info *info)
  232. {
  233.     memcpy(fix, &fb_fix, sizeof(fb_fix));
  234.     return 0;
  235. }
  238.     /*
  239.      *  Get the User Defined Part of the Display
  240.      */
  242. static int fm2fb_get_var(struct fb_var_screeninfo *var, int con,
  243.  struct fb_info *info)
  244. {
  245.     memcpy(var, &fb_var, sizeof(fb_var));
  246.     return 0;
  247. }
  250.     /*
  251.      *  Set the User Defined Part of the Display
  252.      */
  254. static int fm2fb_set_var(struct fb_var_screeninfo *var, int con,
  255.  struct fb_info *info)
  256. {
  257.     struct display *display;
  258.     int oldbpp = -1, err;
  260.     if (con >= 0)
  261. display = &fb_display[con];
  262.     else
  263. display = &disp; /* used during initialization */
  265.     if (var->xres > fb_var.xres || var->yres > fb_var.yres ||
  266. var->xres_virtual > fb_var.xres_virtual ||
  267. var->yres_virtual > fb_var.yres_virtual ||
  268. var->bits_per_pixel > fb_var.bits_per_pixel ||
  269. var->nonstd ||
  270. (var->vmode & FB_VMODE_MASK) != FB_VMODE_NONINTERLACED)
  271. return -EINVAL;
  272.     memcpy(var, &fb_var, sizeof(fb_var));
  274.     if ((var->activate & FB_ACTIVATE_MASK) == FB_ACTIVATE_NOW) {
  275. oldbpp = display->var.bits_per_pixel;
  276. display->var = *var;
  277.     }
  278.     if (oldbpp != var->bits_per_pixel) {
  279. if ((err = fb_alloc_cmap(&display->cmap, 0, 0)))
  280.     return err;
  281. do_install_cmap(con, info);
  282.     }
  283.     return 0;
  284. }
  287.     /*
  288.      *  Get the Colormap
  289.      */
  291. static int fm2fb_get_cmap(struct fb_cmap *cmap, int kspc, int con,
  292.   struct fb_info *info)
  293. {
  294.     if (con == currcon) /* current console? */
  295. return fb_get_cmap(cmap, kspc, fm2fb_getcolreg, info);
  296.     else if (fb_display[con].cmap.len) /* non default colormap? */
  297. fb_copy_cmap(&fb_display[con].cmap, cmap, kspc ? 0 : 2);
  298.     else
  299. fb_copy_cmap(fb_default_cmap(256), cmap, kspc ? 0 : 2);
  300.     return 0;
  301. }
  303.     /*
  304.      *  Set the Colormap
  305.      */
  307. static int fm2fb_set_cmap(struct fb_cmap *cmap, int kspc, int con,
  308.   struct fb_info *info)
  309. {
  310.     int err;
  312.     if (!fb_display[con].cmap.len) { /* no colormap allocated? */
  313. if ((err = fb_alloc_cmap(&fb_display[con].cmap, 256, 0)))
  314.     return err;
  315.     }
  316.     if (con == currcon) { /* current console? */
  317. err = fb_set_cmap(cmap, kspc, fm2fb_setcolreg, info);
  318. return err;
  319.     } else
  320. fb_copy_cmap(cmap, &fb_display[con].cmap, kspc ? 0 : 1);
  321.     return 0;
  322. }
  325.     /*
  326.      *  Initialisation
  327.      */
  329. int __init fm2fb_init(void)
  330. {
  331.     int is_fm;
  332.     struct zorro_dev *z = NULL;
  333.     unsigned long *ptr;
  334.     int x, y;
  336.     while ((z = zorro_find_device(ZORRO_WILDCARD, z))) {
  337. if (z->id == ZORRO_PROD_BSC_FRAMEMASTER_II)
  338.     is_fm = 1;
  339. else if (z->id == ZORRO_PROD_HELFRICH_RAINBOW_II)
  340.     is_fm = 0;
  341. else
  342.     continue;
  343. if (!request_mem_region(z->resource.start, FRAMEMASTER_SIZE, "fm2fb"))
  344.     continue;
  346. /* assigning memory to kernel space */
  347. fm2fb_mem_phys = z->resource.start;
  348. fm2fb_mem  = ioremap(fm2fb_mem_phys, FRAMEMASTER_SIZE);
  349. fm2fb_reg_phys = fm2fb_mem_phys+FRAMEMASTER_REG;
  350. fm2fb_reg  = (unsigned char *)(fm2fb_mem+FRAMEMASTER_REG);
  352. /* make EBU color bars on display */
  353. ptr = (unsigned long *)fm2fb_mem;
  354. for (y = 0; y < 576; y++) {
  355.     for (x = 0; x < 96; x++) *ptr++ = 0xffffff; /* white */
  356.     for (x = 0; x < 96; x++) *ptr++ = 0xffff00; /* yellow */
  357.     for (x = 0; x < 96; x++) *ptr++ = 0x00ffff; /* cyan */
  358.     for (x = 0; x < 96; x++) *ptr++ = 0x00ff00; /* green */
  359.     for (x = 0; x < 96; x++) *ptr++ = 0xff00ff; /* magenta */
  360.     for (x = 0; x < 96; x++) *ptr++ = 0xff0000; /* red */
  361.     for (x = 0; x < 96; x++) *ptr++ = 0x0000ff; /* blue */
  362.     for (x = 0; x < 96; x++) *ptr++ = 0x000000; /* black */
  363. }
  364. fm2fbcon_blank(0, NULL);
  366. if (fm2fb_mode == -1)
  367.     fm2fb_mode = FM2FB_MODE_PAL;
  369. fb_var = fb_var_modes[fm2fb_mode];
  371. strcpy(fb_fix.id, is_fm ? "FrameMaster II" : "Rainbow II");
  372. fb_fix.smem_start = fm2fb_mem_phys;
  373. fb_fix.smem_len = FRAMEMASTER_REG;
  374. fb_fix.type = FB_TYPE_PACKED_PIXELS;
  375. fb_fix.type_aux = 0;
  376. fb_fix.visual = FB_VISUAL_TRUECOLOR;
  377. fb_fix.line_length = 768<<2;
  378. fb_fix.mmio_start = fm2fb_reg_phys;
  379. fb_fix.mmio_len = 8;
  380. fb_fix.accel = FB_ACCEL_NONE;
  382. disp.var = fb_var;
  383. disp.cmap.start = 0;
  384. disp.cmap.len = 0;
  385. disp.cmap.red = disp.cmap.green = disp.cmap.blue = disp.cmap.transp = NULL;
  386. disp.screen_base = (char *)fm2fb_mem;
  387. disp.visual = fb_fix.visual;
  388. disp.type = fb_fix.type;
  389. disp.type_aux = fb_fix.type_aux;
  390. disp.ypanstep = 0;
  391. disp.ywrapstep = 0;
  392. disp.line_length = fb_fix.line_length;
  393. disp.can_soft_blank = 1;
  394. disp.inverse = 0;
  395.     #ifdef FBCON_HAS_CFB32
  396. disp.dispsw = &fbcon_cfb32;
  397. disp.dispsw_data = &fbcon_cfb32_cmap;
  398.     #else
  399. disp.dispsw = &fbcon_dummy;
  400.     #endif
  401. disp.scrollmode = SCROLL_YREDRAW;
  403. strcpy(fb_info.modename, fb_fix.id);
  404. fb_info.node = -1;
  405. fb_info.fbops = &fm2fb_ops;
  406. fb_info.disp = &disp;
  407. fb_info.fontname[0] = '';
  408. fb_info.changevar = NULL;
  409. fb_info.switch_con = &fm2fbcon_switch;
  410. fb_info.updatevar = &fm2fbcon_updatevar;
  411. fb_info.blank = &fm2fbcon_blank;
  412. fb_info.flags = FBINFO_FLAG_DEFAULT;
  414. fm2fb_set_var(&fb_var, -1, &fb_info);
  416. if (register_framebuffer(&fb_info) < 0)
  417.     return -EINVAL;
  419. printk("fb%d: %s frame buffer devicen", GET_FB_IDX(fb_info.node),
  420.        fb_fix.id);
  421. return 0;
  422.     }
  423.     return -ENXIO;
  424. }
  426. int __init fm2fb_setup(char *options)
  427. {
  428.     char *this_opt;
  430.     if (!options || !*options)
  431. return 0;
  433.     while ((this_opt = strsep(&options, ",")) != NULL) {
  434. if (!strncmp(this_opt, "pal", 3))
  435.     fm2fb_mode = FM2FB_MODE_PAL;
  436. else if (!strncmp(this_opt, "ntsc", 4))
  437.     fm2fb_mode = FM2FB_MODE_NTSC;
  438.     }
  439.     return 0;
  440. }
  443. static int fm2fbcon_switch(int con, struct fb_info *info)
  444. {
  445.     /* Do we have to save the colormap? */
  446.     if (fb_display[currcon].cmap.len)
  447. fb_get_cmap(&fb_display[currcon].cmap, 1, fm2fb_getcolreg, info);
  449.     currcon = con;
  450.     /* Install new colormap */
  451.     do_install_cmap(con, info);
  452.     return 0;
  453. }
  455.     /*
  456.      *  Update the `var' structure (called by fbcon.c)
  457.      */
  459. static int fm2fbcon_updatevar(int con, struct fb_info *info)
  460. {
  461.     /* Nothing */
  462.     return 0;
  463. }
  465.     /*
  466.      *  Blank the display.
  467.      */
  469. static void fm2fbcon_blank(int blank, struct fb_info *info)
  470. {
  471.     unsigned char t = FRAMEMASTER_ROM;
  473.     if (!blank)
  474. t |= FRAMEMASTER_ENABLE | FRAMEMASTER_NOLACE;
  475.     fm2fb_reg[0] = t;
  476. }
  478.     /*
  479.      *  Read a single color register and split it into
  480.      *  colors/transparent. Return != 0 for invalid regno.
  481.      */
  483. static int fm2fb_getcolreg(u_int regno, u_int *red, u_int *green, u_int *blue,
  484.                          u_int *transp, struct fb_info *info)
  485. {
  486.     if (regno > 15)
  487. return 1;
  488.     *red = (palette[regno].red<<8) | palette[regno].red;
  489.     *green = (palette[regno].green<<8) | palette[regno].green;
  490.     *blue = (palette[regno].blue<<8) | palette[regno].blue;
  491.     *transp = 0;
  492.     return 0;
  493. }
  496.     /*
  497.      *  Set a single color register. The values supplied are already
  498.      *  rounded down to the hardware's capabilities (according to the
  499.      *  entries in the var structure). Return != 0 for invalid regno.
  500.      */
  502. static int fm2fb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
  503.                          u_int transp, struct fb_info *info)
  504. {
  505.     if (regno > 15)
  506. return 1;
  507.     red >>= 8;
  508.     green >>= 8;
  509.     blue >>= 8;
  510.     palette[regno].red = red;
  511.     palette[regno].green = green;
  512.     palette[regno].blue = blue;
  514. #ifdef FBCON_HAS_CFB32
  515.     fbcon_cfb32_cmap[regno] = (red << 16) | (green << 8) | blue;
  516. #endif
  517.     return 0;
  518. }
  521. static void do_install_cmap(int con, struct fb_info *info)
  522. {
  523.     if (con != currcon)
  524. return;
  525.     if (fb_display[con].cmap.len)
  526. fb_set_cmap(&fb_display[con].cmap, 1, fm2fb_setcolreg, info);
  527.     else
  528. fb_set_cmap(fb_default_cmap(256), 1, fm2fb_setcolreg, info);
  529. }
  531. MODULE_LICENSE("GPL");