?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] W1: w1_netlink: New init/fini netlink callbacks.
[linux-2.6/verdex.git] / drivers / video / cyberfb.c
bloba3e189f90a7defed0588b66c5896df373813e954
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
Verdex Pro support