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