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

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

Linux/Unix编程

开发平台：

Unix_Linux

tgafb.c：源码内容
  1. /*
  2.  *  linux/drivers/video/tgafb.c -- DEC 21030 TGA frame buffer device
  3.  *
  4.  * Copyright (C) 1999,2000 Martin Lucina, Tom Zerucha
  5.  *  
  6.  *  $Id: tgafb.c,v 1.12.2.3 2000/04/04 06:44:56 mato Exp $
  7.  *
  8.  *  This driver is partly based on the original TGA framebuffer device, which 
  9.  *  was partly based on the original TGA console driver, which are
  10.  *
  11.  * Copyright (C) 1997 Geert Uytterhoeven
  12.  * Copyright (C) 1995 Jay Estabrook
  13.  *
  14.  *  This file is subject to the terms and conditions of the GNU General Public
  15.  *  License. See the file COPYING in the main directory of this archive for
  16.  *  more details.
  17.  */
  19. /* KNOWN PROBLEMS/TO DO ===================================================== *
  20.  *
  21.  * - How to set a single color register on 24-plane cards?
  22.  *
  23.  * - Hardware cursor/other text acceleration methods
  24.  *
  25.  * - Some redraws can stall kernel for several seconds
  26.  *   [This should now be solved by the fast memmove() patch in 2.3.6]
  27.  *
  28.  * KNOWN PROBLEMS/TO DO ==================================================== */
  30. #include <linux/module.h>
  31. #include <linux/sched.h>
  32. #include <linux/kernel.h>
  33. #include <linux/errno.h>
  34. #include <linux/string.h>
  35. #include <linux/mm.h>
  36. #include <linux/tty.h>
  37. #include <linux/slab.h>
  38. #include <linux/vmalloc.h>
  39. #include <linux/delay.h>
  40. #include <linux/interrupt.h>
  41. #include <linux/fb.h>
  42. #include <linux/init.h>
  43. #include <linux/pci.h>
  44. #include <linux/selection.h>
  45. #include <linux/console.h>
  46. #include <asm/io.h>
  48. #include <video/fbcon.h>
  49. #include <video/fbcon-cfb8.h>
  50. #include <video/fbcon-cfb32.h>
  51. #include "tgafb.h"
  54.     /*
  55.      *  Global declarations
  56.      */
  58. static struct tgafb_info fb_info;
  59. static struct tgafb_par current_par;
  60. static int current_par_valid = 0;
  61. static struct display disp;
  63. static char default_fontname[40] __initdata = { 0 };
  64. static struct fb_var_screeninfo default_var;
  65. static int default_var_valid = 0;
  67. static int currcon = 0;
  69. static struct { u_char red, green, blue, pad; } palette[256];
  70. #ifdef FBCON_HAS_CFB32
  71. static u32 fbcon_cfb32_cmap[16];
  72. #endif
  75.     /*
  76.      *  Hardware presets
  77.      */
  79. static unsigned int fb_offset_presets[4] = {
  80. TGA_8PLANE_FB_OFFSET,
  81. TGA_24PLANE_FB_OFFSET,
  82. 0xffffffff,
  83. TGA_24PLUSZ_FB_OFFSET
  84. };
  86. static unsigned int deep_presets[4] = {
  87.   0x00014000,
  88.   0x0001440d,
  89.   0xffffffff,
  90.   0x0001441d
  91. };
  93. static unsigned int rasterop_presets[4] = {
  94.   0x00000003,
  95.   0x00000303,
  96.   0xffffffff,
  97.   0x00000303
  98. };
  100. static unsigned int mode_presets[4] = {
  101.   0x00002000,
  102.   0x00002300,
  103.   0xffffffff,
  104.   0x00002300
  105. };
  107. static unsigned int base_addr_presets[4] = {
  108.   0x00000000,
  109.   0x00000001,
  110.   0xffffffff,
  111.   0x00000001
  112. };
  115.     /*
  116.      *  Predefined video modes
  117.      *  This is a subset of the standard VESA modes, recalculated from XFree86.
  118.      *
  119.      *  XXX Should we store these in terms of the encoded par structs? Even better,
  120.      *      fbcon should provide a general mechanism for doing something like this.
  121.      */
  123. static struct {
  124.     const char *name;
  125.     struct fb_var_screeninfo var;
  126. } tgafb_predefined[] __initdata = {
  127.     { "640x480-60", {
  128. 640, 480, 640, 480, 0, 0, 0, 0,
  129. {0, 8, 0}, {0, 8, 0}, {0, 8, 0}, {0, 0, 0},
  130. 0, 0, -1, -1, FB_ACCELF_TEXT, 39722, 40, 24, 32, 11, 96, 2,
  131. 0,
  132. FB_VMODE_NONINTERLACED
  133.     }},
  134.     { "800x600-56", {
  135. 800, 600, 800, 600, 0, 0, 0, 0,
  136. {0, 8, 0}, {0, 8, 0}, {0, 8, 0}, {0, 0, 0},
  137. 0, 0, -1, -1, FB_ACCELF_TEXT, 27777, 128, 24, 22, 1, 72, 2,
  138. 0,
  139. FB_VMODE_NONINTERLACED
  140.     }},
  141.     { "640x480-72", {
  142. 640, 480, 640, 480, 0, 0, 0, 0,
  143. {0, 8, 0}, {0, 8, 0}, {0, 8, 0}, {0, 0, 0},
  144. 0, 0, -1, -1, FB_ACCELF_TEXT, 31746, 144, 40, 30, 8, 40, 3,
  145. 0,
  146. FB_VMODE_NONINTERLACED
  147.     }},
  148.     { "800x600-60", {
  149. 800, 600, 800, 600, 0, 0, 0, 0,
  150. {0, 8, 0}, {0, 8, 0}, {0, 8, 0}, {0, 0, 0},
  151. 0, 0, -1, -1, FB_ACCELF_TEXT, 25000, 88, 40, 23, 1, 128, 4,
  152. FB_SYNC_HOR_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT,
  153. FB_VMODE_NONINTERLACED
  154.     }},
  155.     { "800x600-72", {
  156. 800, 600, 800, 600, 0, 0, 0, 0,
  157. {0, 8, 0}, {0, 8, 0}, {0, 8, 0}, {0, 0, 0},
  158. 0, 0, -1, -1, FB_ACCELF_TEXT, 20000, 64, 56, 23, 37, 120, 6,
  159. FB_SYNC_HOR_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT,
  160. FB_VMODE_NONINTERLACED
  161.     }},
  162.     { "1024x768-60", {
  163. 1024, 768, 1024, 768, 0, 0, 0, 0,
  164. {0, 8, 0}, {0, 8, 0}, {0, 8, 0}, {0, 0, 0},
  165. 0, 0, -1, -1, FB_ACCELF_TEXT, 15384, 168, 8, 29, 3, 144, 6,
  166. 0,
  167. FB_VMODE_NONINTERLACED
  168.     }},
  169.     { "1152x864-60", {
  170. 1152, 864, 1152, 864, 0, 0, 0, 0,
  171. {0, 8, 0}, {0, 8, 0}, {0, 8, 0}, {0, 0, 0},
  172. 0, 0, -1, -1, FB_ACCELF_TEXT, 11123, 208, 64, 16, 4, 256, 8,
  173. 0,
  174. FB_VMODE_NONINTERLACED
  175.     }},
  176.     { "1024x768-70", {
  177. 1024, 768, 1024, 768, 0, 0, 0, 0,
  178. {0, 8, 0}, {0, 8, 0}, {0, 8, 0}, {0, 0, 0},
  179. 0, 0, -1, -1, FB_ACCELF_TEXT, 13333, 144, 24, 29, 3, 136, 6,
  180. 0,
  181. FB_VMODE_NONINTERLACED
  182.     }},
  183.     { "1024x768-76", {
  184. 1024, 768, 1024, 768, 0, 0, 0, 0,
  185. {0, 8, 0}, {0, 8, 0}, {0, 8, 0}, {0, 0, 0},
  186. 0, 0, -1, -1, FB_ACCELF_TEXT, 11764, 208, 8, 36, 16, 120, 3,
  187. 0,
  188. FB_VMODE_NONINTERLACED
  189.     }},
  190.     { "1152x864-70", {
  191. 1152, 864, 1152, 864, 0, 0, 0, 0,
  192. {0, 8, 0}, {0, 8, 0}, {0, 8, 0}, {0, 0, 0},
  193. 0, 0, -1, -1, FB_ACCELF_TEXT, 10869, 106, 56, 20, 1, 160, 10,
  194. 0,
  195. FB_VMODE_NONINTERLACED
  196.     }},
  197.     { "1280x1024-61", {
  198. 1280, 1024, 1280, 1024, 0, 0, 0, 0,
  199. {0, 8, 0}, {0, 8, 0}, {0, 8, 0}, {0, 0, 0},
  200. 0, 0, -1, -1, FB_ACCELF_TEXT, 9090, 200, 48, 26, 1, 184, 3,
  201. 0,
  202. FB_VMODE_NONINTERLACED
  203.     }},
  204.     { "1024x768-85", {
  205. 1024, 768, 1024, 768, 0, 0, 0, 0,
  206. {0, 8, 0}, {0, 8, 0}, {0, 8, 0}, {0, 0, 0},
  207. 0, 0, -1, -1, FB_ACCELF_TEXT, 10111, 192, 32, 34, 14, 160, 6,
  208. 0,
  209. FB_VMODE_NONINTERLACED
  210.     }},
  211.     { "1280x1024-70", {
  212. 1280, 1024, 1280, 1024, 0, 0, 0, 0,
  213. {0, 8, 0}, {0, 8, 0}, {0, 8, 0}, {0, 0, 0},
  214. 0, 0, -1, -1, FB_ACCELF_TEXT, 7905, 224, 32, 28, 8, 160, 8,
  215. 0,
  216. FB_VMODE_NONINTERLACED
  217.     }},
  218.     { "1152x864-84", {
  219. 1152, 864, 1152, 864, 0, 0, 0, 0,
  220. {0, 8, 0}, {0, 8, 0}, {0, 8, 0}, {0, 0, 0},
  221. 0, 0, -1, -1, FB_ACCELF_TEXT, 7407, 184, 312, 32, 0, 128, 12,
  222. 0,
  223. FB_VMODE_NONINTERLACED
  224.     }},
  225.     { "1280x1024-76", {
  226. 1280, 1024, 1280, 1024, 0, 0, 0, 0,
  227. {0, 8, 0}, {0, 8, 0}, {0, 8, 0}, {0, 0, 0},
  228. 0, 0, -1, -1, FB_ACCELF_TEXT, 7407, 248, 32, 34, 3, 104, 3,
  229. 0,
  230. FB_VMODE_NONINTERLACED
  231.     }},
  232.     { "1280x1024-85", {
  233. 1280, 1024, 1280, 1024, 0, 0, 0, 0,
  234. {0, 8, 0}, {0, 8, 0}, {0, 8, 0}, {0, 0, 0},
  235. 0, 0, -1, -1, FB_ACCELF_TEXT, 6349, 224, 64, 44, 1, 160, 3,
  236. 0,
  237. FB_VMODE_NONINTERLACED
  238.     }},
  240.     /* These are modes used by the two fixed-frequency monitors I have at home. 
  241.      * You may or may not find these useful.
  242.      */
  244.     { "WYSE1", { /* 1280x1024 @ 72 Hz, 130 Mhz clock */
  245. 1280, 1024, 1280, 1024, 0, 0, 0, 0,
  246. {0, 8, 0}, {0, 8, 0}, {0, 8, 0}, {0, 0, 0},
  247. 0, 0, -1, -1, FB_ACCELF_TEXT, 7692, 192, 32, 47, 0, 192, 5,
  248. FB_SYNC_HOR_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT,
  249. FB_VMODE_NONINTERLACED
  250.     }},
  251.     { "IBM3", { /* 1280x1024 @ 70 Hz, 120 Mhz clock */
  252. 1280, 1024, 1280, 1024, 0, 0, 0, 0,
  253. {0, 8, 0}, {0, 8, 0}, {0, 8, 0}, {0, 0, 0},
  254. 0, 0, -1, -1, FB_ACCELF_TEXT, 8333, 192, 32, 47, 0, 192, 5,
  255. 0,
  256. FB_VMODE_NONINTERLACED
  257.     }}
  258. };
  260. #define NUM_TOTAL_MODES    ARRAY_SIZE(tgafb_predefined)
  263.     /*
  264.      *  Interface used by the world
  265.      */
  267. static void tgafb_detect(void);
  268. static int tgafb_encode_fix(struct fb_fix_screeninfo *fix, const void *fb_par,
  269.         struct fb_info_gen *info);
  270. static int tgafb_decode_var(const struct fb_var_screeninfo *var, void *fb_par,
  271.         struct fb_info_gen *info);
  272. static int tgafb_encode_var(struct fb_var_screeninfo *var, const void *fb_par,
  273.         struct fb_info_gen *info);
  274. static void tgafb_get_par(void *fb_par, struct fb_info_gen *info);
  275. static void tgafb_set_par(const void *fb_par, struct fb_info_gen *info);
  276. static int tgafb_getcolreg(u_int regno, u_int *red, u_int *green, u_int *blue, 
  277. u_int *transp, struct fb_info *info);
  278. static int tgafb_setcolreg(u_int regno, u_int red, u_int green, u_int blue, 
  279. u_int transp, struct fb_info *info);
  280. static int tgafb_blank(int blank, struct fb_info_gen *info);
  281. static void tgafb_set_disp(const void *fb_par, struct display *disp, 
  282. struct fb_info_gen *info);
  284. #ifndef MODULE
  285. int tgafb_setup(char*);
  286. #endif
  288. static void tgafb_set_pll(int f);
  289. #if 1
  290. static int tgafb_set_cmap(struct fb_cmap *cmap, int kspc, int con,
  291.   struct fb_info *info);
  292. static void tgafb_update_palette(void);
  293. #endif
  296.     /*
  297.      *  Chipset specific functions
  298.      */
  301. static void tgafb_detect(void)
  302. {
  303.     return;
  304. }
  307. static int tgafb_encode_fix(struct fb_fix_screeninfo *fix, const void *fb_par,
  308. struct fb_info_gen *info)
  309. {
  310.     struct tgafb_par *par = (struct tgafb_par *)fb_par;
  312.     strcpy(fix->id, fb_info.gen.info.modename);
  314.     fix->type = FB_TYPE_PACKED_PIXELS;
  315.     fix->type_aux = 0;
  316.     if (fb_info.tga_type == TGA_TYPE_8PLANE) {
  317. fix->visual = FB_VISUAL_PSEUDOCOLOR;
  318.     } else {
  319. fix->visual = FB_VISUAL_TRUECOLOR;
  320.     }
  322.     fix->line_length = par->xres * (par->bits_per_pixel >> 3);
  323.     fix->smem_start = fb_info.tga_fb_base;
  324.     fix->smem_len = fix->line_length * par->yres;
  325.     fix->mmio_start = fb_info.tga_regs_base;
  326.     fix->mmio_len = 0x1000; /* Is this sufficient? */
  327.     fix->xpanstep = fix->ypanstep = fix->ywrapstep = 0;
  328.     fix->accel = FB_ACCEL_DEC_TGA;
  330.     return 0;
  331. }
  334. static int tgafb_decode_var(const struct fb_var_screeninfo *var, void *fb_par,
  335. struct fb_info_gen *info)
  336. {
  337.     struct tgafb_par *par = (struct tgafb_par *)fb_par;
  339.     /* round up some */
  340.     if (fb_info.tga_type == TGA_TYPE_8PLANE) {
  341. if (var->bits_per_pixel > 8) {
  342.     return -EINVAL;
  343. }
  344. par->bits_per_pixel = 8;
  345.     } else {
  346. if (var->bits_per_pixel > 32) {
  347.     return -EINVAL;
  348. }
  349. par->bits_per_pixel = 32;
  350.     }
  352.     /* check the values for sanity */
  353.     if (var->xres_virtual != var->xres ||
  354. var->yres_virtual != var->yres ||
  355. var->nonstd || (1000000000/var->pixclock) > TGA_PLL_MAX_FREQ ||
  356. (var->vmode & FB_VMODE_MASK) != FB_VMODE_NONINTERLACED
  357. #if 0 /* fbmon not done.  uncomment for 2.5.x -brad */
  358. || !fbmon_valid_timings(var->pixclock, var->htotal, var->vtotal, info))
  359. #else
  360. )
  361. #endif
  362. return -EINVAL;
  364.     /* encode video timings */
  365.     par->htimings = ((var->xres/4) & TGA_HORIZ_ACT_LSB) | 
  366. (((var->xres/4) & 0x600 << 19) & TGA_HORIZ_ACT_MSB);
  367.     par->vtimings = (var->yres & TGA_VERT_ACTIVE);
  368.     par->htimings |= ((var->right_margin/4) << 9) & TGA_HORIZ_FP;
  369.     par->vtimings |= (var->lower_margin << 11) & TGA_VERT_FP;
  370.     par->htimings |= ((var->hsync_len/4) << 14) & TGA_HORIZ_SYNC;
  371.     par->vtimings |= (var->vsync_len << 16) & TGA_VERT_SYNC;
  372.     par->htimings |= ((var->left_margin/4) << 21) & TGA_HORIZ_BP;
  373.     par->vtimings |= (var->upper_margin << 22) & TGA_VERT_BP;
  375.     if (var->sync & FB_SYNC_HOR_HIGH_ACT)
  376. par->htimings |= TGA_HORIZ_POLARITY;
  377.     if (var->sync & FB_SYNC_VERT_HIGH_ACT)
  378. par->vtimings |= TGA_VERT_POLARITY;
  379.     if (var->sync & FB_SYNC_ON_GREEN) {
  380. par->sync_on_green = 1;
  381.     } else {
  382. par->sync_on_green = 0;
  383.     }
  385.     /* store other useful values in par */
  386.     par->xres = var->xres; 
  387.     par->yres = var->yres;
  388.     par->pll_freq = 1000000000/var->pixclock;
  389.     par->bits_per_pixel = var->bits_per_pixel;
  391.     return 0;
  392. }
  395. static int tgafb_encode_var(struct fb_var_screeninfo *var, const void *fb_par,
  396. struct fb_info_gen *info)
  397. {
  398.     struct tgafb_par *par = (struct tgafb_par *)fb_par;
  400.     /* decode video timings */
  401.     var->xres = ((par->htimings & TGA_HORIZ_ACT_LSB) | ((par->htimings & TGA_HORIZ_ACT_MSB) >> 19)) * 4;
  402.     var->yres = (par->vtimings & TGA_VERT_ACTIVE);
  403.     var->right_margin = ((par->htimings & TGA_HORIZ_FP) >> 9) * 4;
  404.     var->lower_margin = ((par->vtimings & TGA_VERT_FP) >> 11);
  405.     var->hsync_len = ((par->htimings & TGA_HORIZ_SYNC) >> 14) * 4;
  406.     var->vsync_len = ((par->vtimings & TGA_VERT_SYNC) >> 16);
  407.     var->left_margin = ((par->htimings & TGA_HORIZ_BP) >> 21) * 4;
  408.     var->upper_margin = ((par->vtimings & TGA_VERT_BP) >> 22);
  410.     if (par->htimings & TGA_HORIZ_POLARITY) 
  411.      var->sync |= FB_SYNC_HOR_HIGH_ACT;
  412.     if (par->vtimings & TGA_VERT_POLARITY)
  413.      var->sync |= FB_SYNC_VERT_HIGH_ACT;
  414.     if (par->sync_on_green == 1)
  415. var->sync |= FB_SYNC_ON_GREEN;
  417.     var->xres_virtual = var->xres;
  418.     var->yres_virtual = var->yres;
  419.     var->xoffset = var->yoffset = 0;
  421.     /* depth-related */
  422.     if (fb_info.tga_type == TGA_TYPE_8PLANE) {
  423. var->red.offset = 0;
  424. var->green.offset = 0;
  425. var->blue.offset = 0;
  426.     } else {
  427. var->red.offset = 16;
  428. var->green.offset = 8;
  429. var->blue.offset = 0;
  430.     }
  431.     var->bits_per_pixel = par->bits_per_pixel;
  432.     var->grayscale = 0;
  433.     var->red.length = var->green.length = var->blue.length = 8;
  434.     var->red.msb_right = var->green.msb_right = var->blue.msb_right = 0;
  435.     var->transp.offset = var->transp.length = var->transp.msb_right = 0;
  437.     /* others */
  438.     var->xoffset = var->yoffset = 0;
  439.     var->pixclock = 1000000000/par->pll_freq;
  440.     var->nonstd = 0;
  441.     var->activate = 0;
  442.     var->height = var->width = -1;
  443.     var->accel_flags = 0;
  445.     return 0;
  446. }
  449. static void tgafb_get_par(void *fb_par, struct fb_info_gen *info)
  450. {
  451.     struct tgafb_par *par = (struct tgafb_par *)fb_par;
  453.     if (current_par_valid)
  454. *par = current_par;
  455.     else {
  456. if (fb_info.tga_type == TGA_TYPE_8PLANE)
  457.     default_var.bits_per_pixel = 8;
  458. else
  459.     default_var.bits_per_pixel = 32;
  461. tgafb_decode_var(&default_var, par, info);
  462.     }
  463. }
  466. static void tgafb_set_par(const void *fb_par, struct fb_info_gen *info)
  467. {
  468.     int i, j;
  469.     struct tgafb_par *par = (struct tgafb_par *)fb_par;
  471. #if 0
  472.     /* XXX this will break console switching with X11, maybe I need to test KD_GRAPHICS? */
  473.     /* if current_par is valid, check to see if we need to change anything */
  474.     if (current_par_valid) {
  475. if (!memcmp(par, &current_par, sizeof current_par)) {
  476.     return;
  477. }
  478.     }
  479. #endif
  480.     current_par = *par;
  481.     current_par_valid = 1;
  483.     /* first, disable video */
  484.     TGA_WRITE_REG(TGA_VALID_VIDEO | TGA_VALID_BLANK, TGA_VALID_REG);
  485.     
  486.     /* write the DEEP register */
  487.     while (TGA_READ_REG(TGA_CMD_STAT_REG) & 1) /* wait for not busy */
  488.       continue;
  490.     mb();
  491.     TGA_WRITE_REG(deep_presets[fb_info.tga_type], TGA_DEEP_REG);
  492.     while (TGA_READ_REG(TGA_CMD_STAT_REG) & 1) /* wait for not busy */
  493. continue;
  494.     mb();
  496.     /* write some more registers */
  497.     TGA_WRITE_REG(rasterop_presets[fb_info.tga_type], TGA_RASTEROP_REG);
  498.     TGA_WRITE_REG(mode_presets[fb_info.tga_type], TGA_MODE_REG);
  499.     TGA_WRITE_REG(base_addr_presets[fb_info.tga_type], TGA_BASE_ADDR_REG);
  501.     /* calculate & write the PLL */
  502.     tgafb_set_pll(par->pll_freq);
  504.     /* write some more registers */
  505.     TGA_WRITE_REG(0xffffffff, TGA_PLANEMASK_REG);
  506.     TGA_WRITE_REG(0xffffffff, TGA_PIXELMASK_REG);
  507.     TGA_WRITE_REG(0x12345678, TGA_BLOCK_COLOR0_REG);
  508.     TGA_WRITE_REG(0x12345678, TGA_BLOCK_COLOR1_REG);
  510.     /* init video timing regs */
  511.     TGA_WRITE_REG(par->htimings, TGA_HORIZ_REG);
  512.     TGA_WRITE_REG(par->vtimings, TGA_VERT_REG);
  514.     /* initalise RAMDAC */
  515.     if (fb_info.tga_type == TGA_TYPE_8PLANE) { 
  517. /* init BT485 RAMDAC registers */
  518. BT485_WRITE(0xa2 | (par->sync_on_green ? 0x8 : 0x0), BT485_CMD_0);
  519. BT485_WRITE(0x01, BT485_ADDR_PAL_WRITE);
  520. BT485_WRITE(0x14, BT485_CMD_3); /* cursor 64x64 */
  521. BT485_WRITE(0x40, BT485_CMD_1);
  522. BT485_WRITE(0x20, BT485_CMD_2); /* cursor off, for now */
  523. BT485_WRITE(0xff, BT485_PIXEL_MASK);
  525. /* fill palette registers */
  526. BT485_WRITE(0x00, BT485_ADDR_PAL_WRITE);
  527. TGA_WRITE_REG(BT485_DATA_PAL, TGA_RAMDAC_SETUP_REG);
  529. for (i = 0; i < 16; i++) {
  530.     j = color_table[i];
  531.     TGA_WRITE_REG(default_red[j]|(BT485_DATA_PAL<<8), TGA_RAMDAC_REG);
  532.     TGA_WRITE_REG(default_grn[j]|(BT485_DATA_PAL<<8), TGA_RAMDAC_REG);
  533.     TGA_WRITE_REG(default_blu[j]|(BT485_DATA_PAL<<8), TGA_RAMDAC_REG);
  534.     palette[i].red=default_red[j];
  535.     palette[i].green=default_grn[j];
  536.     palette[i].blue=default_blu[j];
  537. }
  538. for (i = 0; i < 240*3; i += 4) {
  539.     TGA_WRITE_REG(0x55|(BT485_DATA_PAL<<8), TGA_RAMDAC_REG);
  540.     TGA_WRITE_REG(0x00|(BT485_DATA_PAL<<8), TGA_RAMDAC_REG);
  541.     TGA_WRITE_REG(0x00|(BT485_DATA_PAL<<8), TGA_RAMDAC_REG);
  542.     TGA_WRITE_REG(0x00|(BT485_DATA_PAL<<8), TGA_RAMDAC_REG);
  543. }   
  545.     } else { /* 24-plane or 24plusZ */
  547. /* init BT463 registers */
  548. BT463_WRITE(BT463_REG_ACC, BT463_CMD_REG_0, 0x40);
  549. BT463_WRITE(BT463_REG_ACC, BT463_CMD_REG_1, 0x08);
  550. BT463_WRITE(BT463_REG_ACC, BT463_CMD_REG_2, 
  551. (par->sync_on_green ? 0x80 : 0x40));
  553. BT463_WRITE(BT463_REG_ACC, BT463_READ_MASK_0, 0xff);
  554. BT463_WRITE(BT463_REG_ACC, BT463_READ_MASK_1, 0xff);
  555. BT463_WRITE(BT463_REG_ACC, BT463_READ_MASK_2, 0xff);
  556. BT463_WRITE(BT463_REG_ACC, BT463_READ_MASK_3, 0x0f);
  558. BT463_WRITE(BT463_REG_ACC, BT463_BLINK_MASK_0, 0x00);
  559. BT463_WRITE(BT463_REG_ACC, BT463_BLINK_MASK_1, 0x00);
  560. BT463_WRITE(BT463_REG_ACC, BT463_BLINK_MASK_2, 0x00);
  561. BT463_WRITE(BT463_REG_ACC, BT463_BLINK_MASK_3, 0x00);
  563. /* fill the palette */
  564. BT463_LOAD_ADDR(0x0000);
  565. TGA_WRITE_REG((BT463_PALETTE<<2), TGA_RAMDAC_REG);
  567. for (i = 0; i < 16; i++) {
  568.     j = color_table[i];
  569.     TGA_WRITE_REG(default_red[j]|(BT463_PALETTE<<10), TGA_RAMDAC_REG);
  570.     TGA_WRITE_REG(default_grn[j]|(BT463_PALETTE<<10), TGA_RAMDAC_REG);
  571.     TGA_WRITE_REG(default_blu[j]|(BT463_PALETTE<<10), TGA_RAMDAC_REG);
  572. }
  573. for (i = 0; i < 512*3; i += 4) {
  574.     TGA_WRITE_REG(0x55|(BT463_PALETTE<<10), TGA_RAMDAC_REG);
  575.     TGA_WRITE_REG(0x00|(BT463_PALETTE<<10), TGA_RAMDAC_REG);
  576.     TGA_WRITE_REG(0x00|(BT463_PALETTE<<10), TGA_RAMDAC_REG);
  577.     TGA_WRITE_REG(0x00|(BT463_PALETTE<<10), TGA_RAMDAC_REG);
  578. }   
  580. /* fill window type table after start of vertical retrace */
  581. while (!(TGA_READ_REG(TGA_INTR_STAT_REG) & 0x01))
  582.     continue;
  583. TGA_WRITE_REG(0x01, TGA_INTR_STAT_REG);
  584. mb();
  585. while (!(TGA_READ_REG(TGA_INTR_STAT_REG) & 0x01))
  586.     continue;
  587. TGA_WRITE_REG(0x01, TGA_INTR_STAT_REG);
  589. BT463_LOAD_ADDR(BT463_WINDOW_TYPE_BASE);
  590. TGA_WRITE_REG((BT463_REG_ACC<<2), TGA_RAMDAC_SETUP_REG);
  592. for (i = 0; i < 16; i++) {
  593.     TGA_WRITE_REG(0x00|(BT463_REG_ACC<<10), TGA_RAMDAC_REG);
  594.     TGA_WRITE_REG(0x01|(BT463_REG_ACC<<10), TGA_RAMDAC_REG);
  595.     TGA_WRITE_REG(0x80|(BT463_REG_ACC<<10), TGA_RAMDAC_REG);
  596. }
  597.    
  598.     }
  600.     /* finally, enable video scan
  601. (and pray for the monitor... :-) */
  602.     TGA_WRITE_REG(TGA_VALID_VIDEO, TGA_VALID_REG);
  603. }
  606. #define DIFFCHECK(x) { if( m <= 0x3f ) { 
  607.       int delta = f - (TGA_PLL_BASE_FREQ * (x)) / (r << shift); 
  608.       if (delta < 0) delta = -delta; 
  609.       if (delta < min_diff) min_diff = delta, vm = m, va = a, vr = r; } }
  611. static void tgafb_set_pll(int f)
  612. {
  613.     int                 n, shift, base, min_diff, target;
  614.     int                 r,a,m,vm = 34, va = 1, vr = 30;
  616.     for( r = 0 ; r < 12 ; r++ )
  617. TGA_WRITE_REG(!r, TGA_CLOCK_REG);
  619.     if (f > TGA_PLL_MAX_FREQ)
  620. f = TGA_PLL_MAX_FREQ;
  622.     if (f >= TGA_PLL_MAX_FREQ / 2)
  623. shift = 0;
  624.     else if (f >= TGA_PLL_MAX_FREQ / 4)
  625. shift = 1;
  626.     else
  627. shift = 2;
  629.     TGA_WRITE_REG(shift & 1, TGA_CLOCK_REG);
  630.     TGA_WRITE_REG(shift >> 1, TGA_CLOCK_REG);
  632.     for( r = 0 ; r < 10 ; r++ ) {
  633. TGA_WRITE_REG(0, TGA_CLOCK_REG);
  634.     }
  636.     if (f <= 120000) {
  637. TGA_WRITE_REG(0, TGA_CLOCK_REG);
  638. TGA_WRITE_REG(0, TGA_CLOCK_REG);
  639.     }
  640.     else if (f <= 200000) {
  641. TGA_WRITE_REG(1, TGA_CLOCK_REG);
  642. TGA_WRITE_REG(0, TGA_CLOCK_REG);
  643.     }
  644.     else {
  645. TGA_WRITE_REG(0, TGA_CLOCK_REG);
  646. TGA_WRITE_REG(1, TGA_CLOCK_REG);
  647.     }
  649.     TGA_WRITE_REG(1, TGA_CLOCK_REG);
  650.     TGA_WRITE_REG(0, TGA_CLOCK_REG);
  651.     TGA_WRITE_REG(0, TGA_CLOCK_REG);
  652.     TGA_WRITE_REG(1, TGA_CLOCK_REG);
  653.     TGA_WRITE_REG(0, TGA_CLOCK_REG);
  654.     TGA_WRITE_REG(1, TGA_CLOCK_REG);
  656.     target = (f << shift) / TGA_PLL_BASE_FREQ;
  657.     min_diff = TGA_PLL_MAX_FREQ;
  659.     r = 7 / target;
  660.     if (!r)
  661. r = 1;
  663.     base = target * r;
  664.     while (base < 449) {
  665. for (n = base < 7 ? 7 : base ; n < base + target && n < 449; n++) {
  666. m = ((n + 3) / 7) - 1;
  667. a = 0;
  668. DIFFCHECK((m + 1) * 7);
  669. m++;
  670. DIFFCHECK((m + 1) * 7);
  671. m = (n / 6) - 1;
  672. if( (a = n % 6))
  673.     DIFFCHECK( n );
  674. }
  675. r++;
  676. base += target;
  677.     }
  679.     vr--;
  681.     for( r=0; r<8 ; r++) {
  682. TGA_WRITE_REG((vm >> r) & 1, TGA_CLOCK_REG);
  683.     }
  684.     for( r=0; r<8 ; r++) {
  685. TGA_WRITE_REG((va >> r) & 1, TGA_CLOCK_REG);
  686.     }
  687.     for( r=0; r<7 ; r++) {
  688. TGA_WRITE_REG((vr >> r) & 1, TGA_CLOCK_REG);
  689.     }
  690.     TGA_WRITE_REG(((vr >> 7) & 1)|2, TGA_CLOCK_REG);
  691. }
  694. static int tgafb_getcolreg(u_int regno, u_int *red, u_int *green, u_int *blue,
  695.                          u_int *transp, struct fb_info *info)
  696. {
  697.     if (regno > 255)
  698. return 1;
  699.     *red = (palette[regno].red<<8) | palette[regno].red;
  700.     *green = (palette[regno].green<<8) | palette[regno].green;
  701.     *blue = (palette[regno].blue<<8) | palette[regno].blue;
  702.     *transp = 0;
  703.     return 0;
  704. }
  707. static int tgafb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
  708.                          u_int transp, struct fb_info *info)
  709. {
  710.     if (regno > 255)
  711. return 1;
  712.     red >>= 8;
  713.     green >>= 8;
  714.     blue >>= 8;
  715.     palette[regno].red = red;
  716.     palette[regno].green = green;
  717.     palette[regno].blue = blue;
  719. #ifdef FBCON_HAS_CFB32
  720.     if (regno < 16 && fb_info.tga_type != TGA_TYPE_8PLANE)
  721. fbcon_cfb32_cmap[regno] = (red << 16) | (green << 8) | blue;
  722. #endif
  724.     if (fb_info.tga_type == TGA_TYPE_8PLANE) { 
  725.         BT485_WRITE(regno, BT485_ADDR_PAL_WRITE);
  726.         TGA_WRITE_REG(BT485_DATA_PAL, TGA_RAMDAC_SETUP_REG);
  727.         TGA_WRITE_REG(red|(BT485_DATA_PAL<<8),TGA_RAMDAC_REG);
  728.         TGA_WRITE_REG(green|(BT485_DATA_PAL<<8),TGA_RAMDAC_REG);
  729.         TGA_WRITE_REG(blue|(BT485_DATA_PAL<<8),TGA_RAMDAC_REG);
  730.     }                                                    
  731.     /* How to set a single color register on 24-plane cards?? */
  733.     return 0;
  734. }
  736. #if 1
  737.     /*
  738.      * FIXME: since I don't know how to set a single arbitrary color register
  739.      *  on 24-plane cards, all color palette registers have to be updated
  740.      */
  742. static int tgafb_set_cmap(struct fb_cmap *cmap, int kspc, int con,
  743.   struct fb_info *info)
  744. {
  745.     int err;
  747.     if (!fb_display[con].cmap.len) { /* no colormap allocated? */
  748. if ((err = fb_alloc_cmap(&fb_display[con].cmap, 256, 0)))
  749.     return err;
  750.     }
  751.     if (con == currcon) { /* current console? */
  752. err = fb_set_cmap(cmap, kspc, tgafb_setcolreg, info);
  753. #if 1
  754. if (fb_info.tga_type != TGA_TYPE_8PLANE)
  755. tgafb_update_palette();
  756. #endif
  757. return err;
  758.     } else
  759. fb_copy_cmap(cmap, &fb_display[con].cmap, kspc ? 0 : 1);
  760.     return 0;
  761. }
  763. static void tgafb_update_palette(void)
  764. {
  765.     int i;
  767.     BT463_LOAD_ADDR(0x0000);
  768.     TGA_WRITE_REG((BT463_PALETTE<<2), TGA_RAMDAC_REG);
  770.     for (i = 0; i < 256; i++) {
  771.  TGA_WRITE_REG(palette[i].red|(BT463_PALETTE<<10), TGA_RAMDAC_REG);
  772.  TGA_WRITE_REG(palette[i].green|(BT463_PALETTE<<10), TGA_RAMDAC_REG);
  773.  TGA_WRITE_REG(palette[i].blue|(BT463_PALETTE<<10), TGA_RAMDAC_REG);
  774.     }
  775. }
  776. #endif
  779. static int tgafb_blank(int blank, struct fb_info_gen *info)
  780. {
  781.     static int tga_vesa_blanked = 0;
  782.     u32 vhcr, vvcr, vvvr;
  783.     unsigned long flags;
  784.     
  785.     save_flags(flags);
  786.     cli();
  788.     vhcr = TGA_READ_REG(TGA_HORIZ_REG);
  789.     vvcr = TGA_READ_REG(TGA_VERT_REG);
  790.     vvvr = TGA_READ_REG(TGA_VALID_REG) & ~(TGA_VALID_VIDEO | TGA_VALID_BLANK);
  792.     switch (blank) {
  793.     case 0: /* Unblanking */
  794.         if (tga_vesa_blanked) {
  795.    TGA_WRITE_REG(vhcr & 0xbfffffff, TGA_HORIZ_REG);
  796.    TGA_WRITE_REG(vvcr & 0xbfffffff, TGA_VERT_REG);
  797.    tga_vesa_blanked = 0;
  798. }
  799.   TGA_WRITE_REG(vvvr | TGA_VALID_VIDEO, TGA_VALID_REG);
  800. break;
  802.     case 1: /* Normal blanking */
  803. TGA_WRITE_REG(vvvr | TGA_VALID_VIDEO | TGA_VALID_BLANK, TGA_VALID_REG);
  804. break;
  806.     case 2: /* VESA blank (vsync off) */
  807. TGA_WRITE_REG(vvcr | 0x40000000, TGA_VERT_REG);
  808. TGA_WRITE_REG(vvvr | TGA_VALID_BLANK, TGA_VALID_REG);
  809. tga_vesa_blanked = 1;
  810. break;
  812.     case 3: /* VESA blank (hsync off) */
  813. TGA_WRITE_REG(vhcr | 0x40000000, TGA_HORIZ_REG);
  814. TGA_WRITE_REG(vvvr | TGA_VALID_BLANK, TGA_VALID_REG);
  815. tga_vesa_blanked = 1;
  816. break;
  818.     case 4: /* Poweroff */
  819. TGA_WRITE_REG(vhcr | 0x40000000, TGA_HORIZ_REG);
  820. TGA_WRITE_REG(vvcr | 0x40000000, TGA_VERT_REG);
  821. TGA_WRITE_REG(vvvr | TGA_VALID_BLANK, TGA_VALID_REG);
  822. tga_vesa_blanked = 1;
  823. break;
  824.     }
  826.     restore_flags(flags);
  827.     return 0;
  828. }
  831. static void tgafb_set_disp(const void *fb_par, struct display *disp,
  832. struct fb_info_gen *info)
  833. {
  834.     disp->screen_base = (char *)fb_info.tga_fb_base;
  835.     switch (fb_info.tga_type) {
  836. #ifdef FBCON_HAS_CFB8
  837. case TGA_TYPE_8PLANE:
  838.     disp->dispsw = &fbcon_cfb8;
  839.             break;
  840. #endif
  841. #ifdef FBCON_HAS_CFB32
  842.         case TGA_TYPE_24PLANE:
  843.         case TGA_TYPE_24PLUSZ:
  844.     disp->dispsw = &fbcon_cfb32; 
  845.             disp->dispsw_data = &fbcon_cfb32_cmap;
  846.             break;
  847. #endif
  848.         default:
  849.             disp->dispsw = &fbcon_dummy;
  850.     }
  852.     disp->scrollmode = SCROLL_YREDRAW;
  853. }
  856. struct fbgen_hwswitch tgafb_hwswitch = {
  857.     tgafb_detect, tgafb_encode_fix, tgafb_decode_var, tgafb_encode_var, tgafb_get_par,
  858.     tgafb_set_par, tgafb_getcolreg, tgafb_setcolreg, NULL, tgafb_blank, 
  859.     tgafb_set_disp
  860. };
  863.     /*
  864.      *  Hardware Independent functions
  865.      */
  868.     /* 
  869.      *  Frame buffer operations
  870.      */
  872. static struct fb_ops tgafb_ops = {
  873. owner: THIS_MODULE,
  874. fb_get_fix: fbgen_get_fix,
  875. fb_get_var: fbgen_get_var,
  876. fb_set_var: fbgen_set_var,
  877. fb_get_cmap: fbgen_get_cmap,
  878. fb_set_cmap: tgafb_set_cmap,
  879. };
  882. #ifndef MODULE
  883.     /*
  884.      *  Setup
  885.      */
  887. int __init tgafb_setup(char *options) {
  888.     char *this_opt;
  889.     int i;
  890.     
  891.     if (options && *options) {
  892.      while ((this_opt = strsep(&options, ",")) != NULL) {
  893.             if (!*this_opt) { continue; }
  894.         
  895.     if (!strncmp(this_opt, "font:", 5)) {
  896.       strncpy(default_fontname, this_opt+5, sizeof default_fontname);
  897.     }
  899.     else if (!strncmp(this_opt, "mode:", 5)) {
  900.      for (i = 0; i < NUM_TOTAL_MODES; i++) {
  901.          if (!strcmp(this_opt+5, tgafb_predefined[i].name))
  902.      default_var = tgafb_predefined[i].var;
  903.      default_var_valid = 1;
  904.      }
  905.          } 
  906.     
  907.     else {
  908.        printk(KERN_ERR "tgafb: unknown parameter %sn", this_opt);
  909.          }
  910.        }
  911.     }
  912.     return 0;
  913. }
  914. #endif
  917.     /*
  918.      *  Initialisation
  919.      */
  921. int __init tgafb_init(void)
  922. {
  923.     struct pci_dev *pdev;
  925.     pdev = pci_find_device(PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_TGA, NULL);
  926.     if (!pdev)
  927. return -ENXIO;
  929.     /* divine board type */
  931.     fb_info.tga_mem_base = (unsigned long)ioremap(pdev->resource[0].start, 0);
  932.     fb_info.tga_type = (readl(fb_info.tga_mem_base) >> 12) & 0x0f;
  933.     fb_info.tga_regs_base = fb_info.tga_mem_base + TGA_REGS_OFFSET;
  934.     fb_info.tga_fb_base = (fb_info.tga_mem_base
  935.    + fb_offset_presets[fb_info.tga_type]);
  936.     pci_read_config_byte(pdev, PCI_REVISION_ID, &fb_info.tga_chip_rev);
  938.     /* setup framebuffer */
  940.     fb_info.gen.info.node = -1;
  941.     fb_info.gen.info.flags = FBINFO_FLAG_DEFAULT;
  942.     fb_info.gen.info.fbops = &tgafb_ops;
  943.     fb_info.gen.info.disp = &disp;
  944.     fb_info.gen.info.changevar = NULL;
  945.     fb_info.gen.info.switch_con = &fbgen_switch;
  946.     fb_info.gen.info.updatevar = &fbgen_update_var;
  947.     fb_info.gen.info.blank = &fbgen_blank;
  948.     strcpy(fb_info.gen.info.fontname, default_fontname);
  949.     fb_info.gen.parsize = sizeof (struct tgafb_par);
  950.     fb_info.gen.fbhw = &tgafb_hwswitch;
  951.     fb_info.gen.fbhw->detect();
  953.     printk (KERN_INFO "tgafb: DC21030 [TGA] detected, rev=0x%02xn", fb_info.tga_chip_rev);
  954.     printk (KERN_INFO "tgafb: at PCI bus %d, device %d, function %dn", 
  955.     pdev->bus->number, PCI_SLOT(pdev->devfn), PCI_FUNC(pdev->devfn));
  956.     
  957.     switch (fb_info.tga_type) 
  958.     { 
  959. case TGA_TYPE_8PLANE:
  960.     strcpy (fb_info.gen.info.modename,"Digital ZLXp-E1"); 
  961.     break;
  963. case TGA_TYPE_24PLANE:
  964.     strcpy (fb_info.gen.info.modename,"Digital ZLXp-E2"); 
  965.     break;
  967. case TGA_TYPE_24PLUSZ:
  968.     strcpy (fb_info.gen.info.modename,"Digital ZLXp-E3"); 
  969.     break;
  970.     }
  972.     /* This should give a reasonable default video mode */
  974.     if (!default_var_valid) {
  975. default_var = tgafb_predefined[0].var;
  976.     }
  977.     fbgen_get_var(&disp.var, -1, &fb_info.gen.info);
  978.     disp.var.activate = FB_ACTIVATE_NOW;
  979.     fbgen_do_set_var(&disp.var, 1, &fb_info.gen);
  980.     fbgen_set_disp(-1, &fb_info.gen);
  981.     fbgen_install_cmap(0, &fb_info.gen);
  982.     if (register_framebuffer(&fb_info.gen.info) < 0)
  983. return -EINVAL;
  984.     printk(KERN_INFO "fb%d: %s frame buffer device at 0x%lxn", 
  985.     GET_FB_IDX(fb_info.gen.info.node), fb_info.gen.info.modename, 
  986.     pdev->resource[0].start);
  987.     return 0;
  988. }
  991.     /*
  992.      *  Cleanup
  993.      */
  995. void __exit tgafb_cleanup(void)
  996. {
  997.     unregister_framebuffer(&fb_info.gen.info);
  998. }
  1001.     /*
  1002.      *  Modularisation
  1003.      */
  1005. #ifdef MODULE
  1006. MODULE_LICENSE("GPL");
  1007. module_init(tgafb_init);
  1008. #endif
  1010. module_exit(tgafb_cleanup);