Merge master.kernel.org:/pub/scm/linux/kernel/git/roland/infiniband
[linux-2.6] / drivers / video / cyberfb.c
1 /*
2 * linux/drivers/video/cyberfb.c -- CyberVision64 frame buffer device
3 * $Id: cyberfb.c,v 1.6 1998/09/11 04:54:58 abair Exp $
4 *
5 *    Copyright (C) 1998 Alan Bair
6 *
7 * This file is based on two CyberVision64 frame buffer device drivers
8 *
9 * The second CyberVision64 frame buffer device (cvision.c cvision_core.c):
10 *
11 *   Copyright (c) 1997 Antonio Santos
12 *
13 * Released as a patch to 2.1.35, but never included in the source tree.
14 * This is based on work from the NetBSD CyberVision64 frame buffer driver 
15 * and support files (grf_cv.c, grf_cvreg.h, ite_cv.c):
16 * Permission to use the source of this driver was obtained from the
17 * author Michael Teske by Alan Bair.
18 *
19 *   Copyright (c) 1995 Michael Teske
20 *
21 * The first CyberVision64 frame buffer device (cyberfb.c):
22 *
23 *    Copyright (C) 1996 Martin Apel
24 *                       Geert Uytterhoeven
25 *
26 * Which is based on the Amiga frame buffer device (amifb.c):
27 *
28 *    Copyright (C) 1995 Geert Uytterhoeven
29 *
30 *
31 * History:
32 *   - 22 Dec 95: Original version by Martin Apel
33 *   - 05 Jan 96: Geert: integration into the current source tree
34 *   - 01 Aug 98: Alan: Merge in code from cvision.c and cvision_core.c
35 * $Log: cyberfb.c,v $
36 * Revision 1.6  1998/09/11 04:54:58  abair
37 * Update for 2.1.120 change in include file location.
38 * Clean up for public release.
39 *
40 * Revision 1.5  1998/09/03 04:27:13  abair
41 * Move cv64_load_video_mode to cyber_set_video so a new video mode is install
42 * with each change of the 'var' data.
43 *
44 * Revision 1.4  1998/09/01 00:31:17  abair
45 * Put in a set of default 8,16,24 bpp modes and map cyber8,16 to them.
46 * Update operations with 'par' to handle a more complete set of parameter
47 * values for encode/decode process.
48 *
49 * Revision 1.3  1998/08/31 21:31:33  abair
50 * Swap 800x490 for 640x480 video mode and more cleanup.
51 * Abandon idea to resurrect "custom" mode setting via kernel opts,
52 * instead work on making use of fbset program to do this.
53 *
54 * Revision 1.2  1998/08/31 06:17:08  abair
55 * Make updates for changes in cyberfb.c released in 2.1.119
56 * and do some cleanup of the code.
57 *
58 * Revision 1.1  1998/08/29 18:38:31  abair
59 * Initial revision
60 *
61 * Revision 1.3  1998/08/17 06:21:53  abair
62 * Remove more redundant code after merging in cvision_core.c
63 * Set blanking by colormap to pale red to detect this vs trying to
64 * use video blanking. More formating to Linux code style.
65 *
66 * Revision 1.2  1998/08/15 17:51:37  abair
67 * Added cvision_core.c code from 2.1.35 patches.
68 * Changed to compile correctly and switch to using initialization
69 * code. Added debugging and dropping of duplicate code.
70 *
71 *
72 *
73 * This file is subject to the terms and conditions of the GNU General Public
74 * License.  See the file COPYING in the main directory of this archive
75 * for more details.
76 */
77
78
79 #include <linux/module.h>
80 #include <linux/kernel.h>
81 #include <linux/errno.h>
82 #include <linux/string.h>
83 #include <linux/mm.h>
84 #include <linux/tty.h>
85 #include <linux/slab.h>
86 #include <linux/delay.h>
87 #include <linux/zorro.h>
88 #include <linux/fb.h>
89 #include <linux/init.h>
90 #include <asm/uaccess.h>
91 #include <asm/system.h>
92 #include <asm/irq.h>
93 #include <asm/pgtable.h>
94 #include <asm/amigahw.h>
95 #include <asm/io.h>
96
97 #include "cyberfb.h"
98 #include <video/fbcon.h>
99 #include <video/fbcon-cfb8.h>
100 #include <video/fbcon-cfb16.h>
101
102 /*#define CYBERFBDEBUG*/
103 #ifdef CYBERFBDEBUG
104 #define DPRINTK(fmt, args...) printk(KERN_DEBUG "%s: " fmt, __FUNCTION__ , ## args)
105 static void cv64_dump(void);
106 #else
107 #define DPRINTK(fmt, args...)
108 #endif
109
110 #define wb_64(regs,reg,dat) (*(((volatile unsigned char *)regs) + reg) = dat)
111 #define rb_64(regs, reg) (*(((volatile unsigned char *)regs) + reg))
112
113 #define ww_64(regs,reg,dat) (*((volatile unsigned short *)(regs + reg) = dat)
114
115 struct cyberfb_par {
116         struct fb_var_screeninfo var;
117         __u32 type;
118         __u32 type_aux;
119         __u32 visual;
120         __u32 line_length;
121 };
122
123 static struct cyberfb_par current_par;
124
125 static int current_par_valid = 0;
126
127 static struct display disp;
128 static struct fb_info fb_info;
129
130
131 /*
132  *    Frame Buffer Name
133  */
134
135 static char cyberfb_name[16] = "Cybervision";
136
137
138 /*
139  *    CyberVision Graphics Board
140  */
141
142 static unsigned char Cyber_colour_table [256][3];
143 static unsigned long CyberSize;
144 static volatile unsigned char *CyberBase;
145 static volatile unsigned char *CyberMem;
146 static volatile unsigned char *CyberRegs;
147 static unsigned long CyberMem_phys;
148 static unsigned long CyberRegs_phys;
149
150 /*
151  *    Predefined Video Modes
152  */
153
154 static struct {
155     const char *name;
156     struct fb_var_screeninfo var;
157 } cyberfb_predefined[] __initdata = {
158         { "640x480-8", {                /* Default 8 BPP mode (cyber8) */
159                 640, 480, 640, 480, 0, 0, 8, 0,
160                 {0, 8, 0}, {0, 8, 0}, {0, 8, 0}, {0, 0, 0},
161                 0, 0, -1, -1, FB_ACCELF_TEXT, 39722, 40, 24, 32, 11, 96, 2,
162                 FB_SYNC_COMP_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT, 
163                 FB_VMODE_NONINTERLACED
164         }}, 
165         { "640x480-16", {               /* Default 16 BPP mode (cyber16) */
166                 640, 480, 640, 480, 0, 0, 16, 0,
167                 {11, 5, 0}, {5, 6, 0}, {0, 5, 0}, {0, 0, 0},
168                 0, 0, -1, -1, FB_ACCELF_TEXT, 39722, 40, 24, 32, 11, 96, 2,
169                 FB_SYNC_COMP_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT, 
170                 FB_VMODE_NONINTERLACED
171         }}, 
172         { "640x480-24", {               /* Default 24 BPP mode */
173                 640, 480, 640, 480, 0, 0, 24, 0,
174                 {16, 8, 0}, {8, 8, 0}, {0, 8, 0}, {0, 0, 0},
175                 0, 0, -1, -1, FB_ACCELF_TEXT, 39722, 40, 24, 32, 11, 96, 2,
176                 FB_SYNC_COMP_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT, 
177                 FB_VMODE_NONINTERLACED
178         }}, 
179         { "800x490-8", {                /* Cybervision 8 bpp */
180                 /* NO Acceleration */
181                 800, 490, 800, 490, 0, 0, 8, 0,
182                 {0, 8, 0}, {0, 8, 0}, {0, 8, 0}, {0, 0, 0},
183                 0, 0, -1, -1, FB_ACCEL_NONE, 33333, 80, 24, 23, 1, 56, 8,
184                 FB_SYNC_COMP_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT,
185                 FB_VMODE_NONINTERLACED
186         }},
187 /* I can't test these with my monitor, but I suspect they will
188  * be OK, since Antonio Santos indicated he had tested them in
189  * his system.
190  */
191         { "800x600-8", {                /* Cybervision 8 bpp */
192                 800, 600, 800, 600, 0, 0, 8, 0,
193                 {0, 8, 0}, {0, 8, 0}, {0, 8, 0}, {0, 0, 0},
194                 0, 0, -1, -1, FB_ACCELF_TEXT, 27778, 64, 24, 22, 1, 72, 2,
195                 FB_SYNC_COMP_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT,
196                 FB_VMODE_NONINTERLACED
197         }},
198         { "1024x768-8", {               /* Cybervision 8 bpp */
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_ACCELF_TEXT, 16667, 224, 72, 60, 12, 168, 4,
202                 FB_SYNC_COMP_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT,
203                 FB_VMODE_NONINTERLACED
204         }},
205         { "1152x886-8", {               /* Cybervision 8 bpp */
206                 1152, 886, 1152, 886, 0, 0, 8, 0,
207                 {0, 8, 0}, {0, 8, 0}, {0, 8, 0}, {0, 0, 0},
208                 0, 0, -1, -1, FB_ACCELF_TEXT, 15873, 184, 40, 24, 1, 56, 16,
209                 FB_SYNC_COMP_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT,
210                 FB_VMODE_NONINTERLACED
211         }},
212         { "1280x1024-8", {      /* Cybervision 8 bpp */
213                 1280, 1024, 1280, 1024, 0, 0, 8, 0,
214                 {0, 8, 0}, {0, 8, 0}, {0, 8, 0}, {0, 0, 0},
215                 0, 0, -1, -1, FB_ACCELF_TEXT, 16667, 256, 48, 50, 12, 72, 4,
216                 FB_SYNC_COMP_HIGH_ACT|FB_SYNC_VERT_HIGH_ACT,
217                 FB_VMODE_INTERLACED
218         }}
219 };
220
221 #define NUM_TOTAL_MODES    ARRAY_SIZE(cyberfb_predefined)
222
223 static int Cyberfb_inverse = 0;
224
225 /*
226  *    Some default modes
227  */
228
229 #define CYBER8_DEFMODE     (0)
230 #define CYBER16_DEFMODE    (1)
231
232 static struct fb_var_screeninfo cyberfb_default;
233 static int cyberfb_usermode __initdata = 0;
234
235 /*
236  *    Interface used by the world
237  */
238
239 int cyberfb_setup(char *options);
240
241 static int cyberfb_get_fix(struct fb_fix_screeninfo *fix, int con,
242                            struct fb_info *info);
243 static int cyberfb_get_var(struct fb_var_screeninfo *var, int con,
244                            struct fb_info *info);
245 static int cyberfb_set_var(struct fb_var_screeninfo *var, int con,
246                            struct fb_info *info);
247 static int cyberfb_get_cmap(struct fb_cmap *cmap, int kspc, int con,
248                             struct fb_info *info);
249 static int cyberfb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
250                              u_int transp, struct fb_info *info);
251 static int cyberfb_blank(int blank, struct fb_info *info);
252
253 /*
254  *    Interface to the low level console driver
255  */
256
257 int cyberfb_init(void);
258 static int Cyberfb_switch(int con, struct fb_info *info);
259 static int Cyberfb_updatevar(int con, struct fb_info *info);
260
261 /*
262  *    Text console acceleration
263  */
264
265 #ifdef FBCON_HAS_CFB8
266 static struct display_switch fbcon_cyber8;
267 #endif
268
269 /*
270  *    Accelerated Functions used by the low level console driver
271  */
272
273 static void Cyber_WaitQueue(u_short fifo);
274 static void Cyber_WaitBlit(void);
275 static void Cyber_BitBLT(u_short curx, u_short cury, u_short destx,
276                          u_short desty, u_short width, u_short height,
277                          u_short mode);
278 static void Cyber_RectFill(u_short x, u_short y, u_short width, u_short height,
279                            u_short mode, u_short color);
280 #if 0
281 static void Cyber_MoveCursor(u_short x, u_short y);
282 #endif
283
284 /*
285  *   Hardware Specific Routines
286  */
287
288 static int Cyber_init(void);
289 static int Cyber_encode_fix(struct fb_fix_screeninfo *fix,
290                             struct cyberfb_par *par);
291 static int Cyber_decode_var(struct fb_var_screeninfo *var,
292                             struct cyberfb_par *par);
293 static int Cyber_encode_var(struct fb_var_screeninfo *var,
294                             struct cyberfb_par *par);
295 static int Cyber_getcolreg(u_int regno, u_int *red, u_int *green, u_int *blue,
296                            u_int *transp, struct fb_info *info);
297
298 /*
299  *    Internal routines
300  */
301
302 static void cyberfb_get_par(struct cyberfb_par *par);
303 static void cyberfb_set_par(struct cyberfb_par *par);
304 static int do_fb_set_var(struct fb_var_screeninfo *var, int isactive);
305 static void cyberfb_set_disp(int con, struct fb_info *info);
306 static int get_video_mode(const char *name);
307
308 /* For cvision_core.c */
309 static unsigned short cv64_compute_clock(unsigned long);
310 static int cv_has_4mb (volatile unsigned char *);
311 static void cv64_board_init (void);
312 static void cv64_load_video_mode (struct fb_var_screeninfo *);
313
314
315 /* -------------------- Hardware specific routines ------------------------- */
316
317
318 /*
319  *    Initialization
320  *
321  *    Set the default video mode for this chipset. If a video mode was
322  *    specified on the command line, it will override the default mode.
323  */
324
325 static int Cyber_init(void)
326 {
327         volatile unsigned char *regs = CyberRegs;
328         volatile unsigned long *CursorBase;
329         int i;
330         DPRINTK("ENTER\n");
331
332 /* Init local cmap as greyscale levels */
333         for (i = 0; i < 256; i++) {
334                 Cyber_colour_table [i][0] = i;
335                 Cyber_colour_table [i][1] = i;
336                 Cyber_colour_table [i][2] = i;
337         }
338
339 /* Initialize the board and determine fbmem size */
340         cv64_board_init(); 
341 #ifdef CYBERFBDEBUG
342         DPRINTK("Register state after initing board\n");
343         cv64_dump();
344 #endif
345 /* Clear framebuffer memory */
346         DPRINTK("Clear framebuffer memory\n");
347         memset ((char *)CyberMem, 0, CyberSize);
348
349 /* Disable hardware cursor */
350         DPRINTK("Disable HW cursor\n");
351         wb_64(regs, S3_CRTC_ADR, S3_REG_LOCK2);
352         wb_64(regs, S3_CRTC_DATA, 0xa0);
353         wb_64(regs, S3_CRTC_ADR, S3_HGC_MODE);
354         wb_64(regs, S3_CRTC_DATA, 0x00);
355         wb_64(regs, S3_CRTC_ADR, S3_HWGC_DX);
356         wb_64(regs, S3_CRTC_DATA, 0x00);
357         wb_64(regs, S3_CRTC_ADR, S3_HWGC_DY);
358         wb_64(regs, S3_CRTC_DATA, 0x00);
359
360 /* Initialize hardware cursor */
361         DPRINTK("Init HW cursor\n");
362         CursorBase = (u_long *)((char *)(CyberMem) + CyberSize - 0x400);
363         for (i=0; i < 8; i++)
364         {
365                 *(CursorBase  +(i*4)) = 0xffffff00;
366                 *(CursorBase+1+(i*4)) = 0xffff0000;
367                 *(CursorBase+2+(i*4)) = 0xffff0000;
368                 *(CursorBase+3+(i*4)) = 0xffff0000;
369         }
370         for (i=8; i < 64; i++)
371         {
372                 *(CursorBase  +(i*4)) = 0xffff0000;
373                 *(CursorBase+1+(i*4)) = 0xffff0000;
374                 *(CursorBase+2+(i*4)) = 0xffff0000;
375                 *(CursorBase+3+(i*4)) = 0xffff0000;
376         }
377
378         cyberfb_setcolreg (255, 56<<8, 100<<8, 160<<8, 0, NULL /* unused */);
379         cyberfb_setcolreg (254, 0, 0, 0, 0, NULL /* unused */);
380
381         DPRINTK("EXIT\n");
382         return 0;
383 }
384
385
386 /*
387  *    This function should fill in the `fix' structure based on the
388  *    values in the `par' structure.
389  */
390
391 static int Cyber_encode_fix(struct fb_fix_screeninfo *fix,
392                             struct cyberfb_par *par)
393 {
394         DPRINTK("ENTER\n");
395         memset(fix, 0, sizeof(struct fb_fix_screeninfo));
396         strcpy(fix->id, cyberfb_name);
397         fix->smem_start = CyberMem_phys;
398         fix->smem_len = CyberSize;
399         fix->mmio_start = CyberRegs_phys;
400         fix->mmio_len = 0x10000;
401
402         fix->type = FB_TYPE_PACKED_PIXELS;
403         fix->type_aux = 0;
404         if (par->var.bits_per_pixel == 15 || par->var.bits_per_pixel == 16 ||
405             par->var.bits_per_pixel == 24 || par->var.bits_per_pixel == 32) {
406                 fix->visual = FB_VISUAL_DIRECTCOLOR;
407         } else {
408                 fix->visual = FB_VISUAL_PSEUDOCOLOR;
409         }
410
411         fix->xpanstep = 0;
412         fix->ypanstep = 0;
413         fix->ywrapstep = 0;
414         fix->line_length = 0;
415         fix->accel = FB_ACCEL_S3_TRIO64;
416
417         DPRINTK("EXIT\n");
418         return(0);
419 }
420
421
422 /*
423 *    Fill the `par' structure based on the values in `var'.
424 *    TODO: Verify and adjust values, return -EINVAL if bad.
425 */
426
427 static int Cyber_decode_var(struct fb_var_screeninfo *var,
428                             struct cyberfb_par *par)
429 {
430         DPRINTK("ENTER\n");
431         par->var.xres = var->xres;
432         par->var.yres = var->yres;
433         par->var.xres_virtual = var->xres_virtual;
434         par->var.yres_virtual = var->yres_virtual;
435         par->var.xoffset = var->xoffset;
436         par->var.yoffset = var->yoffset;
437         par->var.bits_per_pixel = var->bits_per_pixel;
438         par->var.grayscale = var->grayscale;
439         par->var.red = var->red;
440         par->var.green = var->green;
441         par->var.blue = var->blue;
442         par->var.transp = var->transp;
443         par->var.nonstd = var->nonstd;
444         par->var.activate = var->activate;
445         par->var.height = var->height;
446         par->var.width = var->width;
447         if (var->accel_flags & FB_ACCELF_TEXT) {
448                 par->var.accel_flags = FB_ACCELF_TEXT;
449         } else {
450                 par->var.accel_flags = 0;
451         }
452         par->var.pixclock = var->pixclock;
453         par->var.left_margin = var->left_margin;
454         par->var.right_margin = var->right_margin;
455         par->var.upper_margin = var->upper_margin;
456         par->var.lower_margin = var->lower_margin;
457         par->var.hsync_len = var->hsync_len;
458         par->var.vsync_len = var->vsync_len;
459         par->var.sync = var->sync;
460         par->var.vmode = var->vmode;
461         DPRINTK("EXIT\n");
462         return(0);
463 }
464
465 /*
466 *    Fill the `var' structure based on the values in `par' and maybe
467 *    other values read out of the hardware.
468 */
469
470 static int Cyber_encode_var(struct fb_var_screeninfo *var,
471                             struct cyberfb_par *par)
472 {
473         DPRINTK("ENTER\n");
474         var->xres = par->var.xres;
475         var->yres = par->var.yres;
476         var->xres_virtual = par->var.xres_virtual;
477         var->yres_virtual = par->var.yres_virtual;
478         var->xoffset = par->var.xoffset;
479         var->yoffset = par->var.yoffset;
480
481         var->bits_per_pixel = par->var.bits_per_pixel;
482         var->grayscale = par->var.grayscale;
483
484         var->red = par->var.red;
485         var->green = par->var.green;
486         var->blue = par->var.blue;
487         var->transp = par->var.transp;
488
489         var->nonstd = par->var.nonstd;
490         var->activate = par->var.activate;
491
492         var->height = par->var.height;
493         var->width = par->var.width;
494
495         var->accel_flags = par->var.accel_flags;
496
497         var->pixclock = par->var.pixclock;
498         var->left_margin = par->var.left_margin;
499         var->right_margin = par->var.right_margin;
500         var->upper_margin = par->var.upper_margin;
501         var->lower_margin = par->var.lower_margin;
502         var->hsync_len = par->var.hsync_len;
503         var->vsync_len = par->var.vsync_len;
504         var->sync = par->var.sync;
505         var->vmode = par->var.vmode;
506         
507         DPRINTK("EXIT\n");
508         return(0);
509 }
510
511
512 /*
513  *    Set a single color register. Return != 0 for invalid regno.
514  */
515
516 static int cyberfb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
517                            u_int transp, struct fb_info *info)
518 {
519         volatile unsigned char *regs = CyberRegs;
520
521         /*DPRINTK("ENTER\n");*/
522         if (regno > 255) {
523                 DPRINTK("EXIT - Register # > 255\n");
524                 return (1);
525         }
526
527         wb_64(regs, 0x3c8, (unsigned char) regno);
528
529         red >>= 10;
530         green >>= 10;
531         blue >>= 10;
532
533         Cyber_colour_table [regno][0] = red;
534         Cyber_colour_table [regno][1] = green;
535         Cyber_colour_table [regno][2] = blue;
536
537         wb_64(regs, 0x3c9, red);
538         wb_64(regs, 0x3c9, green);
539         wb_64(regs, 0x3c9, blue);
540
541         /*DPRINTK("EXIT\n");*/
542         return (0);
543 }
544
545
546 /*
547 *    Read a single color register and split it into
548 *    colors/transparent. Return != 0 for invalid regno.
549 */
550
551 static int Cyber_getcolreg(u_int regno, u_int *red, u_int *green, u_int *blue,
552                            u_int *transp, struct fb_info *info)
553 {
554         int t;
555
556         /*DPRINTK("ENTER\n");*/
557         if (regno > 255) {
558                 DPRINTK("EXIT - Register # > 255\n");
559                 return (1);
560         }
561         /* ARB This shifting & oring seems VERY strange */
562         t       = Cyber_colour_table [regno][0];
563         *red    = (t<<10) | (t<<4) | (t>>2);
564         t       = Cyber_colour_table [regno][1];
565         *green  = (t<<10) | (t<<4) | (t>>2);
566         t       = Cyber_colour_table [regno][2];
567         *blue   = (t<<10) | (t<<4) | (t>>2);
568         *transp = 0;
569         /*DPRINTK("EXIT\n");*/
570         return (0);
571 }
572
573
574 /*
575 *    (Un)Blank the screen
576 *    blank: 1 = zero fb cmap
577 *           0 = restore fb cmap from local cmap
578 */
579 static int cyberfb_blank(int blank, struct fb_info *info)
580 {
581         volatile unsigned char *regs = CyberRegs;
582         int i;
583
584         DPRINTK("ENTER\n");
585 #if 0
586 /* Blank by turning gfx off */
587         gfx_on_off (1, regs);
588 #else
589         if (blank) {
590                 for (i = 0; i < 256; i++) {
591                         wb_64(regs, 0x3c8, (unsigned char) i);
592                         /* ARB Pale red to detect this blanking method */
593                         wb_64(regs, 0x3c9, 48); 
594                         wb_64(regs, 0x3c9, 0);
595                         wb_64(regs, 0x3c9, 0);
596                 }
597         } else {
598                 for (i = 0; i < 256; i++) {
599                         wb_64(regs, 0x3c8, (unsigned char) i);
600                         wb_64(regs, 0x3c9, Cyber_colour_table[i][0]);
601                         wb_64(regs, 0x3c9, Cyber_colour_table[i][1]);
602                         wb_64(regs, 0x3c9, Cyber_colour_table[i][2]);
603                 }
604         }
605 #endif
606         DPRINTK("EXIT\n");
607         return 0;
608 }
609
610
611 /**************************************************************
612  * We are waiting for "fifo" FIFO-slots empty
613  */
614 static void Cyber_WaitQueue (u_short fifo)
615 {
616         unsigned short status;
617
618         DPRINTK("ENTER\n");
619         do {
620                 status = *((u_short volatile *)(CyberRegs + S3_GP_STAT));
621         } while (status & fifo);
622         DPRINTK("EXIT\n");
623 }
624
625 /**************************************************************
626  * We are waiting for Hardware (Graphics Engine) not busy
627  */
628 static void Cyber_WaitBlit (void)
629 {
630         unsigned short status;
631
632         DPRINTK("ENTER\n");
633         do {
634                 status = *((u_short volatile *)(CyberRegs + S3_GP_STAT));
635         } while (status & S3_HDW_BUSY);
636         DPRINTK("EXIT\n");
637 }
638
639 /**************************************************************
640  * BitBLT - Through the Plane
641  */
642 static void Cyber_BitBLT (u_short curx, u_short cury, u_short destx,
643                           u_short desty, u_short width, u_short height,
644                           u_short mode)
645 {
646         volatile unsigned char *regs = CyberRegs;
647         u_short blitcmd = S3_BITBLT;
648
649         DPRINTK("ENTER\n");
650         /* Set drawing direction */
651         /* -Y, X maj, -X (default) */
652         if (curx > destx) {
653                 blitcmd |= 0x0020;  /* Drawing direction +X */
654         } else {
655                 curx  += (width - 1);
656                 destx += (width - 1);
657         }
658
659         if (cury > desty) {
660                 blitcmd |= 0x0080;  /* Drawing direction +Y */
661         } else {
662                 cury  += (height - 1);
663                 desty += (height - 1);
664         }
665
666         Cyber_WaitQueue (0x8000);
667
668         *((u_short volatile *)(regs + S3_PIXEL_CNTL)) = 0xa000;
669         *((u_short volatile *)(regs + S3_FRGD_MIX)) = (0x0060 | mode);
670
671         *((u_short volatile *)(regs + S3_CUR_X)) = curx;
672         *((u_short volatile *)(regs + S3_CUR_Y)) = cury;
673
674         *((u_short volatile *)(regs + S3_DESTX_DIASTP)) = destx;
675         *((u_short volatile *)(regs + S3_DESTY_AXSTP)) = desty;
676
677         *((u_short volatile *)(regs + S3_MIN_AXIS_PCNT)) = height - 1;
678         *((u_short volatile *)(regs + S3_MAJ_AXIS_PCNT)) = width  - 1;
679
680         *((u_short volatile *)(regs + S3_CMD)) = blitcmd;
681         DPRINTK("EXIT\n");
682 }
683
684 /**************************************************************
685  * Rectangle Fill Solid
686  */
687 static void Cyber_RectFill (u_short x, u_short y, u_short width,
688                             u_short height, u_short mode, u_short color)
689 {
690         volatile unsigned char *regs = CyberRegs;
691         u_short blitcmd = S3_FILLEDRECT;
692
693         DPRINTK("ENTER\n");
694         Cyber_WaitQueue (0x8000);
695
696         *((u_short volatile *)(regs + S3_PIXEL_CNTL)) = 0xa000;
697         *((u_short volatile *)(regs + S3_FRGD_MIX)) = (0x0020 | mode);
698
699         *((u_short volatile *)(regs + S3_MULT_MISC)) = 0xe000;
700         *((u_short volatile *)(regs + S3_FRGD_COLOR)) = color;
701
702         *((u_short volatile *)(regs + S3_CUR_X)) = x;
703         *((u_short volatile *)(regs + S3_CUR_Y)) = y;
704
705         *((u_short volatile *)(regs + S3_MIN_AXIS_PCNT)) = height - 1;
706         *((u_short volatile *)(regs + S3_MAJ_AXIS_PCNT)) = width  - 1;
707
708         *((u_short volatile *)(regs + S3_CMD)) = blitcmd;
709         DPRINTK("EXIT\n");
710 }
711
712
713 #if 0
714 /**************************************************************
715  * Move cursor to x, y
716  */
717 static void Cyber_MoveCursor (u_short x, u_short y)
718 {
719         volatile unsigned char *regs = CyberRegs;
720         DPRINTK("ENTER\n");
721         *(regs + S3_CRTC_ADR)  = 0x39;
722         *(regs + S3_CRTC_DATA) = 0xa0;
723
724         *(regs + S3_CRTC_ADR)  = S3_HWGC_ORGX_H;
725         *(regs + S3_CRTC_DATA) = (char)((x & 0x0700) >> 8);
726         *(regs + S3_CRTC_ADR)  = S3_HWGC_ORGX_L;
727         *(regs + S3_CRTC_DATA) = (char)(x & 0x00ff);
728
729         *(regs + S3_CRTC_ADR)  = S3_HWGC_ORGY_H;
730         *(regs + S3_CRTC_DATA) = (char)((y & 0x0700) >> 8);
731         *(regs + S3_CRTC_ADR)  = S3_HWGC_ORGY_L;
732         *(regs + S3_CRTC_DATA) = (char)(y & 0x00ff);
733         DPRINTK("EXIT\n");
734 }
735 #endif
736
737
738 /* -------------------- Generic routines ---------------------------------- */
739
740
741 /*
742  *    Fill the hardware's `par' structure.
743  */
744
745 static void cyberfb_get_par(struct cyberfb_par *par)
746 {
747         DPRINTK("ENTER\n");
748         if (current_par_valid) {
749                 *par = current_par;
750         } else {
751                 Cyber_decode_var(&cyberfb_default, par);
752         }
753         DPRINTK("EXIT\n");
754 }
755
756
757 static void cyberfb_set_par(struct cyberfb_par *par)
758 {
759         DPRINTK("ENTER\n");
760         current_par = *par;
761         current_par_valid = 1;
762         DPRINTK("EXIT\n");
763 }
764
765
766 static void cyber_set_video(struct fb_var_screeninfo *var)
767 {
768
769         /* Load the video mode defined by the 'var' data */
770         cv64_load_video_mode (var);
771 #ifdef CYBERFBDEBUG
772         DPRINTK("Register state after loading video mode\n");
773         cv64_dump();
774 #endif
775 }
776
777
778 static int do_fb_set_var(struct fb_var_screeninfo *var, int isactive)
779 {
780         int err, activate;
781         struct cyberfb_par par;
782
783         DPRINTK("ENTER\n");
784         if ((err = Cyber_decode_var(var, &par))) {
785                 DPRINTK("EXIT - decode_var failed\n");
786                 return(err);
787         }
788         activate = var->activate;
789         if ((var->activate & FB_ACTIVATE_MASK) == FB_ACTIVATE_NOW && isactive)
790                 cyberfb_set_par(&par);
791         Cyber_encode_var(var, &par);
792         var->activate = activate;
793
794         cyber_set_video(var);
795         DPRINTK("EXIT\n");
796         return 0;
797 }
798
799 /*
800  *    Get the Fixed Part of the Display
801  */
802
803 static int cyberfb_get_fix(struct fb_fix_screeninfo *fix, int con,
804                            struct fb_info *info)
805 {
806         struct cyberfb_par par;
807         int error = 0;
808
809         DPRINTK("ENTER\n");
810         if (con == -1) {
811                 cyberfb_get_par(&par);
812         } else {
813                 error = Cyber_decode_var(&fb_display[con].var, &par);
814         }
815         DPRINTK("EXIT\n");
816         return(error ? error : Cyber_encode_fix(fix, &par));
817 }
818
819
820 /*
821  *    Get the User Defined Part of the Display
822  */
823
824 static int cyberfb_get_var(struct fb_var_screeninfo *var, int con,
825                            struct fb_info *info)
826 {
827         struct cyberfb_par par;
828         int error = 0;
829
830         DPRINTK("ENTER\n");
831         if (con == -1) {
832                 cyberfb_get_par(&par);
833                 error = Cyber_encode_var(var, &par);
834                 disp.var = *var;   /* ++Andre: don't know if this is the right place */
835         } else {
836                 *var = fb_display[con].var;
837         }
838
839         DPRINTK("EXIT\n");
840         return(error);
841 }
842
843
844 static void cyberfb_set_disp(int con, struct fb_info *info)
845 {
846         struct fb_fix_screeninfo fix;
847         struct display *display;
848
849         DPRINTK("ENTER\n");
850         if (con >= 0)
851                 display = &fb_display[con];
852         else
853                 display = &disp;        /* used during initialization */
854
855         cyberfb_get_fix(&fix, con, info);
856         if (con == -1)
857                 con = 0;
858         display->visual = fix.visual;
859         display->type = fix.type;
860         display->type_aux = fix.type_aux;
861         display->ypanstep = fix.ypanstep;
862         display->ywrapstep = fix.ywrapstep;
863         display->can_soft_blank = 1;
864         display->inverse = Cyberfb_inverse;
865         switch (display->var.bits_per_pixel) {
866 #ifdef FBCON_HAS_CFB8
867             case 8:
868                 if (display->var.accel_flags & FB_ACCELF_TEXT) {
869                     display->dispsw = &fbcon_cyber8;
870 #warning FIXME: We should reinit the graphics engine here
871                 } else
872                     display->dispsw = &fbcon_cfb8;
873                 break;
874 #endif
875 #ifdef FBCON_HAS_CFB16
876             case 16:
877                 display->dispsw = &fbcon_cfb16;
878                 break;
879 #endif
880             default:
881                 display->dispsw = NULL;
882                 break;
883         }
884         DPRINTK("EXIT\n");
885 }
886
887
888 /*
889  *    Set the User Defined Part of the Display
890  */
891
892 static int cyberfb_set_var(struct fb_var_screeninfo *var, int con,
893                            struct fb_info *info)
894 {
895         int err, oldxres, oldyres, oldvxres, oldvyres, oldbpp, oldaccel;
896
897         DPRINTK("ENTER\n");
898         if ((err = do_fb_set_var(var, con == info->currcon))) {
899                 DPRINTK("EXIT - do_fb_set_var failed\n");
900                 return(err);
901         }
902         if ((var->activate & FB_ACTIVATE_MASK) == FB_ACTIVATE_NOW) {
903                 oldxres = fb_display[con].var.xres;
904                 oldyres = fb_display[con].var.yres;
905                 oldvxres = fb_display[con].var.xres_virtual;
906                 oldvyres = fb_display[con].var.yres_virtual;
907                 oldbpp = fb_display[con].var.bits_per_pixel;
908                 oldaccel = fb_display[con].var.accel_flags;
909                 fb_display[con].var = *var;
910                 if (oldxres != var->xres || oldyres != var->yres ||
911                     oldvxres != var->xres_virtual ||
912                     oldvyres != var->yres_virtual ||
913                     oldbpp != var->bits_per_pixel ||
914                     oldaccel != var->accel_flags) {
915                         cyberfb_set_disp(con, info);
916                         (*fb_info.changevar)(con);
917                         fb_alloc_cmap(&fb_display[con].cmap, 0, 0);
918                         do_install_cmap(con, info);
919                 }
920         }
921         var->activate = 0;
922         DPRINTK("EXIT\n");
923         return(0);
924 }
925
926
927 /*
928  *    Get the Colormap
929  */
930
931 static int cyberfb_get_cmap(struct fb_cmap *cmap, int kspc, int con,
932                             struct fb_info *info)
933 {
934         DPRINTK("ENTER\n");
935         if (con == info->currcon) { /* current console? */
936                 DPRINTK("EXIT - console is current console\n");
937                 return(fb_get_cmap(cmap, kspc, Cyber_getcolreg, info));
938         } else if (fb_display[con].cmap.len) { /* non default colormap? */
939                 DPRINTK("Use console cmap\n");
940                 fb_copy_cmap(&fb_display[con].cmap, cmap, kspc ? 0 : 2);
941         } else {
942                 DPRINTK("Use default cmap\n");
943                 fb_copy_cmap(fb_default_cmap(1<<fb_display[con].var.bits_per_pixel),
944                              cmap, kspc ? 0 : 2);
945         }
946         DPRINTK("EXIT\n");
947         return(0);
948 }
949
950 static struct fb_ops cyberfb_ops = {
951         .owner =        THIS_MODULE,
952         .fb_get_fix =   cyberfb_get_fix,
953         .fb_get_var =   cyberfb_get_var,
954         .fb_set_var =   cyberfb_set_var,
955         .fb_get_cmap =  cyberfb_get_cmap,
956         .fb_set_cmap =  gen_set_cmap,
957         .fb_setcolreg = cyberfb_setcolreg,
958         .fb_blank =     cyberfb_blank,
959 };
960
961 int __init cyberfb_setup(char *options)
962 {
963         char *this_opt;
964         DPRINTK("ENTER\n");
965
966         fb_info.fontname[0] = '\0';
967
968         if (!options || !*options) {
969                 DPRINTK("EXIT - no options\n");
970                 return 0;
971         }
972
973         while ((this_opt = strsep(&options, ",")) != NULL) {
974                 if (!*this_opt)
975                         continue;
976                 if (!strcmp(this_opt, "inverse")) {
977                         Cyberfb_inverse = 1;
978                         fb_invert_cmaps();
979                 } else if (!strncmp(this_opt, "font:", 5)) {
980                         strcpy(fb_info.fontname, this_opt+5);
981                 } else if (!strcmp (this_opt, "cyber8")) {
982                         cyberfb_default = cyberfb_predefined[CYBER8_DEFMODE].var;
983                         cyberfb_usermode = 1;
984                 } else if (!strcmp (this_opt, "cyber16")) {
985                         cyberfb_default = cyberfb_predefined[CYBER16_DEFMODE].var;
986                         cyberfb_usermode = 1;
987                 } else get_video_mode(this_opt);
988         }
989
990         DPRINTK("default mode: xres=%d, yres=%d, bpp=%d\n",
991                 cyberfb_default.xres,
992                 cyberfb_default.yres,
993                 cyberfb_default.bits_per_pixel);
994         DPRINTK("EXIT\n");
995         return 0;
996 }
997
998 /*
999  *    Initialization
1000  */
1001
1002 int __init cyberfb_init(void)
1003 {
1004         unsigned long board_addr, board_size;
1005         struct cyberfb_par par;
1006         struct zorro_dev *z = NULL;
1007         DPRINTK("ENTER\n");
1008
1009         while ((z = zorro_find_device(ZORRO_PROD_PHASE5_CYBERVISION64, z))) {
1010             board_addr = z->resource.start;
1011             board_size = z->resource.end-z->resource.start+1;
1012             CyberMem_phys = board_addr + 0x01400000;
1013             CyberRegs_phys = CyberMem_phys + 0x00c00000;
1014             if (!request_mem_region(CyberRegs_phys, 0x10000, "S3 Trio64"))
1015                 continue;
1016             if (!request_mem_region(CyberMem_phys, 0x400000, "RAM")) {
1017                 release_mem_region(CyberRegs_phys, 0x10000);
1018                 continue;
1019             }
1020             DPRINTK("board_addr=%08lx\n", board_addr);
1021             DPRINTK("board_size=%08lx\n", board_size);
1022
1023             CyberBase = ioremap(board_addr, board_size);
1024             CyberRegs = CyberBase + 0x02000000;
1025             CyberMem = CyberBase + 0x01400000;
1026             DPRINTK("CyberBase=%08lx CyberRegs=%08lx CyberMem=%08lx\n",
1027                     CyberBase, (long unsigned int)CyberRegs, CyberMem);
1028
1029 #ifdef CYBERFBDEBUG
1030             DPRINTK("Register state just after mapping memory\n");
1031             cv64_dump();
1032 #endif
1033
1034             strcpy(fb_info.modename, cyberfb_name);
1035             fb_info.changevar = NULL;
1036             fb_info.fbops = &cyberfb_ops;
1037             fb_info.screen_base = (unsigned char *)CyberMem;
1038             fb_info.disp = &disp;
1039             fb_info.currcon = -1;
1040             fb_info.switch_con = &Cyberfb_switch;
1041             fb_info.updatevar = &Cyberfb_updatevar;
1042
1043             Cyber_init();
1044             /* ++Andre: set cyberfb default mode */
1045             if (!cyberfb_usermode) {
1046                     cyberfb_default = cyberfb_predefined[CYBER8_DEFMODE].var;
1047                     DPRINTK("Use default cyber8 mode\n");
1048             }
1049             Cyber_decode_var(&cyberfb_default, &par);
1050             Cyber_encode_var(&cyberfb_default, &par);
1051
1052             do_fb_set_var(&cyberfb_default, 1);
1053             cyberfb_get_var(&fb_display[0].var, -1, &fb_info);
1054             cyberfb_set_disp(-1, &fb_info);
1055             do_install_cmap(0, &fb_info);
1056
1057             if (register_framebuffer(&fb_info) < 0) {
1058                     DPRINTK("EXIT - register_framebuffer failed\n");
1059                     release_mem_region(CyberMem_phys, 0x400000);
1060                     release_mem_region(CyberRegs_phys, 0x10000);
1061                     return -EINVAL;
1062             }
1063
1064             printk("fb%d: %s frame buffer device, using %ldK of video memory\n",
1065                    fb_info.node, fb_info.modename, CyberSize>>10);
1066
1067             /* TODO: This driver cannot be unloaded yet */
1068             DPRINTK("EXIT\n");
1069             return 0;
1070         }
1071         return -ENXIO;
1072 }
1073
1074
1075 static int Cyberfb_switch(int con, struct fb_info *info)
1076 {
1077         DPRINTK("ENTER\n");
1078         /* Do we have to save the colormap? */
1079         if (fb_display[info->currcon].cmap.len) {
1080                 fb_get_cmap(&fb_display[info->currcon].cmap, 1, Cyber_getcolreg,
1081                             info);
1082         }
1083
1084         do_fb_set_var(&fb_display[con].var, 1);
1085         info->currcon = con;
1086         /* Install new colormap */
1087         do_install_cmap(con, info);
1088         DPRINTK("EXIT\n");
1089         return(0);
1090 }
1091
1092
1093 /*
1094  *    Update the `var' structure (called by fbcon.c)
1095  *
1096  *    This call looks only at yoffset and the FB_VMODE_YWRAP flag in `var'.
1097  *    Since it's called by a kernel driver, no range checking is done.
1098  */
1099
1100 static int Cyberfb_updatevar(int con, struct fb_info *info)
1101 {
1102         DPRINTK("Enter - Exit\n");
1103         return(0);
1104 }
1105
1106
1107 /*
1108  *    Get a Video Mode
1109  */
1110
1111 static int __init get_video_mode(const char *name)
1112 {
1113         int i;
1114
1115         DPRINTK("ENTER\n");
1116         for (i = 0; i < NUM_TOTAL_MODES; i++) {
1117                 if (!strcmp(name, cyberfb_predefined[i].name)) {
1118                         cyberfb_default = cyberfb_predefined[i].var;
1119                         cyberfb_usermode = 1;
1120                         DPRINTK("EXIT - Matched predefined mode\n");
1121                         return(i);
1122                 }
1123         }
1124         return(0);
1125 }
1126
1127
1128 /*
1129  *    Text console acceleration
1130  */
1131
1132 #ifdef FBCON_HAS_CFB8
1133 static void fbcon_cyber8_bmove(struct display *p, int sy, int sx, int dy,
1134                                int dx, int height, int width)
1135 {
1136         DPRINTK("ENTER\n");
1137         sx *= 8; dx *= 8; width *= 8;
1138         Cyber_BitBLT((u_short)sx, (u_short)(sy*fontheight(p)), (u_short)dx,
1139                      (u_short)(dy*fontheight(p)), (u_short)width,
1140                      (u_short)(height*fontheight(p)), (u_short)S3_NEW);
1141         DPRINTK("EXIT\n");
1142 }
1143
1144 static void fbcon_cyber8_clear(struct vc_data *conp, struct display *p, int sy,
1145                                int sx, int height, int width)
1146 {
1147         unsigned char bg;
1148
1149         DPRINTK("ENTER\n");
1150         sx *= 8; width *= 8;
1151         bg = attr_bgcol_ec(p,conp);
1152         Cyber_RectFill((u_short)sx,
1153                        (u_short)(sy*fontheight(p)),
1154                        (u_short)width,
1155                        (u_short)(height*fontheight(p)),
1156                        (u_short)S3_NEW,
1157                        (u_short)bg);
1158         DPRINTK("EXIT\n");
1159 }
1160
1161 static void fbcon_cyber8_putc(struct vc_data *conp, struct display *p, int c,
1162                               int yy, int xx)
1163 {
1164         DPRINTK("ENTER\n");
1165         Cyber_WaitBlit();
1166         fbcon_cfb8_putc(conp, p, c, yy, xx);
1167         DPRINTK("EXIT\n");
1168 }
1169
1170 static void fbcon_cyber8_putcs(struct vc_data *conp, struct display *p,
1171                                const unsigned short *s, int count,
1172                                int yy, int xx)
1173 {
1174         DPRINTK("ENTER\n");
1175         Cyber_WaitBlit();
1176         fbcon_cfb8_putcs(conp, p, s, count, yy, xx);
1177         DPRINTK("EXIT\n");
1178 }
1179
1180 static void fbcon_cyber8_revc(struct display *p, int xx, int yy)
1181 {
1182         DPRINTK("ENTER\n");
1183         Cyber_WaitBlit();
1184         fbcon_cfb8_revc(p, xx, yy);
1185         DPRINTK("EXIT\n");
1186 }
1187
1188 static struct display_switch fbcon_cyber8 = {
1189         .setup =        fbcon_cfb8_setup,
1190         .bmove =        fbcon_cyber8_bmove,
1191         .clear =        fbcon_cyber8_clear,
1192         .putc =         fbcon_cyber8_putc,
1193         .putcs =        fbcon_cyber8_putcs,
1194         .revc =         fbcon_cyber8_revc,
1195         .clear_margins =fbcon_cfb8_clear_margins,
1196         .fontwidthmask =FONTWIDTH(8)
1197 };
1198 #endif
1199
1200
1201 #ifdef MODULE
1202 MODULE_LICENSE("GPL");
1203
1204 int init_module(void)
1205 {
1206         return cyberfb_init();
1207 }
1208 #endif /* MODULE */
1209
1210 /*
1211  *
1212  * Low level initialization routines for the CyberVision64 graphics card
1213  *
1214  * Most of the following code is from cvision_core.c
1215  *
1216  */
1217
1218 #define MAXPIXELCLOCK 135000000 /* safety */
1219
1220 #ifdef CV_AGGRESSIVE_TIMING
1221 long cv64_memclk = 55000000;
1222 #else
1223 long cv64_memclk = 50000000;
1224 #endif
1225
1226 /*********************/
1227
1228 static unsigned char clocks[]={
1229   0x13, 0x61, 0x6b, 0x6d, 0x51, 0x69, 0x54, 0x69,
1230   0x4f, 0x68, 0x6b, 0x6b, 0x18, 0x61, 0x7b, 0x6c,
1231   0x51, 0x67, 0x24, 0x62, 0x56, 0x67, 0x77, 0x6a,
1232   0x1d, 0x61, 0x53, 0x66, 0x6b, 0x68, 0x79, 0x69,
1233   0x7c, 0x69, 0x7f, 0x69, 0x22, 0x61, 0x54, 0x65,
1234   0x56, 0x65, 0x58, 0x65, 0x67, 0x66, 0x41, 0x63,
1235   0x27, 0x61, 0x13, 0x41, 0x37, 0x62, 0x6b, 0x4d,
1236   0x23, 0x43, 0x51, 0x49, 0x79, 0x66, 0x54, 0x49,
1237   0x7d, 0x66, 0x34, 0x56, 0x4f, 0x63, 0x1f, 0x42,
1238   0x6b, 0x4b, 0x7e, 0x4d, 0x18, 0x41, 0x2a, 0x43,
1239   0x7b, 0x4c, 0x74, 0x4b, 0x51, 0x47, 0x65, 0x49,
1240   0x24, 0x42, 0x68, 0x49, 0x56, 0x47, 0x75, 0x4a,
1241   0x77, 0x4a, 0x31, 0x43, 0x1d, 0x41, 0x71, 0x49,
1242   0x53, 0x46, 0x29, 0x42, 0x6b, 0x48, 0x1f, 0x41,
1243   0x79, 0x49, 0x6f, 0x48, 0x7c, 0x49, 0x38, 0x43,
1244   0x7f, 0x49, 0x5d, 0x46, 0x22, 0x41, 0x53, 0x45,
1245   0x54, 0x45, 0x55, 0x45, 0x56, 0x45, 0x57, 0x45,
1246   0x58, 0x45, 0x25, 0x41, 0x67, 0x46, 0x5b, 0x45,
1247   0x41, 0x43, 0x78, 0x47, 0x27, 0x41, 0x51, 0x44,
1248   0x13, 0x21, 0x7d, 0x47, 0x37, 0x42, 0x71, 0x46,
1249   0x6b, 0x2d, 0x14, 0x21, 0x23, 0x23, 0x7d, 0x2f,
1250   0x51, 0x29, 0x61, 0x2b, 0x79, 0x46, 0x1d, 0x22,
1251   0x54, 0x29, 0x45, 0x27, 0x7d, 0x46, 0x7f, 0x46,
1252   0x4f, 0x43, 0x2f, 0x41, 0x1f, 0x22, 0x6a, 0x2b,
1253   0x6b, 0x2b, 0x5b, 0x29, 0x7e, 0x2d, 0x65, 0x44,
1254   0x18, 0x21, 0x5e, 0x29, 0x2a, 0x23, 0x45, 0x26,
1255   0x7b, 0x2c, 0x19, 0x21, 0x74, 0x2b, 0x75, 0x2b,
1256   0x51, 0x27, 0x3f, 0x25, 0x65, 0x29, 0x40, 0x25,
1257   0x24, 0x22, 0x41, 0x25, 0x68, 0x29, 0x42, 0x25,
1258   0x56, 0x27, 0x7e, 0x2b, 0x75, 0x2a, 0x1c, 0x21,
1259   0x77, 0x2a, 0x4f, 0x26, 0x31, 0x23, 0x6f, 0x29,
1260   0x1d, 0x21, 0x32, 0x23, 0x71, 0x29, 0x72, 0x29,
1261   0x53, 0x26, 0x69, 0x28, 0x29, 0x22, 0x75, 0x29,
1262   0x6b, 0x28, 0x1f, 0x21, 0x1f, 0x21, 0x6d, 0x28,
1263   0x79, 0x29, 0x2b, 0x22, 0x6f, 0x28, 0x59, 0x26,
1264   0x7c, 0x29, 0x7d, 0x29, 0x38, 0x23, 0x21, 0x21,
1265   0x7f, 0x29, 0x39, 0x23, 0x5d, 0x26, 0x75, 0x28,
1266   0x22, 0x21, 0x77, 0x28, 0x53, 0x25, 0x6c, 0x27,
1267   0x54, 0x25, 0x61, 0x26, 0x55, 0x25, 0x30, 0x22,
1268   0x56, 0x25, 0x63, 0x26, 0x57, 0x25, 0x71, 0x27,
1269   0x58, 0x25, 0x7f, 0x28, 0x25, 0x21, 0x74, 0x27,
1270   0x67, 0x26, 0x40, 0x23, 0x5b, 0x25, 0x26, 0x21,
1271   0x41, 0x23, 0x34, 0x22, 0x78, 0x27, 0x6b, 0x26,
1272   0x27, 0x21, 0x35, 0x22, 0x51, 0x24, 0x7b, 0x27,
1273   0x13, 0x1,  0x13, 0x1,  0x7d, 0x27, 0x4c, 0x9,
1274   0x37, 0x22, 0x5b, 0xb,  0x71, 0x26, 0x5c, 0xb,
1275   0x6b, 0xd,  0x47, 0x23, 0x14, 0x1,  0x4f, 0x9,
1276   0x23, 0x3,  0x75, 0x26, 0x7d, 0xf,  0x1c, 0x2,
1277   0x51, 0x9,  0x59, 0x24, 0x61, 0xb,  0x69, 0x25,
1278   0x79, 0x26, 0x34, 0x5,  0x1d, 0x2,  0x6b, 0x25,
1279   0x54, 0x9,  0x35, 0x5,  0x45, 0x7,  0x6d, 0x25,
1280   0x7d, 0x26, 0x16, 0x1,  0x7f, 0x26, 0x77, 0xd,
1281   0x4f, 0x23, 0x78, 0xd,  0x2f, 0x21, 0x27, 0x3,
1282   0x1f, 0x2,  0x59, 0x9,  0x6a, 0xb,  0x73, 0x25,
1283   0x6b, 0xb,  0x63, 0x24, 0x5b, 0x9,  0x20, 0x2,
1284   0x7e, 0xd,  0x4b, 0x7,  0x65, 0x24, 0x43, 0x22,
1285   0x18, 0x1,  0x6f, 0xb,  0x5e, 0x9,  0x70, 0xb,
1286   0x2a, 0x3,  0x33, 0x4,  0x45, 0x6,  0x60, 0x9,
1287   0x7b, 0xc,  0x19, 0x1,  0x19, 0x1,  0x7d, 0xc,
1288   0x74, 0xb,  0x50, 0x7,  0x75, 0xb,  0x63, 0x9,
1289   0x51, 0x7,  0x23, 0x2,  0x3f, 0x5,  0x1a, 0x1,
1290   0x65, 0x9,  0x2d, 0x3,  0x40, 0x5,  0x0,  0x0,
1291 };
1292
1293 /* Console colors */
1294 unsigned char cvconscolors[16][3] = {   /* background, foreground, hilite */
1295   /*  R     G     B  */
1296   {0x30, 0x30, 0x30},
1297   {0x00, 0x00, 0x00},
1298   {0x80, 0x00, 0x00},
1299   {0x00, 0x80, 0x00},
1300   {0x00, 0x00, 0x80},
1301   {0x80, 0x80, 0x00},
1302   {0x00, 0x80, 0x80},
1303   {0x80, 0x00, 0x80},
1304   {0xff, 0xff, 0xff},
1305   {0x40, 0x40, 0x40},
1306   {0xff, 0x00, 0x00},
1307   {0x00, 0xff, 0x00},
1308   {0x00, 0x00, 0xff},
1309   {0xff, 0xff, 0x00},
1310   {0x00, 0xff, 0xff},
1311   {0x00, 0x00, 0xff}
1312 };
1313
1314 /* -------------------- Hardware specific routines ------------------------- */
1315
1316 /* Read Attribute Controller Register=idx */
1317 inline unsigned char RAttr (volatile unsigned char *regs, short idx)
1318 {
1319         wb_64 (regs, ACT_ADDRESS_W, idx);
1320         mb();
1321         udelay(100);
1322         return (rb_64(regs, ACT_ADDRESS_R));
1323 }
1324
1325 /* Read Sequencer Register=idx */
1326 inline unsigned char RSeq (volatile unsigned char *regs, short idx)
1327 {
1328         wb_64 (regs, SEQ_ADDRESS, idx);
1329         mb();
1330         return (rb_64(regs, SEQ_ADDRESS_R));
1331 }
1332
1333 /* Read CRT Controller Register=idx */
1334 inline unsigned char RCrt (volatile unsigned char *regs, short idx)
1335 {
1336         wb_64 (regs, CRT_ADDRESS, idx);
1337         mb();
1338         return (rb_64(regs, CRT_ADDRESS_R));
1339 }
1340
1341 /* Read Graphics Controller Register=idx */
1342 inline unsigned char RGfx (volatile unsigned char *regs, short idx)
1343 {
1344         wb_64 (regs, GCT_ADDRESS, idx);
1345         mb();
1346         return (rb_64(regs, GCT_ADDRESS_R));
1347 }
1348
1349 /*
1350  * Special wakeup/passthrough registers on graphics boards
1351  */
1352
1353 inline void cv64_write_port (unsigned short bits,
1354                              volatile unsigned char *base)
1355 {
1356         volatile unsigned char *addr;
1357         static unsigned char cvportbits = 0; /* Mirror port bits here */
1358         DPRINTK("ENTER\n");
1359
1360         addr = base + 0x40001;
1361         if (bits & 0x8000) {
1362                 cvportbits |= bits & 0xff; /* Set bits */
1363                 DPRINTK("Set bits: %04x\n", bits);
1364         } else {
1365                 bits = bits & 0xff;
1366                 bits = (~bits) & 0xff;
1367                 cvportbits &= bits; /* Clear bits */
1368                 DPRINTK("Clear bits: %04x\n", bits);
1369         }
1370
1371         *addr = cvportbits;
1372         DPRINTK("EXIT\n");
1373 }
1374
1375 /*
1376  * Monitor switch on CyberVision board
1377  *
1378  *  toggle:
1379  *    0 = CyberVision Signal
1380  *    1 = Amiga Signal
1381  *  board = board addr
1382  *
1383  */
1384 inline void cvscreen (int toggle, volatile unsigned char *board)
1385 {
1386         DPRINTK("ENTER\n");
1387         if (toggle == 1) {
1388                 DPRINTK("Show Amiga video\n");
1389                 cv64_write_port (0x10, board);
1390         } else {
1391                 DPRINTK("Show CyberVision video\n");
1392                 cv64_write_port (0x8010, board);
1393         }
1394         DPRINTK("EXIT\n");
1395 }
1396
1397 /* Control screen display */
1398 /* toggle: 0 = on, 1 = off */
1399 /* board = registerbase */
1400 inline void gfx_on_off(int toggle, volatile unsigned char *regs)
1401 {
1402         int r;
1403         DPRINTK("ENTER\n");
1404         
1405         toggle &= 0x1;
1406         toggle = toggle << 5;
1407         DPRINTK("Turn display %s\n", (toggle ? "off" : "on"));
1408         
1409         r = (int) RSeq(regs, SEQ_ID_CLOCKING_MODE);
1410         r &= 0xdf;      /* Set bit 5 to 0 */
1411         
1412         WSeq (regs, SEQ_ID_CLOCKING_MODE, r | toggle);
1413         DPRINTK("EXIT\n");
1414 }
1415
1416 /*
1417  * Computes M, N, and R values from
1418  * given input frequency. It uses a table of
1419  * precomputed values, to keep CPU time low.
1420  *
1421  * The return value consist of:
1422  * lower byte:  Bits 4-0: N Divider Value
1423  *              Bits 5-6: R Value          for e.g. SR10 or SR12
1424  * higher byte: Bits 0-6: M divider value  for e.g. SR11 or SR13
1425  */
1426 static unsigned short cv64_compute_clock(unsigned long freq)
1427 {
1428         static unsigned char *mnr, *save;       /* M, N + R vals */
1429         unsigned long work_freq, r;
1430         unsigned short erg;
1431         long diff, d2;
1432
1433         DPRINTK("ENTER\n");
1434         if (freq < 12500000 || freq > MAXPIXELCLOCK) {
1435                 printk("CV64 driver: Illegal clock frequency %ld, using 25MHz\n",
1436                        freq);
1437                 freq = 25000000;
1438         }
1439         DPRINTK("Freq = %ld\n", freq);
1440         mnr = clocks;   /* there the vals are stored */
1441         d2 = 0x7fffffff;
1442
1443         while (*mnr) {  /* mnr vals are 0-terminated */
1444                 work_freq = (0x37EE * (mnr[0] + 2)) / ((mnr[1] & 0x1F) + 2);
1445
1446                 r = (mnr[1] >> 5) & 0x03;
1447                 if (r != 0) {
1448                         work_freq = work_freq >> r;     /* r is the freq divider */
1449                 }
1450
1451                 work_freq *= 0x3E8;     /* 2nd part of OSC */
1452
1453                 diff = abs(freq - work_freq);
1454
1455                 if (d2 >= diff) {
1456                         d2 = diff;
1457                         /* In save are the vals for minimal diff */
1458                         save = mnr;
1459                 }
1460                 mnr += 2;
1461         }
1462         erg = *((unsigned short *)save);
1463
1464         DPRINTK("EXIT\n");
1465         return (erg);
1466 }
1467
1468 static int cv_has_4mb (volatile unsigned char *fb)
1469 {
1470         volatile unsigned long *tr, *tw;
1471         DPRINTK("ENTER\n");
1472
1473         /* write patterns in memory and test if they can be read */
1474         tw = (volatile unsigned long *) fb;
1475         tr = (volatile unsigned long *) (fb + 0x02000000);
1476
1477         *tw = 0x87654321;
1478         
1479         if (*tr != 0x87654321) {
1480                 DPRINTK("EXIT - <4MB\n");
1481                 return (0);
1482         }
1483
1484         /* upper memory region */
1485         tw = (volatile unsigned long *) (fb + 0x00200000);
1486         tr = (volatile unsigned long *) (fb + 0x02200000);
1487
1488         *tw = 0x87654321;
1489
1490         if (*tr != 0x87654321) {
1491                 DPRINTK("EXIT - <4MB\n");
1492                 return (0);
1493         }
1494
1495         *tw = 0xAAAAAAAA;
1496
1497         if (*tr != 0xAAAAAAAA) {
1498                 DPRINTK("EXIT - <4MB\n");
1499                 return (0);
1500         }
1501
1502         *tw = 0x55555555;
1503
1504         if (*tr != 0x55555555) {
1505                 DPRINTK("EXIT - <4MB\n");
1506                 return (0);
1507         }
1508
1509         DPRINTK("EXIT\n");
1510         return (1);
1511 }
1512
1513 static void cv64_board_init (void)
1514 {
1515         volatile unsigned char *regs = CyberRegs;
1516         int i;
1517         unsigned int clockpar;
1518         unsigned char test;
1519         
1520         DPRINTK("ENTER\n");
1521
1522         /*
1523          * Special CyberVision 64 board operations
1524          */
1525         /* Reset board */
1526         for (i = 0; i < 6; i++) {
1527                 cv64_write_port (0xff, CyberBase);
1528         }
1529         /* Return to operational mode */
1530         cv64_write_port (0x8004, CyberBase);
1531         
1532         /*
1533          * Generic (?) S3 chip wakeup
1534          */
1535         /* Disable I/O & memory decoders, video in setup mode */
1536         wb_64 (regs, SREG_VIDEO_SUBS_ENABLE, 0x10);
1537         /* Video responds to cmds, addrs & data */
1538         wb_64 (regs, SREG_OPTION_SELECT, 0x1);
1539         /* Enable I/O & memory decoders, video in operational mode */
1540         wb_64 (regs, SREG_VIDEO_SUBS_ENABLE, 0x8);
1541         /* VGA color emulation, enable cpu access to display mem */ 
1542         wb_64 (regs, GREG_MISC_OUTPUT_W, 0x03);
1543         /* Unlock S3 VGA regs */
1544         WCrt (regs, CRT_ID_REGISTER_LOCK_1, 0x48); 
1545         /* Unlock system control & extension registers */
1546         WCrt (regs, CRT_ID_REGISTER_LOCK_2, 0xA5);
1547 /* GRF - Enable interrupts */
1548         /* Enable enhanced regs access, Ready cntl 0 wait states */
1549         test = RCrt (regs, CRT_ID_SYSTEM_CONFIG);
1550         test = test | 0x01;             /* enable enhanced register access */
1551         test = test & 0xEF;             /* clear bit 4, 0 wait state */
1552         WCrt (regs, CRT_ID_SYSTEM_CONFIG, test);
1553         /*
1554          * bit 0=1: Enable enhaced mode functions
1555          * bit 2=0: Enhanced mode 8+ bits/pixel
1556          * bit 4=1: Enable linear addressing
1557          * bit 5=1: Enable MMIO
1558          */
1559         wb_64 (regs, ECR_ADV_FUNC_CNTL, 0x31);
1560         /*
1561          * bit 0=1: Color emulation
1562          * bit 1=1: Enable CPU access to display memory
1563          * bit 5=1: Select high 64K memory page
1564          */
1565 /* GRF - 0xE3 */
1566         wb_64 (regs, GREG_MISC_OUTPUT_W, 0x23);
1567         
1568         /* Cpu base addr */
1569         WCrt (regs, CRT_ID_EXT_SYS_CNTL_4, 0x0);
1570         
1571         /* Reset. This does nothing on Trio, but standard VGA practice */
1572         /* WSeq (CyberRegs, SEQ_ID_RESET, 0x03); */
1573         /* Character clocks 8 dots wide */
1574         WSeq (regs, SEQ_ID_CLOCKING_MODE, 0x01);
1575         /* Enable cpu write to all color planes */
1576         WSeq (regs, SEQ_ID_MAP_MASK, 0x0F);
1577         /* Font table in 1st 8k of plane 2, font A=B disables swtich */
1578         WSeq (regs, SEQ_ID_CHAR_MAP_SELECT, 0x0);
1579         /* Allow mem access to 256kb */
1580         WSeq (regs, SEQ_ID_MEMORY_MODE, 0x2);
1581         /* Unlock S3 extensions to VGA Sequencer regs */
1582         WSeq (regs, SEQ_ID_UNLOCK_EXT, 0x6);
1583         
1584         /* Enable 4MB fast page mode */
1585         test = RSeq (regs, SEQ_ID_BUS_REQ_CNTL);
1586         test = test | 1 << 6;
1587         WSeq (regs, SEQ_ID_BUS_REQ_CNTL, test);
1588         
1589         /* Faster LUT write: 1 DCLK LUT write cycle, RAMDAC clk doubled */
1590         WSeq (regs, SEQ_ID_RAMDAC_CNTL, 0xC0);
1591
1592         /* Clear immediate clock load bit */
1593         test = RSeq (regs, SEQ_ID_CLKSYN_CNTL_2);
1594         test = test & 0xDF;
1595         /* If > 55MHz, enable 2 cycle memory write */
1596         if (cv64_memclk >= 55000000) {
1597                 test |= 0x80;
1598         }
1599         WSeq (regs, SEQ_ID_CLKSYN_CNTL_2, test);
1600
1601         /* Set MCLK value */
1602         clockpar = cv64_compute_clock (cv64_memclk);
1603         test = (clockpar & 0xFF00) >> 8;
1604         WSeq (regs, SEQ_ID_MCLK_HI, test);
1605         test = clockpar & 0xFF;
1606         WSeq (regs, SEQ_ID_MCLK_LO, test);
1607
1608         /* Chip rev specific: Not in my Trio manual!!! */
1609         if (RCrt (regs, CRT_ID_REVISION) == 0x10)
1610                 WSeq (regs, SEQ_ID_MORE_MAGIC, test);
1611
1612         /* We now load an 25 MHz, 31kHz, 640x480 standard VGA Mode. */
1613
1614         /* Set DCLK value */
1615         WSeq (regs, SEQ_ID_DCLK_HI, 0x13);
1616         WSeq (regs, SEQ_ID_DCLK_LO, 0x41);
1617
1618         /* Load DCLK (and MCLK?) immediately */
1619         test = RSeq (regs, SEQ_ID_CLKSYN_CNTL_2);
1620         test = test | 0x22;
1621         WSeq (regs, SEQ_ID_CLKSYN_CNTL_2, test);
1622
1623         /* Enable loading of DCLK */
1624         test = rb_64(regs, GREG_MISC_OUTPUT_R);
1625         test = test | 0x0C;
1626         wb_64 (regs, GREG_MISC_OUTPUT_W, test);
1627
1628         /* Turn off immediate xCLK load */
1629         WSeq (regs, SEQ_ID_CLKSYN_CNTL_2, 0x2);
1630
1631         /* Horizontal character clock counts */
1632         /* 8 LSB of 9 bits = total line - 5 */
1633         WCrt (regs, CRT_ID_HOR_TOTAL, 0x5F);
1634         /* Active display line */
1635         WCrt (regs, CRT_ID_HOR_DISP_ENA_END, 0x4F);
1636         /* Blank assertion start */
1637         WCrt (regs, CRT_ID_START_HOR_BLANK, 0x50);
1638         /* Blank assertion end */
1639         WCrt (regs, CRT_ID_END_HOR_BLANK, 0x82);
1640         /* HSYNC assertion start */
1641         WCrt (regs, CRT_ID_START_HOR_RETR, 0x54);
1642         /* HSYNC assertion end */
1643         WCrt (regs, CRT_ID_END_HOR_RETR, 0x80);
1644         WCrt (regs, CRT_ID_VER_TOTAL, 0xBF);
1645         WCrt (regs, CRT_ID_OVERFLOW, 0x1F);
1646         WCrt (regs, CRT_ID_PRESET_ROW_SCAN, 0x0);
1647         WCrt (regs, CRT_ID_MAX_SCAN_LINE, 0x40);
1648         WCrt (regs, CRT_ID_CURSOR_START, 0x00);
1649         WCrt (regs, CRT_ID_CURSOR_END, 0x00);
1650         WCrt (regs, CRT_ID_START_ADDR_HIGH, 0x00);
1651         WCrt (regs, CRT_ID_START_ADDR_LOW, 0x00);
1652         WCrt (regs, CRT_ID_CURSOR_LOC_HIGH, 0x00);
1653         WCrt (regs, CRT_ID_CURSOR_LOC_LOW, 0x00);
1654         WCrt (regs, CRT_ID_START_VER_RETR, 0x9C);
1655         WCrt (regs, CRT_ID_END_VER_RETR, 0x0E);
1656         WCrt (regs, CRT_ID_VER_DISP_ENA_END, 0x8F);
1657         WCrt (regs, CRT_ID_SCREEN_OFFSET, 0x50);
1658         WCrt (regs, CRT_ID_UNDERLINE_LOC, 0x00);
1659         WCrt (regs, CRT_ID_START_VER_BLANK, 0x96);
1660         WCrt (regs, CRT_ID_END_VER_BLANK, 0xB9);
1661         WCrt (regs, CRT_ID_MODE_CONTROL, 0xE3);
1662         WCrt (regs, CRT_ID_LINE_COMPARE, 0xFF);
1663         WCrt (regs, CRT_ID_BACKWAD_COMP_3, 0x10);       /* FIFO enabled */
1664         WCrt (regs, CRT_ID_MISC_1, 0x35);
1665         WCrt (regs, CRT_ID_DISPLAY_FIFO, 0x5A);
1666         WCrt (regs, CRT_ID_EXT_MEM_CNTL_2, 0x70);
1667         WCrt (regs, CRT_ID_LAW_POS_LO, 0x40);
1668         WCrt (regs, CRT_ID_EXT_MEM_CNTL_3, 0xFF);
1669
1670         WGfx (regs, GCT_ID_SET_RESET, 0x0);
1671         WGfx (regs, GCT_ID_ENABLE_SET_RESET, 0x0);
1672         WGfx (regs, GCT_ID_COLOR_COMPARE, 0x0);
1673         WGfx (regs, GCT_ID_DATA_ROTATE, 0x0);
1674         WGfx (regs, GCT_ID_READ_MAP_SELECT, 0x0);
1675         WGfx (regs, GCT_ID_GRAPHICS_MODE, 0x40);
1676         WGfx (regs, GCT_ID_MISC, 0x01);
1677         WGfx (regs, GCT_ID_COLOR_XCARE, 0x0F);
1678         WGfx (regs, GCT_ID_BITMASK, 0xFF);
1679
1680         /* Colors for text mode */
1681         for (i = 0; i < 0xf; i++)
1682                 WAttr (regs, i, i);
1683
1684         WAttr (regs, ACT_ID_ATTR_MODE_CNTL, 0x41);
1685         WAttr (regs, ACT_ID_OVERSCAN_COLOR, 0x01);
1686         WAttr (regs, ACT_ID_COLOR_PLANE_ENA, 0x0F);
1687         WAttr (regs, ACT_ID_HOR_PEL_PANNING, 0x0);
1688         WAttr (regs, ACT_ID_COLOR_SELECT, 0x0);
1689
1690         wb_64 (regs, VDAC_MASK, 0xFF);
1691
1692         *((unsigned long *) (regs + ECR_FRGD_COLOR)) = 0xFF;
1693         *((unsigned long *) (regs + ECR_BKGD_COLOR)) = 0;
1694
1695         /* Colors initially set to grayscale */
1696
1697         wb_64 (regs, VDAC_ADDRESS_W, 0);
1698         for (i = 255; i >= 0; i--) {
1699                 wb_64(regs, VDAC_DATA, i);
1700                 wb_64(regs, VDAC_DATA, i);
1701                 wb_64(regs, VDAC_DATA, i);
1702         }
1703
1704         /* GFx hardware cursor off */
1705         WCrt (regs, CRT_ID_HWGC_MODE, 0x00);
1706
1707         /* Set first to 4MB, so test will work */
1708         WCrt (regs, CRT_ID_LAW_CNTL, 0x13);
1709         /* Find "correct" size of fbmem of Z3 board */
1710         if (cv_has_4mb (CyberMem)) {
1711                 CyberSize = 1024 * 1024 * 4;
1712                 WCrt (regs, CRT_ID_LAW_CNTL, 0x13);
1713                 DPRINTK("4MB board\n");
1714         } else {
1715                 CyberSize = 1024 * 1024 * 2;
1716                 WCrt (regs, CRT_ID_LAW_CNTL, 0x12);
1717                 DPRINTK("2MB board\n");
1718         }
1719
1720         /* Initialize graphics engine */
1721         Cyber_WaitBlit();
1722         vgaw16 (regs, ECR_FRGD_MIX, 0x27);
1723         vgaw16 (regs, ECR_BKGD_MIX, 0x07);
1724         vgaw16 (regs, ECR_READ_REG_DATA, 0x1000);
1725         udelay(200);
1726         vgaw16 (regs, ECR_READ_REG_DATA, 0x2000);
1727         Cyber_WaitBlit();
1728         vgaw16 (regs, ECR_READ_REG_DATA, 0x3FFF);
1729         Cyber_WaitBlit();
1730         udelay(200);
1731         vgaw16 (regs, ECR_READ_REG_DATA, 0x4FFF);
1732         Cyber_WaitBlit();
1733         vgaw16 (regs, ECR_BITPLANE_WRITE_MASK, ~0);
1734         Cyber_WaitBlit();
1735         vgaw16 (regs, ECR_READ_REG_DATA, 0xE000);
1736         vgaw16 (regs, ECR_CURRENT_Y_POS2, 0x00);
1737         vgaw16 (regs, ECR_CURRENT_X_POS2, 0x00);
1738         vgaw16 (regs, ECR_READ_REG_DATA, 0xA000);
1739         vgaw16 (regs, ECR_DEST_Y__AX_STEP, 0x00);
1740         vgaw16 (regs, ECR_DEST_Y2__AX_STEP2, 0x00);
1741         vgaw16 (regs, ECR_DEST_X__DIA_STEP, 0x00);
1742         vgaw16 (regs, ECR_DEST_X2__DIA_STEP2, 0x00);
1743         vgaw16 (regs, ECR_SHORT_STROKE, 0x00);
1744         vgaw16 (regs, ECR_DRAW_CMD, 0x01);
1745
1746         Cyber_WaitBlit();
1747
1748         vgaw16 (regs, ECR_READ_REG_DATA, 0x4FFF);
1749         vgaw16 (regs, ECR_BKGD_COLOR, 0x01);
1750         vgaw16 (regs, ECR_FRGD_COLOR, 0x00);
1751
1752
1753         /* Enable video display (set bit 5) */
1754 /* ARB - Would also seem to write to AR13.
1755  *       May want to use parts of WAttr to set JUST bit 5
1756  */
1757         WAttr (regs, 0x33, 0);
1758         
1759 /* GRF - function code ended here */
1760
1761         /* Turn gfx on again */
1762         gfx_on_off (0, regs);
1763
1764         /* Pass-through */
1765         cvscreen (0, CyberBase);
1766
1767         DPRINTK("EXIT\n");
1768 }
1769
1770 static void cv64_load_video_mode (struct fb_var_screeninfo *video_mode)
1771 {
1772   volatile unsigned char *regs = CyberRegs;
1773   int fx, fy;
1774   unsigned short mnr;
1775   unsigned short HT, HDE, HBS, HBE, HSS, HSE, VDE, VBS, VBE, VSS, VSE, VT;
1776   char LACE, DBLSCAN, TEXT, CONSOLE;
1777   int cr50, sr15, sr18, clock_mode, test;
1778   int m, n;
1779   int tfillm, temptym;
1780   int hmul;
1781         
1782   /* ---------------- */
1783   int xres, hfront, hsync, hback;
1784   int yres, vfront, vsync, vback;
1785   int bpp;
1786 #if 0
1787   float freq_f;
1788 #endif
1789   long freq;
1790   /* ---------------- */
1791         
1792   DPRINTK("ENTER\n");
1793   TEXT = 0;     /* if depth == 4 */
1794   CONSOLE = 0;  /* mode num == 255 (console) */
1795   fx = fy = 8;  /* force 8x8 font */
1796
1797 /* GRF - Disable interrupts */  
1798         
1799   gfx_on_off (1, regs);
1800         
1801   switch (video_mode->bits_per_pixel) {
1802   case 15:
1803   case 16:
1804     hmul = 2;
1805     break;
1806                 
1807   default:
1808     hmul = 1;
1809     break;
1810   }
1811         
1812   bpp = video_mode->bits_per_pixel;
1813   xres = video_mode->xres;
1814   hfront = video_mode->right_margin;
1815   hsync = video_mode->hsync_len;
1816   hback = video_mode->left_margin;
1817
1818   LACE = 0;
1819   DBLSCAN = 0;
1820
1821   if (video_mode->vmode & FB_VMODE_DOUBLE) {
1822     yres = video_mode->yres * 2;
1823     vfront = video_mode->lower_margin * 2;
1824     vsync = video_mode->vsync_len * 2;
1825     vback = video_mode->upper_margin * 2;
1826     DBLSCAN = 1;
1827   } else if (video_mode->vmode & FB_VMODE_INTERLACED) {
1828     yres = (video_mode->yres + 1) / 2;
1829     vfront = (video_mode->lower_margin + 1) / 2;
1830     vsync = (video_mode->vsync_len + 1) / 2;
1831     vback = (video_mode->upper_margin + 1) / 2;
1832     LACE = 1;
1833   } else {
1834     yres = video_mode->yres;
1835     vfront = video_mode->lower_margin;
1836     vsync = video_mode->vsync_len;
1837     vback = video_mode->upper_margin;
1838   }
1839
1840   /* ARB Dropping custom setup method from cvision.c */
1841 #if 0
1842   if (cvision_custom_mode) {
1843     HBS = hbs / 8 * hmul;
1844     HBE = hbe / 8 * hmul;
1845     HSS = hss / 8 * hmul;
1846     HSE = hse / 8 * hmul;
1847     HT  = ht / 8 * hmul - 5;
1848                 
1849     VBS = vbs - 1;
1850     VSS = vss;
1851     VSE = vse;
1852     VBE = vbe;
1853     VT  = vt - 2;
1854   } else {
1855 #else
1856     {
1857 #endif
1858     HBS = hmul * (xres / 8);
1859     HBE = hmul * ((xres/8) + (hfront/8) + (hsync/8) + (hback/8) - 2);
1860     HSS = hmul * ((xres/8) + (hfront/8) + 2);
1861     HSE = hmul * ((xres/8) + (hfront/8) + (hsync/8) + 1);
1862     HT  = hmul * ((xres/8) + (hfront/8) + (hsync/8) + (hback/8));
1863         
1864     VBS = yres;
1865     VBE = yres + vfront + vsync + vback - 2;
1866     VSS = yres + vfront - 1;
1867     VSE = yres + vfront + vsync - 1;
1868     VT  = yres + vfront + vsync + vback - 2;
1869   }
1870
1871   wb_64 (regs, ECR_ADV_FUNC_CNTL, (TEXT ? 0x00 : 0x31));
1872         
1873   if (TEXT)
1874     HDE = ((video_mode->xres + fx - 1) / fx) - 1;
1875   else
1876     HDE = (video_mode->xres + 3) * hmul / 8 - 1;
1877         
1878   VDE = video_mode->yres - 1;
1879
1880   WCrt (regs, CRT_ID_HWGC_MODE, 0x00);
1881   WCrt (regs, CRT_ID_EXT_DAC_CNTL, 0x00);
1882         
1883   WSeq (regs, SEQ_ID_MEMORY_MODE,
1884         (TEXT || (video_mode->bits_per_pixel == 1)) ? 0x06 : 0x0e);
1885   WGfx (regs, GCT_ID_READ_MAP_SELECT, 0x00);
1886   WSeq (regs, SEQ_ID_MAP_MASK,
1887         (video_mode->bits_per_pixel == 1) ? 0x01 : 0xFF);
1888   WSeq (regs, SEQ_ID_CHAR_MAP_SELECT, 0x00);
1889         
1890   /* cv64_compute_clock accepts arguments in Hz */
1891   /* pixclock is in ps ... convert to Hz */
1892         
1893 #if 0
1894   freq_f = (1.0 / (float) video_mode->pixclock) * 1000000000;
1895   freq = ((long) freq_f) * 1000;
1896 #else
1897 /* freq = (long) ((long long)1000000000000 / (long long) video_mode->pixclock);
1898  */
1899   freq = (1000000000 / video_mode->pixclock) * 1000;
1900 #endif
1901
1902   mnr = cv64_compute_clock (freq);
1903   WSeq (regs, SEQ_ID_DCLK_HI, ((mnr & 0xFF00) >> 8));
1904   WSeq (regs, SEQ_ID_DCLK_LO, (mnr & 0xFF));
1905         
1906   /* Load display parameters into board */
1907   WCrt (regs, CRT_ID_EXT_HOR_OVF,
1908         ((HT & 0x100) ? 0x01 : 0x00) |
1909         ((HDE & 0x100) ? 0x02 : 0x00) |
1910         ((HBS & 0x100) ? 0x04 : 0x00) |
1911         /* ((HBE & 0x40) ? 0x08 : 0x00) | */
1912         ((HSS & 0x100) ? 0x10 : 0x00) |
1913         /* ((HSE & 0x20) ? 0x20 : 0x00) | */
1914         (((HT-5) & 0x100) ? 0x40 : 0x00)
1915         );
1916         
1917   WCrt (regs, CRT_ID_EXT_VER_OVF,
1918         0x40 |
1919         ((VT & 0x400) ? 0x01 : 0x00) |
1920         ((VDE & 0x400) ? 0x02 : 0x00) |
1921         ((VBS & 0x400) ? 0x04 : 0x00) |
1922         ((VSS & 0x400) ? 0x10 : 0x00)
1923         );
1924         
1925   WCrt (regs, CRT_ID_HOR_TOTAL, HT);
1926   WCrt (regs, CRT_ID_DISPLAY_FIFO, HT - 5);
1927   WCrt (regs, CRT_ID_HOR_DISP_ENA_END, ((HDE >= HBS) ? (HBS - 1) : HDE));
1928   WCrt (regs, CRT_ID_START_HOR_BLANK, HBS);
1929   WCrt (regs, CRT_ID_END_HOR_BLANK, ((HBE & 0x1F) | 0x80));
1930   WCrt (regs, CRT_ID_START_HOR_RETR, HSS);
1931   WCrt (regs, CRT_ID_END_HOR_RETR,
1932         (HSE & 0x1F) |
1933         ((HBE & 0x20) ? 0x80 : 0x00)
1934         );
1935   WCrt (regs, CRT_ID_VER_TOTAL, VT);
1936   WCrt (regs, CRT_ID_OVERFLOW,
1937         0x10 |
1938         ((VT & 0x100) ? 0x01 : 0x00) |
1939         ((VDE & 0x100) ? 0x02 : 0x00) |
1940         ((VSS & 0x100) ? 0x04 : 0x00) |
1941         ((VBS & 0x100) ? 0x08 : 0x00) |
1942         ((VT & 0x200) ? 0x20 : 0x00) |
1943         ((VDE & 0x200) ? 0x40 : 0x00) |
1944         ((VSS & 0x200) ? 0x80 : 0x00)
1945         );
1946   WCrt (regs, CRT_ID_MAX_SCAN_LINE,
1947         0x40 |
1948         (DBLSCAN ? 0x80 : 0x00) |
1949         ((VBS & 0x200) ? 0x20 : 0x00) |
1950         (TEXT ? ((fy - 1) & 0x1F) : 0x00)
1951         );
1952         
1953   WCrt (regs, CRT_ID_MODE_CONTROL, 0xE3);
1954
1955   /* Text cursor */
1956         
1957   if (TEXT) {
1958 #if 1
1959     WCrt (regs, CRT_ID_CURSOR_START, (fy & 0x1f) - 2);
1960     WCrt (regs, CRT_ID_CURSOR_END, (fy & 0x1F) - 1);
1961 #else
1962     WCrt (regs, CRT_ID_CURSOR_START, 0x00);
1963     WCrt (regs, CRT_ID_CURSOR_END, fy & 0x1F);
1964 #endif
1965     WCrt (regs, CRT_ID_UNDERLINE_LOC, (fy - 1) & 0x1F);
1966     WCrt (regs, CRT_ID_CURSOR_LOC_HIGH, 0x00);
1967     WCrt (regs, CRT_ID_CURSOR_LOC_LOW, 0x00);
1968   }
1969         
1970   WCrt (regs, CRT_ID_START_ADDR_HIGH, 0x00);
1971   WCrt (regs, CRT_ID_START_ADDR_LOW, 0x00);
1972   WCrt (regs, CRT_ID_START_VER_RETR, VSS);
1973   WCrt (regs, CRT_ID_END_VER_RETR, (VSE & 0x0F));
1974   WCrt (regs, CRT_ID_VER_DISP_ENA_END, VDE);
1975   WCrt (regs, CRT_ID_START_VER_BLANK, VBS);
1976   WCrt (regs, CRT_ID_END_VER_BLANK, VBE);
1977   WCrt (regs, CRT_ID_LINE_COMPARE, 0xFF);
1978   WCrt (regs, CRT_ID_LACE_RETR_START, HT / 2);
1979   WCrt (regs, CRT_ID_LACE_CONTROL, (LACE ? 0x20 : 0x00));
1980   WGfx (regs, GCT_ID_GRAPHICS_MODE,
1981         ((TEXT || (video_mode->bits_per_pixel == 1)) ? 0x00 : 0x40));
1982   WGfx (regs, GCT_ID_MISC, (TEXT ? 0x04 : 0x01));
1983   WSeq (regs, SEQ_ID_MEMORY_MODE,
1984         ((TEXT || (video_mode->bits_per_pixel == 1)) ? 0x06 : 0x02));
1985         
1986   wb_64 (regs, VDAC_MASK, 0xFF);
1987         
1988   /* Blank border */
1989   test = RCrt (regs, CRT_ID_BACKWAD_COMP_2);
1990   WCrt (regs, CRT_ID_BACKWAD_COMP_2, (test | 0x20));
1991         
1992   sr15 = RSeq (regs, SEQ_ID_CLKSYN_CNTL_2);
1993   sr15 &= 0xEF;
1994   sr18 = RSeq (regs, SEQ_ID_RAMDAC_CNTL);
1995   sr18 &= 0x7F;
1996   clock_mode = 0x00;
1997   cr50 = 0x00;
1998         
1999   test = RCrt (regs, CRT_ID_EXT_MISC_CNTL_2);
2000   test &= 0xD;
2001         
2002   /* Clear roxxler byte-swapping... */
2003   cv64_write_port (0x0040, CyberBase);
2004   cv64_write_port (0x0020, CyberBase);
2005         
2006   switch (video_mode->bits_per_pixel) {
2007   case 1:
2008   case 4:       /* text */
2009     HDE = video_mode->xres / 16;
2010     break;
2011                 
2012   case 8:
2013     if (freq > 80000000) {
2014       clock_mode = 0x10 | 0x02;
2015       sr15 |= 0x10;
2016       sr18 |= 0x80;
2017     }
2018     HDE = video_mode->xres / 8;
2019     cr50 |= 0x00;
2020     break;
2021                 
2022   case 15:
2023     cv64_write_port (0x8020, CyberBase);
2024     clock_mode = 0x30;
2025     HDE = video_mode->xres / 4;
2026     cr50 |= 0x10;
2027     break;
2028                 
2029   case 16:
2030     cv64_write_port (0x8020, CyberBase);
2031     clock_mode = 0x50;
2032     HDE = video_mode->xres / 4;
2033     cr50 |= 0x10;
2034     break;
2035                 
2036   case 24:
2037   case 32:
2038     cv64_write_port (0x8040, CyberBase);
2039     clock_mode = 0xD0;
2040     HDE = video_mode->xres / 2;
2041     cr50 |= 0x30;
2042     break;
2043   }
2044
2045   WCrt (regs, CRT_ID_EXT_MISC_CNTL_2, clock_mode | test);
2046   WSeq (regs, SEQ_ID_CLKSYN_CNTL_2, sr15);
2047   WSeq (regs, SEQ_ID_RAMDAC_CNTL, sr18);
2048   WCrt (regs, CRT_ID_SCREEN_OFFSET, HDE);
2049
2050   WCrt (regs, CRT_ID_MISC_1, (TEXT ? 0x05 : 0x35));
2051         
2052   test = RCrt (regs, CRT_ID_EXT_SYS_CNTL_2);
2053   test &= ~0x30;
2054   test |= (HDE >> 4) & 0x30;
2055   WCrt (regs, CRT_ID_EXT_SYS_CNTL_2, test);
2056         
2057   /* Set up graphics engine */
2058   switch (video_mode->xres) {
2059   case 1024:
2060     cr50 |= 0x00;
2061     break;
2062                 
2063   case 640:
2064     cr50 |= 0x40;
2065     break;
2066                 
2067   case 800:
2068     cr50 |= 0x80;
2069     break;
2070                 
2071   case 1280:
2072     cr50 |= 0xC0;
2073     break;
2074                 
2075   case 1152:
2076     cr50 |= 0x01;
2077     break;
2078                 
2079   case 1600:
2080     cr50 |= 0x81;
2081     break;
2082                 
2083   default:      /* XXX */
2084     break;
2085   }
2086         
2087   WCrt (regs, CRT_ID_EXT_SYS_CNTL_1, cr50);
2088         
2089   udelay(100);
2090   WAttr (regs, ACT_ID_ATTR_MODE_CNTL, (TEXT ? 0x08 : 0x41));
2091   udelay(100);
2092   WAttr (regs, ACT_ID_COLOR_PLANE_ENA,
2093          (video_mode->bits_per_pixel == 1) ? 0x01 : 0x0F);
2094   udelay(100);
2095         
2096   tfillm = (96 * (cv64_memclk / 1000)) / 240000;
2097         
2098   switch (video_mode->bits_per_pixel) {
2099   case 32:
2100   case 24:
2101     temptym = (24 * (cv64_memclk / 1000)) / (freq / 1000);
2102     break;
2103   case 15:
2104   case 16:
2105     temptym = (48 * (cv64_memclk / 1000)) / (freq / 1000);
2106     break;
2107   case 4:
2108     temptym = (192 * (cv64_memclk / 1000)) / (freq / 1000);
2109     break;
2110   default:
2111     temptym = (96 * (cv64_memclk / 1000)) / (freq / 1000);
2112     break;
2113   }
2114         
2115   m = (temptym - tfillm - 9) / 2;
2116   if (m < 0)
2117     m = 0;
2118   m = (m & 0x1F) << 3;
2119   if (m < 0x18)
2120     m = 0x18;
2121   n = 0xFF;
2122         
2123   WCrt (regs, CRT_ID_EXT_MEM_CNTL_2, m);
2124   WCrt (regs, CRT_ID_EXT_MEM_CNTL_3, n);
2125   udelay(10);
2126         
2127   /* Text initialization */
2128         
2129   if (TEXT) {
2130     /* Do text initialization here ! */
2131   }
2132         
2133   if (CONSOLE) {
2134     int i;
2135     wb_64 (regs, VDAC_ADDRESS_W, 0);
2136     for (i = 0; i < 4; i++) {
2137       wb_64 (regs, VDAC_DATA, cvconscolors [i][0]);
2138       wb_64 (regs, VDAC_DATA, cvconscolors [i][1]);
2139       wb_64 (regs, VDAC_DATA, cvconscolors [i][2]);
2140     }
2141   }
2142         
2143   WAttr (regs, 0x33, 0);
2144         
2145   /* Turn gfx on again */
2146   gfx_on_off (0, (volatile unsigned char *) regs);
2147         
2148   /* Pass-through */
2149   cvscreen (0, CyberBase);
2150
2151 DPRINTK("EXIT\n");
2152 }
2153
2154 void cvision_bitblt (u_short sx, u_short sy, u_short dx, u_short dy,
2155                      u_short w, u_short h)
2156 {
2157         volatile unsigned char *regs = CyberRegs;
2158         unsigned short drawdir = 0;
2159         
2160         DPRINTK("ENTER\n");
2161         if (sx > dx) {
2162                 drawdir |= 1 << 5;
2163         } else {
2164                 sx += w - 1;
2165                 dx += w - 1;
2166         }
2167         
2168         if (sy > dy) {
2169                 drawdir |= 1 << 7;
2170         } else {
2171                 sy += h - 1;
2172                 dy += h - 1;
2173         }
2174         
2175         Cyber_WaitBlit();
2176         vgaw16 (regs, ECR_READ_REG_DATA, 0xA000);
2177         vgaw16 (regs, ECR_BKGD_MIX, 0x7);
2178         vgaw16 (regs, ECR_FRGD_MIX, 0x67);
2179         vgaw16 (regs, ECR_BKGD_COLOR, 0x0);
2180         vgaw16 (regs, ECR_FRGD_COLOR, 0x1);
2181         vgaw16 (regs, ECR_BITPLANE_READ_MASK, 0x1);
2182         vgaw16 (regs, ECR_BITPLANE_WRITE_MASK, 0xFFF);
2183         vgaw16 (regs, ECR_CURRENT_Y_POS, sy);
2184         vgaw16 (regs, ECR_CURRENT_X_POS, sx);
2185         vgaw16 (regs, ECR_DEST_Y__AX_STEP, dy);
2186         vgaw16 (regs, ECR_DEST_X__DIA_STEP, dx);
2187         vgaw16 (regs, ECR_READ_REG_DATA, h - 1);
2188         vgaw16 (regs, ECR_MAJ_AXIS_PIX_CNT, w - 1);
2189         vgaw16 (regs, ECR_DRAW_CMD, 0xC051 | drawdir);
2190         DPRINTK("EXIT\n");
2191 }
2192
2193 void cvision_clear (u_short dx, u_short dy, u_short w, u_short h, u_short bg)
2194 {
2195         volatile unsigned char *regs = CyberRegs;
2196         DPRINTK("ENTER\n");
2197         Cyber_WaitBlit();
2198         vgaw16 (regs, ECR_FRGD_MIX, 0x0027);
2199         vgaw16 (regs, ECR_FRGD_COLOR, bg);
2200         vgaw16 (regs, ECR_READ_REG_DATA, 0xA000);
2201         vgaw16 (regs, ECR_CURRENT_Y_POS, dy);
2202         vgaw16 (regs, ECR_CURRENT_X_POS, dx);
2203         vgaw16 (regs, ECR_READ_REG_DATA, h - 1);
2204         vgaw16 (regs, ECR_MAJ_AXIS_PIX_CNT, w - 1);
2205         vgaw16 (regs, ECR_DRAW_CMD, 0x40B1);    
2206         DPRINTK("EXIT\n");
2207 }
2208
2209 #ifdef CYBERFBDEBUG
2210 /*
2211  * Dump internal settings of CyberVision board
2212  */
2213 static void cv64_dump (void)
2214 {
2215         volatile unsigned char *regs = CyberRegs;
2216         DPRINTK("ENTER\n");
2217         /* Dump the VGA setup values */
2218         *(regs + S3_CRTC_ADR) = 0x00;
2219         DPRINTK("CR00 = %x\n", *(regs + S3_CRTC_DATA));
2220         *(regs + S3_CRTC_ADR) = 0x01;
2221         DPRINTK("CR01 = %x\n", *(regs + S3_CRTC_DATA));
2222         *(regs + S3_CRTC_ADR) = 0x02;
2223         DPRINTK("CR02 = %x\n", *(regs + S3_CRTC_DATA));
2224         *(regs + S3_CRTC_ADR) = 0x03;
2225         DPRINTK("CR03 = %x\n", *(regs + S3_CRTC_DATA));
2226         *(regs + S3_CRTC_ADR) = 0x04;
2227         DPRINTK("CR04 = %x\n", *(regs + S3_CRTC_DATA));
2228         *(regs + S3_CRTC_ADR) = 0x05;
2229         DPRINTK("CR05 = %x\n", *(regs + S3_CRTC_DATA));
2230         *(regs + S3_CRTC_ADR) = 0x06;
2231         DPRINTK("CR06 = %x\n", *(regs + S3_CRTC_DATA));
2232         *(regs + S3_CRTC_ADR) = 0x07;
2233         DPRINTK("CR07 = %x\n", *(regs + S3_CRTC_DATA));
2234         *(regs + S3_CRTC_ADR) = 0x08;
2235         DPRINTK("CR08 = %x\n", *(regs + S3_CRTC_DATA));
2236         *(regs + S3_CRTC_ADR) = 0x09;
2237         DPRINTK("CR09 = %x\n", *(regs + S3_CRTC_DATA));
2238         *(regs + S3_CRTC_ADR) = 0x10;
2239         DPRINTK("CR10 = %x\n", *(regs + S3_CRTC_DATA));
2240         *(regs + S3_CRTC_ADR) = 0x11;
2241         DPRINTK("CR11 = %x\n", *(regs + S3_CRTC_DATA));
2242         *(regs + S3_CRTC_ADR) = 0x12;
2243         DPRINTK("CR12 = %x\n", *(regs + S3_CRTC_DATA));
2244         *(regs + S3_CRTC_ADR) = 0x13;
2245         DPRINTK("CR13 = %x\n", *(regs + S3_CRTC_DATA));
2246         *(regs + S3_CRTC_ADR) = 0x15;
2247         DPRINTK("CR15 = %x\n", *(regs + S3_CRTC_DATA));
2248         *(regs + S3_CRTC_ADR) = 0x16;
2249         DPRINTK("CR16 = %x\n", *(regs + S3_CRTC_DATA));
2250         *(regs + S3_CRTC_ADR) = 0x36;
2251         DPRINTK("CR36 = %x\n", *(regs + S3_CRTC_DATA));
2252         *(regs + S3_CRTC_ADR) = 0x37;
2253         DPRINTK("CR37 = %x\n", *(regs + S3_CRTC_DATA));
2254         *(regs + S3_CRTC_ADR) = 0x42;
2255         DPRINTK("CR42 = %x\n", *(regs + S3_CRTC_DATA));
2256         *(regs + S3_CRTC_ADR) = 0x43;
2257         DPRINTK("CR43 = %x\n", *(regs + S3_CRTC_DATA));
2258         *(regs + S3_CRTC_ADR) = 0x50;
2259         DPRINTK("CR50 = %x\n", *(regs + S3_CRTC_DATA));
2260         *(regs + S3_CRTC_ADR) = 0x51;
2261         DPRINTK("CR51 = %x\n", *(regs + S3_CRTC_DATA));
2262         *(regs + S3_CRTC_ADR) = 0x53;
2263         DPRINTK("CR53 = %x\n", *(regs + S3_CRTC_DATA));
2264         *(regs + S3_CRTC_ADR) = 0x58;
2265         DPRINTK("CR58 = %x\n", *(regs + S3_CRTC_DATA));
2266         *(regs + S3_CRTC_ADR) = 0x59;
2267         DPRINTK("CR59 = %x\n", *(regs + S3_CRTC_DATA));
2268         *(regs + S3_CRTC_ADR) = 0x5A;
2269         DPRINTK("CR5A = %x\n", *(regs + S3_CRTC_DATA));
2270         *(regs + S3_CRTC_ADR) = 0x5D;
2271         DPRINTK("CR5D = %x\n", *(regs + S3_CRTC_DATA));
2272         *(regs + S3_CRTC_ADR) = 0x5E;
2273         DPRINTK("CR5E = %x\n", *(regs + S3_CRTC_DATA));
2274         DPRINTK("MISC = %x\n", *(regs + GREG_MISC_OUTPUT_R));
2275         *(regs + SEQ_ADDRESS) = 0x01;
2276         DPRINTK("SR01 = %x\n", *(regs + SEQ_ADDRESS_R));
2277         *(regs + SEQ_ADDRESS) = 0x02;
2278         DPRINTK("SR02 = %x\n", *(regs + SEQ_ADDRESS_R));
2279         *(regs + SEQ_ADDRESS) = 0x03;
2280         DPRINTK("SR03 = %x\n", *(regs + SEQ_ADDRESS_R));
2281         *(regs + SEQ_ADDRESS) = 0x09;
2282         DPRINTK("SR09 = %x\n", *(regs + SEQ_ADDRESS_R));
2283         *(regs + SEQ_ADDRESS) = 0x10;
2284         DPRINTK("SR10 = %x\n", *(regs + SEQ_ADDRESS_R));
2285         *(regs + SEQ_ADDRESS) = 0x11;
2286         DPRINTK("SR11 = %x\n", *(regs + SEQ_ADDRESS_R));
2287         *(regs + SEQ_ADDRESS) = 0x12;
2288         DPRINTK("SR12 = %x\n", *(regs + SEQ_ADDRESS_R));
2289         *(regs + SEQ_ADDRESS) = 0x13;
2290         DPRINTK("SR13 = %x\n", *(regs + SEQ_ADDRESS_R));
2291         *(regs + SEQ_ADDRESS) = 0x15;
2292         DPRINTK("SR15 = %x\n", *(regs + SEQ_ADDRESS_R));
2293         
2294         return;
2295 }
2296 #endif