retz3fb.c
上传用户:lgb322
上传日期:2013-02-24
资源大小:30529k
文件大小:40k
源码类别:

嵌入式Linux

开发平台:

Unix_Linux

  1. /*
  2.  * Linux/drivers/video/retz3fb.c -- RetinaZ3 frame buffer device
  3.  *
  4.  *    Copyright (C) 1997 Jes Sorensen
  5.  *
  6.  * This file is based on the CyberVision64 frame buffer device and
  7.  * the generic Cirrus Logic driver.
  8.  *
  9.  * cyberfb.c: Copyright (C) 1996 Martin Apel,
  10.  *                               Geert Uytterhoeven
  11.  * clgen.c:   Copyright (C) 1996 Frank Neumann
  12.  *
  13.  * History:
  14.  *   - 22 Jan 97: Initial work
  15.  *   - 14 Feb 97: Screen initialization works somewhat, still only
  16.  *                8-bit packed pixel is supported.
  17.  *
  18.  * This file is subject to the terms and conditions of the GNU General Public
  19.  * License.  See the file COPYING in the main directory of this archive
  20.  * for more details.
  21.  */
  22. #include <linux/module.h>
  23. #include <linux/kernel.h>
  24. #include <linux/errno.h>
  25. #include <linux/string.h>
  26. #include <linux/mm.h>
  27. #include <linux/tty.h>
  28. #include <linux/slab.h>
  29. #include <linux/delay.h>
  30. #include <linux/fb.h>
  31. #include <linux/zorro.h>
  32. #include <linux/init.h>
  33. #include <asm/uaccess.h>
  34. #include <asm/system.h>
  35. #include <asm/irq.h>
  36. #include <asm/pgtable.h>
  37. #include <asm/io.h>
  38. #include <video/fbcon.h>
  39. #include <video/fbcon-cfb8.h>
  40. #include <video/fbcon-cfb16.h>
  41. #include "retz3fb.h"
  42. /* #define DEBUG if(1) */
  43. #define DEBUG if(0)
  44. /*
  45.  * Reserve space for one pattern line.
  46.  *
  47.  * For the time being we only support 4MB boards!
  48.  */
  49. #define PAT_MEM_SIZE 16*3
  50. #define PAT_MEM_OFF  (4*1024*1024 - PAT_MEM_SIZE)
  51. struct retz3fb_par {
  52. int xres;
  53. int yres;
  54. int xres_vir;
  55. int yres_vir;
  56. int xoffset;
  57. int yoffset;
  58. int bpp;
  59. struct fb_bitfield red;
  60. struct fb_bitfield green;
  61. struct fb_bitfield blue;
  62. struct fb_bitfield transp;
  63. int pixclock;
  64. int left_margin; /* time from sync to picture */
  65. int right_margin; /* time from picture to sync */
  66. int upper_margin; /* time from sync to picture */
  67. int lower_margin;
  68. int hsync_len; /* length of horizontal sync */
  69. int vsync_len; /* length of vertical sync */
  70. int vmode;
  71. int accel;
  72. };
  73. struct display_data {
  74. long h_total; /* Horizontal Total */
  75. long h_sstart; /* Horizontal Sync Start */
  76. long h_sstop; /* Horizontal Sync Stop */
  77. long h_bstart; /* Horizontal Blank Start */
  78. long h_bstop; /* Horizontal Blank Stop */
  79. long h_dispend; /* Horizontal Display End */
  80. long v_total; /* Vertical Total */
  81. long v_sstart; /* Vertical Sync Start */
  82. long v_sstop; /* Vertical Sync Stop */
  83. long v_bstart; /* Vertical Blank Start */
  84. long v_bstop; /* Vertical Blank Stop */
  85. long v_dispend; /* Horizontal Display End */
  86. };
  87. struct retz3_fb_info {
  88. struct fb_info info;
  89. unsigned char *base;
  90. unsigned char *fbmem;
  91. unsigned long fbsize;
  92. volatile unsigned char *regs;
  93. unsigned long physfbmem;
  94. unsigned long physregs;
  95. int currcon;
  96. int current_par_valid; /* set to 0 by memset */
  97. int blitbusy;
  98. struct display disp;
  99. struct retz3fb_par current_par;
  100. unsigned char color_table [256][3];
  101. };
  102. static char fontname[40] __initdata = { 0 };
  103. #define retz3info(info) ((struct retz3_fb_info *)(info))
  104. #define fbinfo(info) ((struct fb_info *)(info))
  105. /*
  106.  *    Frame Buffer Name
  107.  */
  108. static char retz3fb_name[16] = "RetinaZ3";
  109. /*
  110.  * A small info on how to convert XFree86 timing values into fb
  111.  * timings - by Frank Neumann:
  112.  *
  113. An XFree86 mode line consists of the following fields:
  114.  "800x600"     50      800  856  976 1040    600  637  643  666
  115.  < name >     DCF       HR  SH1  SH2  HFL     VR  SV1  SV2  VFL
  116. The fields in the fb_var_screeninfo structure are:
  117.         unsigned long pixclock;         * pixel clock in ps (pico seconds) *
  118.         unsigned long left_margin;      * time from sync to picture    *
  119.         unsigned long right_margin;     * time from picture to sync    *
  120.         unsigned long upper_margin;     * time from sync to picture    *
  121.         unsigned long lower_margin;
  122.         unsigned long hsync_len;        * length of horizontal sync    *
  123.         unsigned long vsync_len;        * length of vertical sync      *
  124. 1) Pixelclock:
  125.    xfree: in MHz
  126.    fb: In Picoseconds (ps)
  127.    pixclock = 1000000 / DCF
  128. 2) horizontal timings:
  129.    left_margin = HFL - SH2
  130.    right_margin = SH1 - HR
  131.    hsync_len = SH2 - SH1
  132. 3) vertical timings:
  133.    upper_margin = VFL - SV2
  134.    lower_margin = SV1 - VR
  135.    vsync_len = SV2 - SV1
  136. Good examples for VESA timings can be found in the XFree86 source tree,
  137. under "programs/Xserver/hw/xfree86/doc/modeDB.txt".
  138. */
  139. /*
  140.  *    Predefined Video Modes
  141.  */
  142. static struct {
  143.     const char *name;
  144.     struct fb_var_screeninfo var;
  145. } retz3fb_predefined[] __initdata = {
  146.     /*
  147.      * NB: it is very important to adjust the pixel-clock to the color-depth.
  148.      */
  149.     {
  150. "640x480", { /* 640x480, 8 bpp */
  151.     640, 480, 640, 480, 0, 0, 8, 0,
  152.     {0, 8, 0}, {0, 8, 0}, {0, 8, 0}, {0, 0, 0},
  153.     0, 0, -1, -1, FB_ACCEL_NONE, 39722, 48, 16, 33, 10, 96, 2,
  154.     FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,FB_VMODE_NONINTERLACED
  155. }
  156.     },
  157.     /*
  158.      ModeLine "800x600" 36 800 824 896 1024 600 601 603 625
  159.       < name > DCF HR  SH1 SH2  HFL VR  SV1 SV2 VFL
  160.      */
  161.     {
  162. "800x600", { /* 800x600, 8 bpp */
  163.     800, 600, 800, 600, 0, 0, 8, 0,
  164.     {0, 8, 0}, {0, 8, 0}, {0, 8, 0}, {0, 0, 0},
  165.     0, 0, -1, -1, FB_ACCELF_TEXT, 27778, 64, 24, 22, 1, 120, 2,
  166.     FB_SYNC_COMP_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED
  167. }
  168.     },
  169.     {
  170. "800x600-60", { /* 800x600, 8 bpp */
  171.     800, 600, 800, 600, 0, 0, 8, 0,
  172.     {0, 8, 0}, {0, 8, 0}, {0, 8, 0}, {0, 0, 0},
  173.     0, 0, -1, -1, FB_ACCELF_TEXT, 25000, 88, 40, 23, 1, 128, 4,
  174.     FB_SYNC_COMP_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED
  175. }
  176.     },
  177.     {
  178. "800x600-70", { /* 800x600, 8 bpp */
  179.     800, 600, 800, 600, 0, 0, 8, 0,
  180.     {0, 8, 0}, {0, 8, 0}, {0, 8, 0}, {0, 0, 0},
  181.     0, 0, -1, -1, FB_ACCELF_TEXT, 22272, 40, 24, 15, 9, 144, 12,
  182.     FB_SYNC_COMP_HIGH_ACT, FB_VMODE_NONINTERLACED
  183. }
  184.     },
  185.     /*
  186.       ModeLine "1024x768i" 45 1024 1064 1224 1264 768 777 785 817 interlace
  187.        < name >   DCF HR  SH1  SH2  HFL  VR  SV1 SV2 VFL
  188.      */
  189.     {
  190. "1024x768i", { /* 1024x768, 8 bpp, interlaced */
  191.     1024, 768, 1024, 768, 0, 0, 8, 0,
  192.     {0, 8, 0}, {0, 8, 0}, {0, 8, 0}, {0, 0, 0},
  193.     0, 0, -1, -1, FB_ACCELF_TEXT, 22222, 40, 40, 32, 9, 160, 8,
  194.     FB_SYNC_COMP_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT, FB_VMODE_INTERLACED
  195. }
  196.     },
  197.     {
  198. "1024x768", {
  199.     1024, 768, 1024, 768, 0, 0, 8, 0, 
  200.     {0, 8, 0}, {0, 8, 0}, {0, 8, 0}, {0, 0, 0}, 
  201.     0, 0, -1, -1, FB_ACCEL_NONE, 12500, 92, 112, 31, 2, 204, 4,
  202.     FB_SYNC_HOR_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT, FB_VMODE_NONINTERLACED
  203.  }
  204.     },
  205.     {
  206. "640x480-16", { /* 640x480, 16 bpp */
  207.     640, 480, 640, 480, 0, 0, 16, 0,
  208.     {11, 5, 0}, {5, 6, 0}, {0, 5, 0}, {0, 0, 0},
  209.     0, 0, -1, -1, 0, 38461/2, 28, 32, 12, 10, 96, 2,
  210.     FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,FB_VMODE_NONINTERLACED
  211. }
  212.     },
  213.     {
  214. "640x480-24", { /* 640x480, 24 bpp */
  215.     640, 480, 640, 480, 0, 0, 24, 0,
  216.     {8, 8, 8}, {8, 8, 8}, {8, 8, 8}, {0, 0, 0},
  217.     0, 0, -1, -1, 0, 38461/3, 28, 32, 12, 10, 96, 2,
  218.     FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,FB_VMODE_NONINTERLACED
  219. }
  220.     },
  221. };
  222. #define NUM_TOTAL_MODES    ARRAY_SIZE(retz3fb_predefined)
  223. static struct fb_var_screeninfo retz3fb_default;
  224. static int z3fb_inverse = 0;
  225. static int z3fb_mode __initdata = 0;
  226. /*
  227.  *    Interface used by the world
  228.  */
  229. int retz3fb_setup(char *options);
  230. static int retz3fb_get_fix(struct fb_fix_screeninfo *fix, int con,
  231.    struct fb_info *info);
  232. static int retz3fb_get_var(struct fb_var_screeninfo *var, int con,
  233.    struct fb_info *info);
  234. static int retz3fb_set_var(struct fb_var_screeninfo *var, int con,
  235.    struct fb_info *info);
  236. static int retz3fb_get_cmap(struct fb_cmap *cmap, int kspc, int con,
  237.     struct fb_info *info);
  238. static int retz3fb_set_cmap(struct fb_cmap *cmap, int kspc, int con,
  239.     struct fb_info *info);
  240. /*
  241.  *    Interface to the low level console driver
  242.  */
  243. int retz3fb_init(void);
  244. static int z3fb_switch(int con, struct fb_info *info);
  245. static int z3fb_updatevar(int con, struct fb_info *info);
  246. static void z3fb_blank(int blank, struct fb_info *info);
  247. /*
  248.  *    Text console acceleration
  249.  */
  250. #ifdef FBCON_HAS_CFB8
  251. static struct display_switch fbcon_retz3_8;
  252. #endif
  253. /*
  254.  *    Accelerated Functions used by the low level console driver
  255.  */
  256. static void retz3_bitblt(struct display *p,
  257.  unsigned short curx, unsigned short cury, unsigned
  258.  short destx, unsigned short desty, unsigned short
  259.  width, unsigned short height, unsigned short cmd,
  260.  unsigned short mask);
  261. /*
  262.  *   Hardware Specific Routines
  263.  */
  264. static int retz3_encode_fix(struct fb_info *info,
  265.     struct fb_fix_screeninfo *fix,
  266.     struct retz3fb_par *par);
  267. static int retz3_decode_var(struct fb_var_screeninfo *var,
  268.     struct retz3fb_par *par);
  269. static int retz3_encode_var(struct fb_var_screeninfo *var,
  270.     struct retz3fb_par *par);
  271. static int retz3_getcolreg(unsigned int regno, unsigned int *red,
  272.    unsigned int *green, unsigned int *blue,
  273.    unsigned int *transp, struct fb_info *info);
  274. static int retz3_setcolreg(unsigned int regno, unsigned int red,
  275.    unsigned int green, unsigned int blue,
  276.    unsigned int transp, struct fb_info *info);
  277. /*
  278.  *    Internal routines
  279.  */
  280. static void retz3fb_get_par(struct fb_info *info, struct retz3fb_par *par);
  281. static void retz3fb_set_par(struct fb_info *info, struct retz3fb_par *par);
  282. static int do_fb_set_var(struct fb_info *info,
  283.  struct fb_var_screeninfo *var, int isactive);
  284. static void do_install_cmap(int con, struct fb_info *info);
  285. static void retz3fb_set_disp(int con, struct fb_info *info);
  286. static int get_video_mode(const char *name);
  287. /* -------------------- Hardware specific routines ------------------------- */
  288. static unsigned short find_fq(unsigned int freq)
  289. {
  290. unsigned long f;
  291. long tmp;
  292. long prev = 0x7fffffff;
  293. long n2, n1 = 3;
  294. unsigned long m;
  295. unsigned short res = 0;
  296. if (freq <= 31250000)
  297. n2 = 3;
  298. else if (freq <= 62500000)
  299. n2 = 2;
  300. else if (freq <= 125000000)
  301. n2 = 1;
  302. else if (freq <= 250000000)
  303. n2 = 0;
  304. else
  305. return 0;
  306. do {
  307. f = freq >> (10 - n2);
  308. m = (f * n1) / (14318180/1024);
  309. if (m > 129)
  310. break;
  311. tmp =  (((m * 14318180) >> n2) / n1) - freq;
  312. if (tmp < 0)
  313. tmp = -tmp;
  314. if (tmp < prev) {
  315. prev = tmp;
  316. res = (((n2 << 5) | (n1-2)) << 8) | (m-2);
  317. }
  318. } while ( (++n1) <= 21);
  319. return res;
  320. }
  321. static int retz3_set_video(struct fb_info *info,
  322.    struct fb_var_screeninfo *var,
  323.    struct retz3fb_par *par)
  324. {
  325. volatile unsigned char *regs = retz3info(info)->regs;
  326. unsigned int freq;
  327. int xres, hfront, hsync, hback;
  328. int yres, vfront, vsync, vback;
  329. unsigned char tmp;
  330. unsigned short best_freq;
  331. struct display_data data;
  332. short clocksel = 0; /* Apparantly this is always zero */
  333. int bpp = var->bits_per_pixel;
  334. /*
  335.  * XXX
  336.  */
  337. if (bpp == 24)
  338. return 0;
  339. if ((bpp != 8) && (bpp != 16) && (bpp != 24))
  340. return -EFAULT;
  341. par->xoffset = 0;
  342. par->yoffset = 0;
  343. xres   = var->xres * bpp / 4;
  344. hfront = var->right_margin * bpp / 4;
  345. hsync  = var->hsync_len * bpp / 4;
  346. hback  = var->left_margin * bpp / 4;
  347. if (var->vmode & FB_VMODE_DOUBLE)
  348. {
  349. yres = var->yres * 2;
  350. vfront = var->lower_margin * 2;
  351. vsync  = var->vsync_len * 2;
  352. vback  = var->upper_margin * 2;
  353. }
  354. else if (var->vmode & FB_VMODE_INTERLACED)
  355. {
  356. yres   = (var->yres + 1) / 2;
  357. vfront = (var->lower_margin + 1) / 2;
  358. vsync  = (var->vsync_len + 1) / 2;
  359. vback  = (var->upper_margin + 1) / 2;
  360. }
  361. else
  362. {
  363. yres   = var->yres; /* -1 ? */
  364. vfront = var->lower_margin;
  365. vsync  = var->vsync_len;
  366. vback  = var->upper_margin;
  367. }
  368. data.h_total = (hback / 8) + (xres / 8)
  369. + (hfront / 8) + (hsync / 8) - 1 /* + 1 */;
  370. data.h_dispend = ((xres + bpp - 1)/ 8) - 1;
  371. data.h_bstart = xres / 8 - 1 /* + 1 */;
  372. data.h_bstop = data.h_total+1 + 2 + 1;
  373. data.h_sstart = (xres / 8) + (hfront / 8) + 1;
  374. data.h_sstop = (xres / 8) + (hfront / 8) + (hsync / 8) + 1;
  375. data.v_total = yres + vfront + vsync + vback - 1;
  376. data.v_dispend = yres - 1;
  377. data.v_bstart = yres - 1;
  378. data.v_bstop = data.v_total;
  379. data.v_sstart = yres + vfront - 1 - 2;
  380. data.v_sstop = yres + vfront + vsync - 1;
  381. #if 0 /* testing */
  382. printk("HBS: %in", data.h_bstart);
  383. printk("HSS: %in", data.h_sstart);
  384. printk("HSE: %in", data.h_sstop);
  385. printk("HBE: %in", data.h_bstop);
  386. printk("HT: %in", data.h_total);
  387. printk("hsync: %in", hsync);
  388. printk("hfront: %in", hfront);
  389. printk("hback: %in", hback);
  390. printk("VBS: %in", data.v_bstart);
  391. printk("VSS: %in", data.v_sstart);
  392. printk("VSE: %in", data.v_sstop);
  393. printk("VBE: %in", data.v_bstop);
  394. printk("VT: %in", data.v_total);
  395. printk("vsync: %in", vsync);
  396. printk("vfront: %in", vfront);
  397. printk("vback: %in", vback);
  398. #endif
  399. if (data.v_total >= 1024)
  400. printk(KERN_ERR "MAYDAY: v_total >= 1024; bailing out!n");
  401. reg_w(regs, GREG_MISC_OUTPUT_W, 0xe3 | ((clocksel & 3) * 0x04));
  402. reg_w(regs, GREG_FEATURE_CONTROL_W, 0x00);
  403. seq_w(regs, SEQ_RESET, 0x00);
  404. seq_w(regs, SEQ_RESET, 0x03); /* reset sequencer logic */
  405. /*
  406.  * CLOCKING_MODE bits:
  407.  * 2: This one is only set for certain text-modes, wonder if
  408.  *    it may be for EGA-lines? (it was referred to as CLKDIV2)
  409.  * (The CL drivers sets it to 0x21 with the comment:
  410.  *  FullBandwidth (video off) and 8/9 dot clock)
  411.  */
  412. seq_w(regs, SEQ_CLOCKING_MODE, 0x01 | 0x00 /* 0x08 */);
  413. seq_w(regs, SEQ_MAP_MASK, 0x0f);        /* enable writing to plane 0-3 */
  414. seq_w(regs, SEQ_CHAR_MAP_SELECT, 0x00); /* doesn't matter in gfx-mode */
  415. seq_w(regs, SEQ_MEMORY_MODE, 0x06); /* CL driver says 0x0e for 256 col mode*/
  416. seq_w(regs, SEQ_RESET, 0x01);
  417. seq_w(regs, SEQ_RESET, 0x03);
  418. seq_w(regs, SEQ_EXTENDED_ENABLE, 0x05);
  419. seq_w(regs, SEQ_CURSOR_CONTROL, 0x00); /* disable cursor */
  420. seq_w(regs, SEQ_PRIM_HOST_OFF_HI, 0x00);
  421. seq_w(regs, SEQ_PRIM_HOST_OFF_HI, 0x00);
  422. seq_w(regs, SEQ_LINEAR_0, 0x4a);
  423. seq_w(regs, SEQ_LINEAR_1, 0x00);
  424. seq_w(regs, SEQ_SEC_HOST_OFF_HI, 0x00);
  425. seq_w(regs, SEQ_SEC_HOST_OFF_LO, 0x00);
  426. seq_w(regs, SEQ_EXTENDED_MEM_ENA, 0x3 | 0x4 | 0x10 | 0x40);
  427. /*
  428.  * The lower 4 bits (0-3) are used to set the font-width for
  429.  * text-mode - DON'T try to set this for gfx-mode.
  430.  */
  431. seq_w(regs, SEQ_EXT_CLOCK_MODE, 0x10);
  432. seq_w(regs, SEQ_EXT_VIDEO_ADDR, 0x03);
  433. /*
  434.  * Extended Pixel Control:
  435.  * bit 0:   text-mode=0, gfx-mode=1 (Graphics Byte ?)
  436.  * bit 1: (Packed/Nibble Pixel Format ?)
  437.  * bit 4-5: depth, 0=1-8bpp, 1=9-16bpp, 2=17-24bpp
  438.  */
  439. seq_w(regs, SEQ_EXT_PIXEL_CNTL, 0x01 | (((bpp / 8) - 1) << 4));
  440. seq_w(regs, SEQ_BUS_WIDTH_FEEDB, 0x04);
  441. seq_w(regs, SEQ_COLOR_EXP_WFG, 0x01);
  442. seq_w(regs, SEQ_COLOR_EXP_WBG, 0x00);
  443. seq_w(regs, SEQ_EXT_RW_CONTROL, 0x00);
  444. seq_w(regs, SEQ_MISC_FEATURE_SEL, (0x51 | (clocksel & 8)));
  445. seq_w(regs, SEQ_COLOR_KEY_CNTL, 0x40);
  446. seq_w(regs, SEQ_COLOR_KEY_MATCH0, 0x00);
  447. seq_w(regs, SEQ_COLOR_KEY_MATCH1, 0x00);
  448. seq_w(regs, SEQ_COLOR_KEY_MATCH2, 0x00);
  449. seq_w(regs, SEQ_CRC_CONTROL, 0x00);
  450. seq_w(regs, SEQ_PERF_SELECT, 0x10);
  451. seq_w(regs, SEQ_ACM_APERTURE_1, 0x00);
  452. seq_w(regs, SEQ_ACM_APERTURE_2, 0x30);
  453. seq_w(regs, SEQ_ACM_APERTURE_3, 0x00);
  454. seq_w(regs, SEQ_MEMORY_MAP_CNTL, 0x03);
  455. /* unlock register CRT0..CRT7 */
  456. crt_w(regs, CRT_END_VER_RETR, (data.v_sstop & 0x0f) | 0x20);
  457. /* Zuerst zu schreibende Werte nur per printk ausgeben */
  458. DEBUG printk("CRT_HOR_TOTAL: %ldn", data.h_total);
  459. crt_w(regs, CRT_HOR_TOTAL, data.h_total & 0xff);
  460. DEBUG printk("CRT_HOR_DISP_ENA_END: %ldn", data.h_dispend);
  461. crt_w(regs, CRT_HOR_DISP_ENA_END, (data.h_dispend) & 0xff);
  462. DEBUG printk("CRT_START_HOR_BLANK: %ldn", data.h_bstart);
  463. crt_w(regs, CRT_START_HOR_BLANK, data.h_bstart & 0xff);
  464. DEBUG printk("CRT_END_HOR_BLANK: 128+%ldn", data.h_bstop % 32);
  465. crt_w(regs, CRT_END_HOR_BLANK,  0x80 | (data.h_bstop & 0x1f));
  466. DEBUG printk("CRT_START_HOR_RETR: %ldn", data.h_sstart);
  467. crt_w(regs, CRT_START_HOR_RETR, data.h_sstart & 0xff);
  468. tmp = (data.h_sstop & 0x1f);
  469. if (data.h_bstop & 0x20)
  470. tmp |= 0x80;
  471. DEBUG printk("CRT_END_HOR_RETR: %dn", tmp);
  472. crt_w(regs, CRT_END_HOR_RETR, tmp);
  473. DEBUG printk("CRT_VER_TOTAL: %ldn", data.v_total & 0xff);
  474. crt_w(regs, CRT_VER_TOTAL, (data.v_total & 0xff));
  475. tmp = 0x10;  /* LineCompare bit #9 */
  476. if (data.v_total & 256)
  477. tmp |= 0x01;
  478. if (data.v_dispend & 256)
  479. tmp |= 0x02;
  480. if (data.v_sstart & 256)
  481. tmp |= 0x04;
  482. if (data.v_bstart & 256)
  483. tmp |= 0x08;
  484. if (data.v_total & 512)
  485. tmp |= 0x20;
  486. if (data.v_dispend & 512)
  487. tmp |= 0x40;
  488. if (data.v_sstart & 512)
  489. tmp |= 0x80;
  490. DEBUG printk("CRT_OVERFLOW: %dn", tmp);
  491. crt_w(regs, CRT_OVERFLOW, tmp);
  492. crt_w(regs, CRT_PRESET_ROW_SCAN, 0x00); /* not CL !!! */
  493. tmp = 0x40; /* LineCompare bit #8 */
  494. if (data.v_bstart & 512)
  495. tmp |= 0x20;
  496. if (var->vmode & FB_VMODE_DOUBLE)
  497. tmp |= 0x80;
  498.   DEBUG printk("CRT_MAX_SCAN_LINE: %dn", tmp);
  499. crt_w(regs, CRT_MAX_SCAN_LINE, tmp);
  500. crt_w(regs, CRT_CURSOR_START, 0x00);
  501. crt_w(regs, CRT_CURSOR_END, 8 & 0x1f); /* font height */
  502. crt_w(regs, CRT_START_ADDR_HIGH, 0x00);
  503. crt_w(regs, CRT_START_ADDR_LOW, 0x00);
  504. crt_w(regs, CRT_CURSOR_LOC_HIGH, 0x00);
  505. crt_w(regs, CRT_CURSOR_LOC_LOW, 0x00);
  506.   DEBUG printk("CRT_START_VER_RETR: %ldn", data.v_sstart & 0xff);
  507. crt_w(regs, CRT_START_VER_RETR, (data.v_sstart & 0xff));
  508. #if 1
  509. /* 5 refresh cycles per scanline */
  510. DEBUG printk("CRT_END_VER_RETR: 64+32+%ldn", data.v_sstop % 16);
  511. crt_w(regs, CRT_END_VER_RETR, ((data.v_sstop & 0x0f) | 0x40 | 0x20));
  512. #else
  513. DEBUG printk("CRT_END_VER_RETR: 128+32+%ldn", data.v_sstop % 16);
  514. crt_w(regs, CRT_END_VER_RETR, ((data.v_sstop & 0x0f) | 128 | 32));
  515. #endif
  516. DEBUG printk("CRT_VER_DISP_ENA_END: %ldn", data.v_dispend & 0xff);
  517. crt_w(regs, CRT_VER_DISP_ENA_END, (data.v_dispend & 0xff));
  518. DEBUG printk("CRT_START_VER_BLANK: %ldn", data.v_bstart & 0xff);
  519. crt_w(regs, CRT_START_VER_BLANK, (data.v_bstart & 0xff));
  520. DEBUG printk("CRT_END_VER_BLANK: %ldn", data.v_bstop & 0xff);
  521. crt_w(regs, CRT_END_VER_BLANK, (data.v_bstop & 0xff));
  522. DEBUG printk("CRT_MODE_CONTROL: 0xe3n");
  523. crt_w(regs, CRT_MODE_CONTROL, 0xe3);
  524. DEBUG printk("CRT_LINE_COMPARE: 0xffn");
  525. crt_w(regs, CRT_LINE_COMPARE, 0xff);
  526. tmp = (var->xres_virtual / 8) * (bpp / 8);
  527. crt_w(regs, CRT_OFFSET, tmp);
  528. crt_w(regs, CRT_UNDERLINE_LOC, 0x07); /* probably font-height - 1 */
  529. tmp = 0x20; /* Enable extended end bits */
  530. if (data.h_total & 0x100)
  531. tmp |= 0x01;
  532. if ((data.h_dispend) & 0x100)
  533. tmp |= 0x02;
  534. if (data.h_bstart & 0x100)
  535. tmp |= 0x04;
  536. if (data.h_sstart & 0x100)
  537. tmp |= 0x08;
  538. if (var->vmode & FB_VMODE_INTERLACED)
  539. tmp |= 0x10;
  540.   DEBUG printk("CRT_EXT_HOR_TIMING1: %dn", tmp);
  541. crt_w(regs, CRT_EXT_HOR_TIMING1, tmp);
  542. tmp = 0x00;
  543. if (((var->xres_virtual / 8) * (bpp / 8)) & 0x100)
  544. tmp |= 0x10;
  545. crt_w(regs, CRT_EXT_START_ADDR, tmp);
  546. tmp = 0x00;
  547. if (data.h_total & 0x200)
  548. tmp |= 0x01;
  549. if ((data.h_dispend) & 0x200)
  550. tmp |= 0x02;
  551. if (data.h_bstart & 0x200)
  552. tmp |= 0x04;
  553. if (data.h_sstart & 0x200)
  554. tmp |= 0x08;
  555. tmp |= ((data.h_bstop & 0xc0) >> 2);
  556. tmp |= ((data.h_sstop & 0x60) << 1);
  557. crt_w(regs, CRT_EXT_HOR_TIMING2, tmp);
  558.   DEBUG printk("CRT_EXT_HOR_TIMING2: %dn", tmp);
  559. tmp = 0x10; /* Line compare bit 10 */
  560. if (data.v_total & 0x400)
  561. tmp |= 0x01;
  562. if ((data.v_dispend) & 0x400)
  563. tmp |= 0x02;
  564. if (data.v_bstart & 0x400)
  565. tmp |= 0x04;
  566. if (data.v_sstart & 0x400)
  567. tmp |= 0x08;
  568. tmp |= ((data.v_bstop & 0x300) >> 3);
  569. if (data.v_sstop & 0x10)
  570. tmp |= 0x80;
  571. crt_w(regs, CRT_EXT_VER_TIMING, tmp);
  572.   DEBUG printk("CRT_EXT_VER_TIMING: %dn", tmp);
  573. crt_w(regs, CRT_MONITOR_POWER, 0x00);
  574. /*
  575.  * Convert from ps to Hz.
  576.  */
  577. freq = 2000000000 / var->pixclock;
  578. freq = freq * 500;
  579. best_freq = find_fq(freq);
  580. pll_w(regs, 0x02, best_freq);
  581. best_freq = find_fq(61000000);
  582. pll_w(regs, 0x0a, best_freq);
  583. pll_w(regs, 0x0e, 0x22);
  584. gfx_w(regs, GFX_SET_RESET, 0x00);
  585. gfx_w(regs, GFX_ENABLE_SET_RESET, 0x00);
  586. gfx_w(regs, GFX_COLOR_COMPARE, 0x00);
  587. gfx_w(regs, GFX_DATA_ROTATE, 0x00);
  588. gfx_w(regs, GFX_READ_MAP_SELECT, 0x00);
  589. gfx_w(regs, GFX_GRAPHICS_MODE, 0x00);
  590. gfx_w(regs, GFX_MISC, 0x05);
  591. gfx_w(regs, GFX_COLOR_XCARE, 0x0f);
  592. gfx_w(regs, GFX_BITMASK, 0xff);
  593. reg_r(regs, ACT_ADDRESS_RESET);
  594. attr_w(regs, ACT_PALETTE0 , 0x00);
  595. attr_w(regs, ACT_PALETTE1 , 0x01);
  596. attr_w(regs, ACT_PALETTE2 , 0x02);
  597. attr_w(regs, ACT_PALETTE3 , 0x03);
  598. attr_w(regs, ACT_PALETTE4 , 0x04);
  599. attr_w(regs, ACT_PALETTE5 , 0x05);
  600. attr_w(regs, ACT_PALETTE6 , 0x06);
  601. attr_w(regs, ACT_PALETTE7 , 0x07);
  602. attr_w(regs, ACT_PALETTE8 , 0x08);
  603. attr_w(regs, ACT_PALETTE9 , 0x09);
  604. attr_w(regs, ACT_PALETTE10, 0x0a);
  605. attr_w(regs, ACT_PALETTE11, 0x0b);
  606. attr_w(regs, ACT_PALETTE12, 0x0c);
  607. attr_w(regs, ACT_PALETTE13, 0x0d);
  608. attr_w(regs, ACT_PALETTE14, 0x0e);
  609. attr_w(regs, ACT_PALETTE15, 0x0f);
  610. reg_r(regs, ACT_ADDRESS_RESET);
  611. attr_w(regs, ACT_ATTR_MODE_CNTL, 0x09); /* 0x01 for CL */
  612. attr_w(regs, ACT_OVERSCAN_COLOR, 0x00);
  613. attr_w(regs, ACT_COLOR_PLANE_ENA, 0x0f);
  614. attr_w(regs, ACT_HOR_PEL_PANNING, 0x00);
  615. attr_w(regs, ACT_COLOR_SELECT, 0x00);
  616. reg_r(regs, ACT_ADDRESS_RESET);
  617. reg_w(regs, ACT_DATA, 0x20);
  618. reg_w(regs, VDAC_MASK, 0xff);
  619. /*
  620.  * Extended palette addressing ???
  621.  */
  622. switch (bpp){
  623. case 8:
  624. reg_w(regs, 0x83c6, 0x00);
  625. break;
  626. case 16:
  627. reg_w(regs, 0x83c6, 0x60);
  628. break;
  629. case 24:
  630. reg_w(regs, 0x83c6, 0xe0);
  631. break;
  632. default:
  633. printk(KERN_INFO "Illegal color-depth: %in", bpp);
  634. }
  635. reg_w(regs, VDAC_ADDRESS, 0x00);
  636. seq_w(regs, SEQ_MAP_MASK, 0x0f );
  637. return 0;
  638. }
  639. /*
  640.  *    This function should fill in the `fix' structure based on the
  641.  *    values in the `par' structure.
  642.  */
  643. static int retz3_encode_fix(struct fb_info *info,
  644.     struct fb_fix_screeninfo *fix,
  645.     struct retz3fb_par *par)
  646. {
  647. struct retz3_fb_info *zinfo = retz3info(info);
  648. memset(fix, 0, sizeof(struct fb_fix_screeninfo));
  649. strcpy(fix->id, retz3fb_name);
  650. fix->smem_start = zinfo->physfbmem;
  651. fix->smem_len = zinfo->fbsize;
  652. fix->mmio_start = zinfo->physregs;
  653. fix->mmio_len = 0x00c00000;
  654. fix->type = FB_TYPE_PACKED_PIXELS;
  655. fix->type_aux = 0;
  656. if (par->bpp == 8)
  657. fix->visual = FB_VISUAL_PSEUDOCOLOR;
  658. else
  659. fix->visual = FB_VISUAL_TRUECOLOR;
  660. fix->xpanstep = 0;
  661. fix->ypanstep = 0;
  662. fix->ywrapstep = 0;
  663. fix->line_length = 0;
  664. fix->accel = FB_ACCEL_NCR_77C32BLT;
  665. return 0;
  666. }
  667. /*
  668.  *    Get the video params out of `var'. If a value doesn't fit, round
  669.  *    it up, if it's too big, return -EINVAL.
  670.  */
  671. static int retz3_decode_var(struct fb_var_screeninfo *var,
  672.     struct retz3fb_par *par)
  673. {
  674. par->xres = var->xres;
  675. par->yres = var->yres;
  676. par->xres_vir = var->xres_virtual;
  677. par->yres_vir = var->yres_virtual;
  678. par->bpp = var->bits_per_pixel;
  679. par->pixclock = var->pixclock;
  680. par->vmode = var->vmode;
  681. par->red = var->red;
  682. par->green = var->green;
  683. par->blue = var->blue;
  684. par->transp = var->transp;
  685. par->left_margin = var->left_margin;
  686. par->right_margin = var->right_margin;
  687. par->upper_margin = var->upper_margin;
  688. par->lower_margin = var->lower_margin;
  689. par->hsync_len = var->hsync_len;
  690. par->vsync_len = var->vsync_len;
  691. if (var->accel_flags & FB_ACCELF_TEXT)
  692.     par->accel = FB_ACCELF_TEXT;
  693. else
  694.     par->accel = 0;
  695. return 0;
  696. }
  697. /*
  698.  *    Fill the `var' structure based on the values in `par' and maybe
  699.  *    other values read out of the hardware.
  700.  */
  701. static int retz3_encode_var(struct fb_var_screeninfo *var,
  702.     struct retz3fb_par *par)
  703. {
  704. memset(var, 0, sizeof(struct fb_var_screeninfo));
  705. var->xres = par->xres;
  706. var->yres = par->yres;
  707. var->xres_virtual = par->xres_vir;
  708. var->yres_virtual = par->yres_vir;
  709. var->xoffset = 0;
  710. var->yoffset = 0;
  711. var->bits_per_pixel = par->bpp;
  712. var->grayscale = 0;
  713. var->red = par->red;
  714. var->green = par->green;
  715. var->blue = par->blue;
  716. var->transp = par->transp;
  717. var->nonstd = 0;
  718. var->activate = 0;
  719. var->height = -1;
  720. var->width = -1;
  721. var->accel_flags = (par->accel && par->bpp == 8) ? FB_ACCELF_TEXT : 0;
  722. var->pixclock = par->pixclock;
  723. var->sync = 0; /* ??? */
  724. var->left_margin = par->left_margin;
  725. var->right_margin = par->right_margin;
  726. var->upper_margin = par->upper_margin;
  727. var->lower_margin = par->lower_margin;
  728. var->hsync_len = par->hsync_len;
  729. var->vsync_len = par->vsync_len;
  730. var->vmode = par->vmode;
  731. return 0;
  732. }
  733. /*
  734.  *    Set a single color register. Return != 0 for invalid regno.
  735.  */
  736. static int retz3_setcolreg(unsigned int regno, unsigned int red,
  737.    unsigned int green, unsigned int blue,
  738.    unsigned int transp, struct fb_info *info)
  739. {
  740. struct retz3_fb_info *zinfo = retz3info(info);
  741. volatile unsigned char *regs = zinfo->regs;
  742. /* We'll get to this */
  743. if (regno > 255)
  744. return 1;
  745. red >>= 10;
  746. green >>= 10;
  747. blue >>= 10;
  748. zinfo->color_table[regno][0] = red;
  749. zinfo->color_table[regno][1] = green;
  750. zinfo->color_table[regno][2] = blue;
  751. reg_w(regs, VDAC_ADDRESS_W, regno);
  752. reg_w(regs, VDAC_DATA, red);
  753. reg_w(regs, VDAC_DATA, green);
  754. reg_w(regs, VDAC_DATA, blue);
  755. return 0;
  756. }
  757. /*
  758.  *    Read a single color register and split it into
  759.  *    colors/transparent. Return != 0 for invalid regno.
  760.  */
  761. static int retz3_getcolreg(unsigned int regno, unsigned int *red,
  762.    unsigned int *green, unsigned int *blue,
  763.    unsigned int *transp, struct fb_info *info)
  764. {
  765. struct retz3_fb_info *zinfo = retz3info(info);
  766. int t;
  767. if (regno > 255)
  768. return 1;
  769. t       = zinfo->color_table[regno][0];
  770. *red    = (t<<10) | (t<<4) | (t>>2);
  771. t       = zinfo->color_table[regno][1];
  772. *green  = (t<<10) | (t<<4) | (t>>2);
  773. t       = zinfo->color_table[regno][2];
  774. *blue   = (t<<10) | (t<<4) | (t>>2);
  775. *transp = 0;
  776. return 0;
  777. }
  778. static inline void retz3_busy(struct display *p)
  779. {
  780. struct retz3_fb_info *zinfo = retz3info(p->fb_info);
  781. volatile unsigned char *acm = zinfo->base + ACM_OFFSET;
  782. unsigned char blt_status;
  783. if (zinfo->blitbusy) {
  784. do{
  785. blt_status = *((acm) + (ACM_START_STATUS + 2));
  786. }while ((blt_status & 1) == 0);
  787. zinfo->blitbusy = 0;
  788. }
  789. }
  790. static void retz3_bitblt (struct display *p,
  791.   unsigned short srcx, unsigned short srcy,
  792.   unsigned short destx, unsigned short desty,
  793.   unsigned short width, unsigned short height,
  794.   unsigned short cmd, unsigned short mask)
  795. {
  796. struct fb_var_screeninfo *var = &p->var;
  797. struct retz3_fb_info *zinfo = retz3info(p->fb_info);
  798. volatile unsigned long *acm = (unsigned long *)(zinfo->base + ACM_OFFSET);
  799. unsigned long *pattern = (unsigned long *)(zinfo->fbmem + PAT_MEM_OFF);
  800. unsigned short mod;
  801. unsigned long tmp;
  802. unsigned long pat, src, dst;
  803. int i, xres_virtual = var->xres_virtual;
  804. short bpp = (var->bits_per_pixel & 0xff);
  805. if (bpp < 8)
  806. bpp = 8;
  807. tmp = mask | (mask << 16);
  808. retz3_busy(p);
  809. i = 0;
  810. do{
  811. *pattern++ = tmp;
  812. }while(i++ < bpp/4);
  813. tmp = cmd << 8;
  814. *(acm + ACM_RASTEROP_ROTATION/4) = tmp;
  815. mod = 0xc0c2;
  816. pat = 8 * PAT_MEM_OFF;
  817. dst = bpp * (destx + desty * xres_virtual);
  818. /*
  819.  * Source is not set for clear.
  820.  */
  821. if ((cmd != Z3BLTclear) && (cmd != Z3BLTset)) {
  822. src = bpp * (srcx + srcy * xres_virtual);
  823. if (destx > srcx) {
  824. mod &= ~0x8000;
  825. src += bpp * (width - 1);
  826. dst += bpp * (width - 1);
  827. pat += bpp * 2;
  828. }
  829. if (desty > srcy) {
  830. mod &= ~0x4000;
  831. src += bpp * (height - 1) * xres_virtual;
  832. dst += bpp * (height - 1) * xres_virtual;
  833. pat += bpp * 4;
  834. }
  835. *(acm + ACM_SOURCE/4) = cpu_to_le32(src);
  836. }
  837. *(acm + ACM_PATTERN/4) = cpu_to_le32(pat);
  838. *(acm + ACM_DESTINATION/4) = cpu_to_le32(dst);
  839. tmp = mod << 16;
  840. *(acm + ACM_CONTROL/4) = tmp;
  841. tmp  = width | (height << 16);
  842. *(acm + ACM_BITMAP_DIMENSION/4) = cpu_to_le32(tmp);
  843. *(((volatile unsigned char *)acm) + ACM_START_STATUS) = 0x00;
  844. *(((volatile unsigned char *)acm) + ACM_START_STATUS) = 0x01;
  845. zinfo->blitbusy = 1;
  846. }
  847. #if 0
  848. /*
  849.  * Move cursor to x, y
  850.  */
  851. static void retz3_MoveCursor (unsigned short x, unsigned short y)
  852. {
  853. /* Guess we gotta deal with the cursor at some point */
  854. }
  855. #endif
  856. /*
  857.  *    Fill the hardware's `par' structure.
  858.  */
  859. static void retz3fb_get_par(struct fb_info *info, struct retz3fb_par *par)
  860. {
  861. struct retz3_fb_info *zinfo = retz3info(info);
  862. if (zinfo->current_par_valid)
  863. *par = zinfo->current_par;
  864. else
  865. retz3_decode_var(&retz3fb_default, par);
  866. }
  867. static void retz3fb_set_par(struct fb_info *info, struct retz3fb_par *par)
  868. {
  869. struct retz3_fb_info *zinfo = retz3info(info);
  870. zinfo->current_par = *par;
  871. zinfo->current_par_valid = 1;
  872. }
  873. static int do_fb_set_var(struct fb_info *info,
  874.  struct fb_var_screeninfo *var, int isactive)
  875. {
  876. int err, activate;
  877. struct retz3fb_par par;
  878. struct retz3_fb_info *zinfo = retz3info(info);
  879. if ((err = retz3_decode_var(var, &par)))
  880. return err;
  881. activate = var->activate;
  882. /* XXX ... what to do about isactive ? */
  883. if ((var->activate & FB_ACTIVATE_MASK) == FB_ACTIVATE_NOW && isactive)
  884. retz3fb_set_par(info, &par);
  885. retz3_encode_var(var, &par);
  886. var->activate = activate;
  887. retz3_set_video(info, var, &zinfo->current_par);
  888. return 0;
  889. }
  890. static void do_install_cmap(int con, struct fb_info *info)
  891. {
  892. struct retz3_fb_info *zinfo = retz3info(info);
  893. if (con != zinfo->currcon)
  894. return;
  895. if (fb_display[con].cmap.len)
  896. fb_set_cmap(&fb_display[con].cmap, 1, retz3_setcolreg, info);
  897. else
  898. fb_set_cmap(fb_default_cmap(1<<fb_display[con].var.bits_per_pixel),
  899.     1, retz3_setcolreg, info);
  900. }
  901. /*
  902.  *    Get the Fixed Part of the Display
  903.  */
  904. static int retz3fb_get_fix(struct fb_fix_screeninfo *fix, int con,
  905.    struct fb_info *info)
  906. {
  907. struct retz3fb_par par;
  908. int error = 0;
  909. if (con == -1)
  910. retz3fb_get_par(info, &par);
  911. else
  912. error = retz3_decode_var(&fb_display[con].var, &par);
  913. return(error ? error : retz3_encode_fix(info, fix, &par));
  914. }
  915. /*
  916.  *    Get the User Defined Part of the Display
  917.  */
  918. static int retz3fb_get_var(struct fb_var_screeninfo *var, int con,
  919.    struct fb_info *info)
  920. {
  921. struct retz3fb_par par;
  922. int error = 0;
  923. if (con == -1) {
  924. retz3fb_get_par(info, &par);
  925. error = retz3_encode_var(var, &par);
  926. } else
  927. *var = fb_display[con].var;
  928. return error;
  929. }
  930. static void retz3fb_set_disp(int con, struct fb_info *info)
  931. {
  932. struct fb_fix_screeninfo fix;
  933. struct display *display;
  934. struct retz3_fb_info *zinfo = retz3info(info);
  935. if (con >= 0)
  936. display = &fb_display[con];
  937. else
  938. display = &zinfo->disp; /* used during initialization */
  939. retz3fb_get_fix(&fix, con, info);
  940. if (con == -1)
  941. con = 0;
  942. display->screen_base = zinfo->fbmem;
  943. display->visual = fix.visual;
  944. display->type = fix.type;
  945. display->type_aux = fix.type_aux;
  946. display->ypanstep = fix.ypanstep;
  947. display->ywrapstep = fix.ywrapstep;
  948. display->can_soft_blank = 1;
  949. display->inverse = z3fb_inverse;
  950. /*
  951.  * This seems to be about 20% faster.
  952.  */
  953. display->scrollmode = SCROLL_YREDRAW;
  954. switch (display->var.bits_per_pixel) {
  955. #ifdef FBCON_HAS_CFB8
  956. case 8:
  957. if (display->var.accel_flags & FB_ACCELF_TEXT) {
  958.     display->dispsw = &fbcon_retz3_8;
  959.     retz3_set_video(info, &display->var, &zinfo->current_par);
  960. } else
  961.     display->dispsw = &fbcon_cfb8;
  962. break;
  963. #endif
  964. #ifdef FBCON_HAS_CFB16
  965. case 16:
  966. display->dispsw = &fbcon_cfb16;
  967. break;
  968. #endif
  969. default:
  970. display->dispsw = &fbcon_dummy;
  971. break;
  972. }
  973. }
  974. /*
  975.  *    Set the User Defined Part of the Display
  976.  */
  977. static int retz3fb_set_var(struct fb_var_screeninfo *var, int con,
  978.    struct fb_info *info)
  979. {
  980. int err, oldxres, oldyres, oldvxres, oldvyres, oldbpp, oldaccel;
  981. struct display *display;
  982. struct retz3_fb_info *zinfo = retz3info(info);
  983. if (con >= 0)
  984. display = &fb_display[con];
  985. else
  986. display = &zinfo->disp; /* used during initialization */
  987. if ((err = do_fb_set_var(info, var, con == zinfo->currcon)))
  988. return err;
  989. if ((var->activate & FB_ACTIVATE_MASK) == FB_ACTIVATE_NOW) {
  990. oldxres = display->var.xres;
  991. oldyres = display->var.yres;
  992. oldvxres = display->var.xres_virtual;
  993. oldvyres = display->var.yres_virtual;
  994. oldbpp = display->var.bits_per_pixel;
  995. oldaccel = display->var.accel_flags;
  996. display->var = *var;
  997. if (oldxres != var->xres || oldyres != var->yres ||
  998.     oldvxres != var->xres_virtual ||
  999.     oldvyres != var->yres_virtual ||
  1000.     oldbpp != var->bits_per_pixel ||
  1001.     oldaccel != var->accel_flags) {
  1002. struct fb_fix_screeninfo fix;
  1003. retz3fb_get_fix(&fix, con, info);
  1004. display->screen_base = zinfo->fbmem;
  1005. display->visual = fix.visual;
  1006. display->type = fix.type;
  1007. display->type_aux = fix.type_aux;
  1008. display->ypanstep = fix.ypanstep;
  1009. display->ywrapstep = fix.ywrapstep;
  1010. display->line_length = fix.line_length;
  1011. display->can_soft_blank = 1;
  1012. display->inverse = z3fb_inverse;
  1013. switch (display->var.bits_per_pixel) {
  1014. #ifdef FBCON_HAS_CFB8
  1015. case 8:
  1016. if (var->accel_flags & FB_ACCELF_TEXT) {
  1017. display->dispsw = &fbcon_retz3_8;
  1018. } else
  1019. display->dispsw = &fbcon_cfb8;
  1020. break;
  1021. #endif
  1022. #ifdef FBCON_HAS_CFB16
  1023. case 16:
  1024. display->dispsw = &fbcon_cfb16;
  1025. break;
  1026. #endif
  1027. default:
  1028. display->dispsw = &fbcon_dummy;
  1029. break;
  1030. }
  1031. /*
  1032.  * We still need to find a way to tell the X
  1033.  * server that the video mem has been fiddled with
  1034.  * so it redraws the entire screen when switching
  1035.  * between X and a text console.
  1036.  */
  1037. retz3_set_video(info, var, &zinfo->current_par);
  1038. if (info->changevar)
  1039. (*info->changevar)(con);
  1040. }
  1041. if (oldbpp != var->bits_per_pixel) {
  1042. if ((err = fb_alloc_cmap(&display->cmap, 0, 0)))
  1043. return err;
  1044. do_install_cmap(con, info);
  1045. }
  1046. }
  1047. return 0;
  1048. }
  1049. /*
  1050.  *    Get the Colormap
  1051.  */
  1052. static int retz3fb_get_cmap(struct fb_cmap *cmap, int kspc, int con,
  1053.     struct fb_info *info)
  1054. {
  1055. struct retz3_fb_info *zinfo = retz3info(info);
  1056. if (con == zinfo->currcon) /* current console? */
  1057. return(fb_get_cmap(cmap, kspc, retz3_getcolreg, info));
  1058. else if (fb_display[con].cmap.len) /* non default colormap? */
  1059. fb_copy_cmap(&fb_display[con].cmap, cmap, kspc ? 0 : 2);
  1060. else
  1061. fb_copy_cmap(fb_default_cmap(1<<fb_display[con].var.bits_per_pixel),
  1062.      cmap, kspc ? 0 : 2);
  1063. return 0;
  1064. }
  1065. /*
  1066.  *    Set the Colormap
  1067.  */
  1068. static int retz3fb_set_cmap(struct fb_cmap *cmap, int kspc, int con,
  1069.     struct fb_info *info)
  1070. {
  1071. int err;
  1072. struct retz3_fb_info *zinfo = retz3info(info);
  1073. if (!fb_display[con].cmap.len) {       /* no colormap allocated? */
  1074. if ((err = fb_alloc_cmap(&fb_display[con].cmap,
  1075.  1<<fb_display[con].var.bits_per_pixel,
  1076.  0)))
  1077. return err;
  1078. }
  1079. if (con == zinfo->currcon)              /* current console? */
  1080. return(fb_set_cmap(cmap, kspc, retz3_setcolreg, info));
  1081. else
  1082. fb_copy_cmap(cmap, &fb_display[con].cmap, kspc ? 0 : 1);
  1083. return 0;
  1084. }
  1085. static struct fb_ops retz3fb_ops = {
  1086. owner: THIS_MODULE,
  1087. fb_get_fix: retz3fb_get_fix,
  1088. fb_get_var: retz3fb_get_var,
  1089. fb_set_var: retz3fb_set_var,
  1090. fb_get_cmap: retz3fb_get_cmap,
  1091. fb_set_cmap: retz3fb_set_cmap,
  1092. };
  1093. int __init retz3fb_setup(char *options)
  1094. {
  1095. char *this_opt;
  1096. if (!options || !*options)
  1097. return 0;
  1098. while ((this_opt = strsep(&options, ",")) != NULL) {
  1099. if (!*this_opt)
  1100. continue;
  1101. if (!strcmp(this_opt, "inverse")) {
  1102. z3fb_inverse = 1;
  1103. fb_invert_cmaps();
  1104. } else if (!strncmp(this_opt, "font:", 5)) {
  1105. strncpy(fontname, this_opt+5, 39);
  1106. fontname[39] = '';
  1107. } else
  1108. z3fb_mode = get_video_mode(this_opt);
  1109. }
  1110. return 0;
  1111. }
  1112. /*
  1113.  *    Initialization
  1114.  */
  1115. int __init retz3fb_init(void)
  1116. {
  1117. unsigned long board_addr, board_size;
  1118. struct zorro_dev *z = NULL;
  1119. volatile unsigned char *regs;
  1120. struct retz3fb_par par;
  1121. struct retz3_fb_info *zinfo;
  1122. struct fb_info *fb_info;
  1123. short i;
  1124. int res = -ENXIO;
  1125. while ((z = zorro_find_device(ZORRO_PROD_MACROSYSTEMS_RETINA_Z3, z))) {
  1126. board_addr = z->resource.start;
  1127. board_size = z->resource.end-z->resource.start+1;
  1128. if (!request_mem_region(board_addr, 0x0c00000,
  1129.      "ncr77c32blt")) {
  1130. continue;
  1131. if (!request_mem_region(board_addr+VIDEO_MEM_OFFSET,
  1132.      0x00400000, "RAM"))
  1133. release_mem_region(board_addr, 0x00c00000);
  1134. continue;
  1135. }
  1136. if (!(zinfo = kmalloc(sizeof(struct retz3_fb_info),
  1137.       GFP_KERNEL)))
  1138. return -ENOMEM;
  1139. memset(zinfo, 0, sizeof(struct retz3_fb_info));
  1140. zinfo->base = ioremap(board_addr, board_size);
  1141. zinfo->regs = zinfo->base;
  1142. zinfo->fbmem = zinfo->base + VIDEO_MEM_OFFSET;
  1143. /* Get memory size - for now we asume its a 4MB board */
  1144. zinfo->fbsize = 0x00400000; /* 4 MB */
  1145. zinfo->physregs = board_addr;
  1146. zinfo->physfbmem = board_addr + VIDEO_MEM_OFFSET;
  1147. fb_info = fbinfo(zinfo);
  1148. for (i = 0; i < 256; i++){
  1149. for (i = 0; i < 256; i++){
  1150. zinfo->color_table[i][0] = i;
  1151. zinfo->color_table[i][1] = i;
  1152. zinfo->color_table[i][2] = i;
  1153. }
  1154. }
  1155. regs = zinfo->regs;
  1156. /* Disable hardware cursor */
  1157. seq_w(regs, SEQ_CURSOR_Y_INDEX, 0x00);
  1158. retz3_setcolreg (255, 56<<8, 100<<8, 160<<8, 0, fb_info);
  1159. retz3_setcolreg (254, 0, 0, 0, 0, fb_info);
  1160. strcpy(fb_info->modename, retz3fb_name);
  1161. fb_info->changevar = NULL;
  1162. fb_info->node = -1;
  1163. fb_info->fbops = &retz3fb_ops;
  1164. fb_info->disp = &zinfo->disp;
  1165. fb_info->switch_con = &z3fb_switch;
  1166. fb_info->updatevar = &z3fb_updatevar;
  1167. fb_info->blank = &z3fb_blank;
  1168. fb_info->flags = FBINFO_FLAG_DEFAULT;
  1169. strncpy(fb_info->fontname, fontname, 40);
  1170. if (z3fb_mode == -1)
  1171. retz3fb_default = retz3fb_predefined[0].var;
  1172. retz3_decode_var(&retz3fb_default, &par);
  1173. retz3_encode_var(&retz3fb_default, &par);
  1174. do_fb_set_var(fb_info, &retz3fb_default, 0);
  1175. retz3fb_get_var(&zinfo->disp.var, -1, fb_info);
  1176. retz3fb_set_disp(-1, fb_info);
  1177. do_install_cmap(0, fb_info);
  1178. if (register_framebuffer(fb_info) < 0)
  1179. return -EINVAL;
  1180. printk(KERN_INFO "fb%d: %s frame buffer device, using %ldK of "
  1181.        "video memoryn", GET_FB_IDX(fb_info->node),
  1182.        fb_info->modename, zinfo->fbsize>>10);
  1183. /* FIXME: This driver cannot be unloaded yet */
  1184. MOD_INC_USE_COUNT;
  1185. res = 0;
  1186. }
  1187. return res;
  1188. }
  1189. static int z3fb_switch(int con, struct fb_info *info)
  1190. {
  1191. struct retz3_fb_info *zinfo = retz3info(info);
  1192. /* Do we have to save the colormap? */
  1193. if (fb_display[zinfo->currcon].cmap.len)
  1194. fb_get_cmap(&fb_display[zinfo->currcon].cmap, 1,
  1195.     retz3_getcolreg, info);
  1196. do_fb_set_var(info, &fb_display[con].var, 1);
  1197. zinfo->currcon = con;
  1198. /* Install new colormap */
  1199. do_install_cmap(con, info);
  1200. return 0;
  1201. }
  1202. /*
  1203.  *    Update the `var' structure (called by fbcon.c)
  1204.  *
  1205.  *    This call looks only at yoffset and the FB_VMODE_YWRAP flag in `var'.
  1206.  *    Since it's called by a kernel driver, no range checking is done.
  1207.  */
  1208. static int z3fb_updatevar(int con, struct fb_info *info)
  1209. {
  1210. return 0;
  1211. }
  1212. /*
  1213.  *    Blank the display.
  1214.  */
  1215. static void z3fb_blank(int blank, struct fb_info *info)
  1216. {
  1217. struct retz3_fb_info *zinfo = retz3info(info);
  1218. volatile unsigned char *regs = retz3info(info)->regs;
  1219. short i;
  1220. if (blank)
  1221. for (i = 0; i < 256; i++){
  1222. reg_w(regs, VDAC_ADDRESS_W, i);
  1223. reg_w(regs, VDAC_DATA, 0);
  1224. reg_w(regs, VDAC_DATA, 0);
  1225. reg_w(regs, VDAC_DATA, 0);
  1226. }
  1227. else
  1228. for (i = 0; i < 256; i++){
  1229. reg_w(regs, VDAC_ADDRESS_W, i);
  1230. reg_w(regs, VDAC_DATA, zinfo->color_table[i][0]);
  1231. reg_w(regs, VDAC_DATA, zinfo->color_table[i][1]);
  1232. reg_w(regs, VDAC_DATA, zinfo->color_table[i][2]);
  1233. }
  1234. }
  1235. /*
  1236.  *    Get a Video Mode
  1237.  */
  1238. static int __init get_video_mode(const char *name)
  1239. {
  1240. short i;
  1241. for (i = 0; i < NUM_TOTAL_MODES; i++)
  1242. if (!strcmp(name, retz3fb_predefined[i].name)){
  1243. retz3fb_default = retz3fb_predefined[i].var;
  1244. return i;
  1245. }
  1246. return -1;
  1247. }
  1248. #ifdef MODULE
  1249. MODULE_LICENSE("GPL");
  1250. int init_module(void)
  1251. {
  1252. return retz3fb_init();
  1253. }
  1254. void cleanup_module(void)
  1255. {
  1256. /*
  1257.  * Not reached because the usecount will never
  1258.  * be decremented to zero
  1259.  *
  1260.  * FIXME: clean up ... *
  1261.  */
  1262. }
  1263. #endif
  1264. /*
  1265.  *  Text console acceleration
  1266.  */
  1267. #ifdef FBCON_HAS_CFB8
  1268. static void retz3_8_bmove(struct display *p, int sy, int sx,
  1269.   int dy, int dx, int height, int width)
  1270. {
  1271. int fontwidth = fontwidth(p);
  1272. sx *= fontwidth;
  1273. dx *= fontwidth;
  1274. width *= fontwidth;
  1275. retz3_bitblt(p,
  1276.      (unsigned short)sx,
  1277.      (unsigned short)(sy*fontheight(p)),
  1278.      (unsigned short)dx,
  1279.      (unsigned short)(dy*fontheight(p)),
  1280.      (unsigned short)width,
  1281.      (unsigned short)(height*fontheight(p)),
  1282.      Z3BLTcopy,
  1283.      0xffff);
  1284. }
  1285. static void retz3_8_clear(struct vc_data *conp, struct display *p,
  1286.   int sy, int sx, int height, int width)
  1287. {
  1288. unsigned short col;
  1289. int fontwidth = fontwidth(p);
  1290. sx *= fontwidth;
  1291. width *= fontwidth;
  1292. col = attr_bgcol_ec(p, conp);
  1293. col &= 0xff;
  1294. col |= (col << 8);
  1295. retz3_bitblt(p,
  1296.      (unsigned short)sx,
  1297.      (unsigned short)(sy*fontheight(p)),
  1298.      (unsigned short)sx,
  1299.      (unsigned short)(sy*fontheight(p)),
  1300.      (unsigned short)width,
  1301.      (unsigned short)(height*fontheight(p)),
  1302.      Z3BLTset,
  1303.      col);
  1304. }
  1305. static void retz3_putc(struct vc_data *conp, struct display *p, int c,
  1306.        int yy, int xx)
  1307. {
  1308. retz3_busy(p);
  1309. fbcon_cfb8_putc(conp, p, c, yy, xx);
  1310. }
  1311. static void retz3_putcs(struct vc_data *conp, struct display *p,
  1312. const unsigned short *s, int count,
  1313. int yy, int xx)
  1314. {
  1315. retz3_busy(p);
  1316. fbcon_cfb8_putcs(conp, p, s, count, yy, xx);
  1317. }
  1318. static void retz3_revc(struct display *p, int xx, int yy)
  1319. {
  1320. retz3_busy(p);
  1321. fbcon_cfb8_revc(p, xx, yy);
  1322. }
  1323. static void retz3_clear_margins(struct vc_data* conp, struct display* p,
  1324. int bottom_only)
  1325. {
  1326. retz3_busy(p);
  1327. fbcon_cfb8_clear_margins(conp, p, bottom_only);
  1328. }
  1329. static struct display_switch fbcon_retz3_8 = {
  1330.     setup: fbcon_cfb8_setup,
  1331.     bmove: retz3_8_bmove,
  1332.     clear: retz3_8_clear,
  1333.     putc: retz3_putc,
  1334.     putcs: retz3_putcs,
  1335.     revc: retz3_revc,
  1336.     clear_margins: retz3_clear_margins,
  1337.     fontwidthmask: FONTWIDTH(8)
  1338. };
  1339. #endif