?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[TG3]: Set minimal hw interrupt mitigation.
[linux-2.6/verdex.git] / drivers / video / cirrusfb.c
bloba3040429c27b7e0d62ca52808b028ebdae211ebc
1 /*
2 * drivers/video/cirrusfb.c - driver for Cirrus Logic chipsets
3 *
4 * Copyright 1999-2001 Jeff Garzik <jgarzik@pobox.com>
5 *
6 * Contributors (thanks, all!)
7 *
8 * David Eger:
9 * Overhaul for Linux 2.6
10 *
11 * Jeff Rugen:
12 * Major contributions; Motorola PowerStack (PPC and PCI) support,
13 * GD54xx, 1280x1024 mode support, change MCLK based on VCLK.
14 *
15 * Geert Uytterhoeven:
16 * Excellent code review.
17 *
18 * Lars Hecking:
19 * Amiga updates and testing.
20 *
21 * Original cirrusfb author: Frank Neumann
22 *
23 * Based on retz3fb.c and cirrusfb.c:
24 * Copyright (C) 1997 Jes Sorensen
25 * Copyright (C) 1996 Frank Neumann
26 *
27 ***************************************************************
28 *
29 * Format this code with GNU indent '-kr -i8 -pcs' options.
30 *
31 * This file is subject to the terms and conditions of the GNU General Public
32 * License. See the file COPYING in the main directory of this archive
33 * for more details.
34 *
35 */
36
37 #define CIRRUSFB_VERSION "2.0-pre2"
38
39 #include <linux/config.h>
40 #include <linux/module.h>
41 #include <linux/kernel.h>
42 #include <linux/errno.h>
43 #include <linux/string.h>
44 #include <linux/mm.h>
45 #include <linux/tty.h>
46 #include <linux/slab.h>
47 #include <linux/delay.h>
48 #include <linux/fb.h>
49 #include <linux/init.h>
50 #include <linux/selection.h>
51 #include <asm/pgtable.h>
52
53 #ifdef CONFIG_ZORRO
54 #include <linux/zorro.h>
55 #endif
56 #ifdef CONFIG_PCI
57 #include <linux/pci.h>
58 #endif
59 #ifdef CONFIG_AMIGA
60 #include <asm/amigahw.h>
61 #endif
62 #ifdef CONFIG_PPC_PREP
63 #include <asm/processor.h>
64 #define isPReP (_machine == _MACH_prep)
65 #else
66 #define isPReP 0
67 #endif
68
69 #include "video/vga.h"
70 #include "video/cirrus.h"
71
72
73 /*****************************************************************
74 *
75 * debugging and utility macros
76 *
77 */
78
79 /* enable debug output? */
80 /* #define CIRRUSFB_DEBUG 1 */
81
82 /* disable runtime assertions? */
83 /* #define CIRRUSFB_NDEBUG */
84
85 /* debug output */
86 #ifdef CIRRUSFB_DEBUG
87 #define DPRINTK(fmt, args...) printk(KERN_DEBUG "%s: " fmt, __FUNCTION__ , ## args)
88 #else
89 #define DPRINTK(fmt, args...)
90 #endif
91
92 /* debugging assertions */
93 #ifndef CIRRUSFB_NDEBUG
94 #define assert(expr) \
95 if(!(expr)) { \
96 printk( "Assertion failed! %s,%s,%s,line=%d\n",\
97 #expr,__FILE__,__FUNCTION__,__LINE__); \
98 }
99 #else
100 #define assert(expr)
101 #endif
102
103 #ifdef TRUE
104 #undef TRUE
105 #endif
106 #ifdef FALSE
107 #undef FALSE
108 #endif
109 #define TRUE 1
110 #define FALSE 0
111
112 #define MB_ (1024*1024)
113 #define KB_ (1024)
114
115 #define MAX_NUM_BOARDS 7
116
117
118 /*****************************************************************
119 *
120 * chipset information
121 *
122 */
123
124 /* board types */
125 typedef enum {
126 BT_NONE = 0,
127 BT_SD64,
128 BT_PICCOLO,
129 BT_PICASSO,
130 BT_SPECTRUM,
131 BT_PICASSO4, /* GD5446 */
132 BT_ALPINE, /* GD543x/4x */
133 BT_GD5480,
134 BT_LAGUNA, /* GD546x */
135 } cirrusfb_board_t;
136
137
138 /*
139 * per-board-type information, used for enumerating and abstracting
140 * chip-specific information
141 * NOTE: MUST be in the same order as cirrusfb_board_t in order to
142 * use direct indexing on this array
143 * NOTE: '__initdata' cannot be used as some of this info
144 * is required at runtime. Maybe separate into an init-only and
145 * a run-time table?
146 */
147 static const struct cirrusfb_board_info_rec {
148 char *name; /* ASCII name of chipset */
149 long maxclock[5]; /* maximum video clock */
150 /* for 1/4bpp, 8bpp 15/16bpp, 24bpp, 32bpp - numbers from xorg code */
151 unsigned init_sr07 : 1; /* init SR07 during init_vgachip() */
152 unsigned init_sr1f : 1; /* write SR1F during init_vgachip() */
153 unsigned scrn_start_bit19 : 1; /* construct bit 19 of screen start address */
154
155 /* initial SR07 value, then for each mode */
156 unsigned char sr07;
157 unsigned char sr07_1bpp;
158 unsigned char sr07_1bpp_mux;
159 unsigned char sr07_8bpp;
160 unsigned char sr07_8bpp_mux;
161
162 unsigned char sr1f; /* SR1F VGA initial register value */
163 } cirrusfb_board_info[] = {
164 [BT_SD64] = {
165 .name = "CL SD64",
166 .maxclock = {
167 /* guess */
168 /* the SD64/P4 have a higher max. videoclock */
169 140000, 140000, 140000, 140000, 140000,
170 },
171 .init_sr07 = TRUE,
172 .init_sr1f = TRUE,
173 .scrn_start_bit19 = TRUE,
174 .sr07 = 0xF0,
175 .sr07_1bpp = 0xF0,
176 .sr07_8bpp = 0xF1,
177 .sr1f = 0x20
178 },
179 [BT_PICCOLO] = {
180 .name = "CL Piccolo",
181 .maxclock = {
182 /* guess */
183 90000, 90000, 90000, 90000, 90000
184 },
185 .init_sr07 = TRUE,
186 .init_sr1f = TRUE,
187 .scrn_start_bit19 = FALSE,
188 .sr07 = 0x80,
189 .sr07_1bpp = 0x80,
190 .sr07_8bpp = 0x81,
191 .sr1f = 0x22
192 },
193 [BT_PICASSO] = {
194 .name = "CL Picasso",
195 .maxclock = {
196 /* guess */
197 90000, 90000, 90000, 90000, 90000
198 },
199 .init_sr07 = TRUE,
200 .init_sr1f = TRUE,
201 .scrn_start_bit19 = FALSE,
202 .sr07 = 0x20,
203 .sr07_1bpp = 0x20,
204 .sr07_8bpp = 0x21,
205 .sr1f = 0x22
206 },
207 [BT_SPECTRUM] = {
208 .name = "CL Spectrum",
209 .maxclock = {
210 /* guess */
211 90000, 90000, 90000, 90000, 90000
212 },
213 .init_sr07 = TRUE,
214 .init_sr1f = TRUE,
215 .scrn_start_bit19 = FALSE,
216 .sr07 = 0x80,
217 .sr07_1bpp = 0x80,
218 .sr07_8bpp = 0x81,
219 .sr1f = 0x22
220 },
221 [BT_PICASSO4] = {
222 .name = "CL Picasso4",
223 .maxclock = {
224 135100, 135100, 85500, 85500, 0
225 },
226 .init_sr07 = TRUE,
227 .init_sr1f = FALSE,
228 .scrn_start_bit19 = TRUE,
229 .sr07 = 0x20,
230 .sr07_1bpp = 0x20,
231 .sr07_8bpp = 0x21,
232 .sr1f = 0
233 },
234 [BT_ALPINE] = {
235 .name = "CL Alpine",
236 .maxclock = {
237 /* for the GD5430. GD5446 can do more... */
238 85500, 85500, 50000, 28500, 0
239 },
240 .init_sr07 = TRUE,
241 .init_sr1f = TRUE,
242 .scrn_start_bit19 = TRUE,
243 .sr07 = 0xA0,
244 .sr07_1bpp = 0xA1,
245 .sr07_1bpp_mux = 0xA7,
246 .sr07_8bpp = 0xA1,
247 .sr07_8bpp_mux = 0xA7,
248 .sr1f = 0x1C
249 },
250 [BT_GD5480] = {
251 .name = "CL GD5480",
252 .maxclock = {
253 135100, 200000, 200000, 135100, 135100
254 },
255 .init_sr07 = TRUE,
256 .init_sr1f = TRUE,
257 .scrn_start_bit19 = TRUE,
258 .sr07 = 0x10,
259 .sr07_1bpp = 0x11,
260 .sr07_8bpp = 0x11,
261 .sr1f = 0x1C
262 },
263 [BT_LAGUNA] = {
264 .name = "CL Laguna",
265 .maxclock = {
266 /* guess */
267 135100, 135100, 135100, 135100, 135100,
268 },
269 .init_sr07 = FALSE,
270 .init_sr1f = FALSE,
271 .scrn_start_bit19 = TRUE,
272 }
273 };
274
275
276 #ifdef CONFIG_PCI
277 #define CHIP(id, btype) \
278 { PCI_VENDOR_ID_CIRRUS, PCI_DEVICE_ID_##id, PCI_ANY_ID, PCI_ANY_ID, 0, 0, (btype) }
279
280 static struct pci_device_id cirrusfb_pci_table[] = {
281 CHIP( CIRRUS_5436, BT_ALPINE ),
282 CHIP( CIRRUS_5434_8, BT_ALPINE ),
283 CHIP( CIRRUS_5434_4, BT_ALPINE ),
284 CHIP( CIRRUS_5430, BT_ALPINE ), /* GD-5440 has identical id */
285 CHIP( CIRRUS_7543, BT_ALPINE ),
286 CHIP( CIRRUS_7548, BT_ALPINE ),
287 CHIP( CIRRUS_5480, BT_GD5480 ), /* MacPicasso probably */
288 CHIP( CIRRUS_5446, BT_PICASSO4 ), /* Picasso 4 is a GD5446 */
289 CHIP( CIRRUS_5462, BT_LAGUNA ), /* CL Laguna */
290 CHIP( CIRRUS_5464, BT_LAGUNA ), /* CL Laguna 3D */
291 CHIP( CIRRUS_5465, BT_LAGUNA ), /* CL Laguna 3DA*/
292 { 0, }
293 };
294 MODULE_DEVICE_TABLE(pci, cirrusfb_pci_table);
295 #undef CHIP
296 #endif /* CONFIG_PCI */
297
298
299 #ifdef CONFIG_ZORRO
300 static const struct zorro_device_id cirrusfb_zorro_table[] = {
301 {
302 .id = ZORRO_PROD_HELFRICH_SD64_RAM,
303 .driver_data = BT_SD64,
304 }, {
305 .id = ZORRO_PROD_HELFRICH_PICCOLO_RAM,
306 .driver_data = BT_PICCOLO,
307 }, {
308 .id = ZORRO_PROD_VILLAGE_TRONIC_PICASSO_II_II_PLUS_RAM,
309 .driver_data = BT_PICASSO,
310 }, {
311 .id = ZORRO_PROD_GVP_EGS_28_24_SPECTRUM_RAM,
312 .driver_data = BT_SPECTRUM,
313 }, {
314 .id = ZORRO_PROD_VILLAGE_TRONIC_PICASSO_IV_Z3,
315 .driver_data = BT_PICASSO4,
316 },
317 { 0 }
318 };
319
320 static const struct {
321 zorro_id id2;
322 unsigned long size;
323 } cirrusfb_zorro_table2[] = {
324 [BT_SD64] = {
325 .id2 = ZORRO_PROD_HELFRICH_SD64_REG,
326 .size = 0x400000
327 },
328 [BT_PICCOLO] = {
329 .id2 = ZORRO_PROD_HELFRICH_PICCOLO_REG,
330 .size = 0x200000
331 },
332 [BT_PICASSO] = {
333 .id2 = ZORRO_PROD_VILLAGE_TRONIC_PICASSO_II_II_PLUS_REG,
334 .size = 0x200000
335 },
336 [BT_SPECTRUM] = {
337 .id2 = ZORRO_PROD_GVP_EGS_28_24_SPECTRUM_REG,
338 .size = 0x200000
339 },
340 [BT_PICASSO4] = {
341 .id2 = 0,
342 .size = 0x400000
343 }
344 };
345 #endif /* CONFIG_ZORRO */
346
347
348 struct cirrusfb_regs {
349 __u32 line_length; /* in BYTES! */
350 __u32 visual;
351 __u32 type;
352
353 long freq;
354 long nom;
355 long den;
356 long div;
357 long multiplexing;
358 long mclk;
359 long divMCLK;
360
361 long HorizRes; /* The x resolution in pixel */
362 long HorizTotal;
363 long HorizDispEnd;
364 long HorizBlankStart;
365 long HorizBlankEnd;
366 long HorizSyncStart;
367 long HorizSyncEnd;
368
369 long VertRes; /* the physical y resolution in scanlines */
370 long VertTotal;
371 long VertDispEnd;
372 long VertSyncStart;
373 long VertSyncEnd;
374 long VertBlankStart;
375 long VertBlankEnd;
376 };
377
378
379
380 #ifdef CIRRUSFB_DEBUG
381 typedef enum {
382 CRT,
383 SEQ
384 } cirrusfb_dbg_reg_class_t;
385 #endif /* CIRRUSFB_DEBUG */
386
387
388
389
390 /* info about board */
391 struct cirrusfb_info {
392 struct fb_info *info;
393
394 u8 __iomem *fbmem;
395 u8 __iomem *regbase;
396 u8 __iomem *mem;
397 unsigned long size;
398 cirrusfb_board_t btype;
399 unsigned char SFR; /* Shadow of special function register */
400
401 unsigned long fbmem_phys;
402 unsigned long fbregs_phys;
403
404 struct cirrusfb_regs currentmode;
405 int blank_mode;
406
407 u32 pseudo_palette[17];
408 struct { u8 red, green, blue, pad; } palette[256];
409
410 #ifdef CONFIG_ZORRO
411 struct zorro_dev *zdev;
412 #endif
413 #ifdef CONFIG_PCI
414 struct pci_dev *pdev;
415 #endif
416 void (*unmap)(struct cirrusfb_info *cinfo);
417 };
418
419
420 static unsigned cirrusfb_def_mode = 1;
421 static int noaccel = 0;
422
423 /*
424 * Predefined Video Modes
425 */
426
427 static const struct {
428 const char *name;
429 struct fb_var_screeninfo var;
430 } cirrusfb_predefined[] = {
431 {
432 /* autodetect mode */
433 .name = "Autodetect",
434 }, {
435 /* 640x480, 31.25 kHz, 60 Hz, 25 MHz PixClock */
436 .name = "640x480",
437 .var = {
438 .xres = 640,
439 .yres = 480,
440 .xres_virtual = 640,
441 .yres_virtual = 480,
442 .bits_per_pixel = 8,
443 .red = { .length = 8 },
444 .green = { .length = 8 },
445 .blue = { .length = 8 },
446 .width = -1,
447 .height = -1,
448 .pixclock = 40000,
449 .left_margin = 48,
450 .right_margin = 16,
451 .upper_margin = 32,
452 .lower_margin = 8,
453 .hsync_len = 96,
454 .vsync_len = 4,
455 .sync = FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
456 .vmode = FB_VMODE_NONINTERLACED
457 }
458 }, {
459 /* 800x600, 48 kHz, 76 Hz, 50 MHz PixClock */
460 .name = "800x600",
461 .var = {
462 .xres = 800,
463 .yres = 600,
464 .xres_virtual = 800,
465 .yres_virtual = 600,
466 .bits_per_pixel = 8,
467 .red = { .length = 8 },
468 .green = { .length = 8 },
469 .blue = { .length = 8 },
470 .width = -1,
471 .height = -1,
472 .pixclock = 20000,
473 .left_margin = 128,
474 .right_margin = 16,
475 .upper_margin = 24,
476 .lower_margin = 2,
477 .hsync_len = 96,
478 .vsync_len = 6,
479 .vmode = FB_VMODE_NONINTERLACED
480 }
481 }, {
482 /*
483 * Modeline from XF86Config:
484 * Mode "1024x768" 80 1024 1136 1340 1432 768 770 774 805
485 */
486 /* 1024x768, 55.8 kHz, 70 Hz, 80 MHz PixClock */
487 .name = "1024x768",
488 .var = {
489 .xres = 1024,
490 .yres = 768,
491 .xres_virtual = 1024,
492 .yres_virtual = 768,
493 .bits_per_pixel = 8,
494 .red = { .length = 8 },
495 .green = { .length = 8 },
496 .blue = { .length = 8 },
497 .width = -1,
498 .height = -1,
499 .pixclock = 12500,
500 .left_margin = 144,
501 .right_margin = 32,
502 .upper_margin = 30,
503 .lower_margin = 2,
504 .hsync_len = 192,
505 .vsync_len = 6,
506 .vmode = FB_VMODE_NONINTERLACED
507 }
508 }
509 };
510
511 #define NUM_TOTAL_MODES ARRAY_SIZE(cirrusfb_predefined)
512
513 /****************************************************************************/
514 /**** BEGIN PROTOTYPES ******************************************************/
515
516
517 /*--- Interface used by the world ------------------------------------------*/
518 static int cirrusfb_init (void);
519 #ifndef MODULE
520 static int cirrusfb_setup (char *options);
521 #endif
522
523 static int cirrusfb_open (struct fb_info *info, int user);
524 static int cirrusfb_release (struct fb_info *info, int user);
525 static int cirrusfb_setcolreg (unsigned regno, unsigned red, unsigned green,
526 unsigned blue, unsigned transp,
527 struct fb_info *info);
528 static int cirrusfb_check_var (struct fb_var_screeninfo *var,
529 struct fb_info *info);
530 static int cirrusfb_set_par (struct fb_info *info);
531 static int cirrusfb_pan_display (struct fb_var_screeninfo *var,
532 struct fb_info *info);
533 static int cirrusfb_blank (int blank_mode, struct fb_info *info);
534 static void cirrusfb_fillrect (struct fb_info *info, const struct fb_fillrect *region);
535 static void cirrusfb_copyarea(struct fb_info *info, const struct fb_copyarea *area);
536 static void cirrusfb_imageblit(struct fb_info *info, const struct fb_image *image);
537
538 /* function table of the above functions */
539 static struct fb_ops cirrusfb_ops = {
540 .owner = THIS_MODULE,
541 .fb_open = cirrusfb_open,
542 .fb_release = cirrusfb_release,
543 .fb_setcolreg = cirrusfb_setcolreg,
544 .fb_check_var = cirrusfb_check_var,
545 .fb_set_par = cirrusfb_set_par,
546 .fb_pan_display = cirrusfb_pan_display,
547 .fb_blank = cirrusfb_blank,
548 .fb_fillrect = cirrusfb_fillrect,
549 .fb_copyarea = cirrusfb_copyarea,
550 .fb_imageblit = cirrusfb_imageblit,
551 .fb_cursor = soft_cursor,
552 };
553
554 /*--- Hardware Specific Routines -------------------------------------------*/
555 static int cirrusfb_decode_var (const struct fb_var_screeninfo *var,
556 struct cirrusfb_regs *regs,
557 const struct fb_info *info);
558 /*--- Internal routines ----------------------------------------------------*/
559 static void init_vgachip (struct cirrusfb_info *cinfo);
560 static void switch_monitor (struct cirrusfb_info *cinfo, int on);
561 static void WGen (const struct cirrusfb_info *cinfo,
562 int regnum, unsigned char val);
563 static unsigned char RGen (const struct cirrusfb_info *cinfo, int regnum);
564 static void AttrOn (const struct cirrusfb_info *cinfo);
565 static void WHDR (const struct cirrusfb_info *cinfo, unsigned char val);
566 static void WSFR (struct cirrusfb_info *cinfo, unsigned char val);
567 static void WSFR2 (struct cirrusfb_info *cinfo, unsigned char val);
568 static void WClut (struct cirrusfb_info *cinfo, unsigned char regnum, unsigned char red,
569 unsigned char green,
570 unsigned char blue);
571 #if 0
572 static void RClut (struct cirrusfb_info *cinfo, unsigned char regnum, unsigned char *red,
573 unsigned char *green,
574 unsigned char *blue);
575 #endif
576 static void cirrusfb_WaitBLT (u8 __iomem *regbase);
577 static void cirrusfb_BitBLT (u8 __iomem *regbase, int bits_per_pixel,
578 u_short curx, u_short cury,
579 u_short destx, u_short desty,
580 u_short width, u_short height,
581 u_short line_length);
582 static void cirrusfb_RectFill (u8 __iomem *regbase, int bits_per_pixel,
583 u_short x, u_short y,
584 u_short width, u_short height,
585 u_char color, u_short line_length);
586
587 static void bestclock (long freq, long *best,
588 long *nom, long *den,
589 long *div, long maxfreq);
590
591 #ifdef CIRRUSFB_DEBUG
592 static void cirrusfb_dump (void);
593 static void cirrusfb_dbg_reg_dump (caddr_t regbase);
594 static void cirrusfb_dbg_print_regs (caddr_t regbase, cirrusfb_dbg_reg_class_t reg_class,...);
595 static void cirrusfb_dbg_print_byte (const char *name, unsigned char val);
596 #endif /* CIRRUSFB_DEBUG */
597
598 /*** END PROTOTYPES ********************************************************/
599 /*****************************************************************************/
600 /*** BEGIN Interface Used by the World ***************************************/
601
602 static int opencount = 0;
603
604 /*--- Open /dev/fbx ---------------------------------------------------------*/
605 static int cirrusfb_open (struct fb_info *info, int user)
606 {
607 if (opencount++ == 0)
608 switch_monitor (info->par, 1);
609 return 0;
610 }
611
612 /*--- Close /dev/fbx --------------------------------------------------------*/
613 static int cirrusfb_release (struct fb_info *info, int user)
614 {
615 if (--opencount == 0)
616 switch_monitor (info->par, 0);
617 return 0;
618 }
619
620 /**** END Interface used by the World *************************************/
621 /****************************************************************************/
622 /**** BEGIN Hardware specific Routines **************************************/
623
624 /* Get a good MCLK value */
625 static long cirrusfb_get_mclk (long freq, int bpp, long *div)
626 {
627 long mclk;
628
629 assert (div != NULL);
630
631 /* Calculate MCLK, in case VCLK is high enough to require > 50MHz.
632 * Assume a 64-bit data path for now. The formula is:
633 * ((B * PCLK * 2)/W) * 1.2
634 * B = bytes per pixel, PCLK = pixclock, W = data width in bytes */
635 mclk = ((bpp / 8) * freq * 2) / 4;
636 mclk = (mclk * 12) / 10;
637 if (mclk < 50000)
638 mclk = 50000;
639 DPRINTK ("Use MCLK of %ld kHz\n", mclk);
640
641 /* Calculate value for SR1F. Multiply by 2 so we can round up. */
642 mclk = ((mclk * 16) / 14318);
643 mclk = (mclk + 1) / 2;
644 DPRINTK ("Set SR1F[5:0] to 0x%lx\n", mclk);
645
646 /* Determine if we should use MCLK instead of VCLK, and if so, what we
647 * should divide it by to get VCLK */
648 switch (freq) {
649 case 24751 ... 25249:
650 *div = 2;
651 DPRINTK ("Using VCLK = MCLK/2\n");
652 break;
653 case 49501 ... 50499:
654 *div = 1;
655 DPRINTK ("Using VCLK = MCLK\n");
656 break;
657 default:
658 *div = 0;
659 break;
660 }
661
662 return mclk;
663 }
664
665 static int cirrusfb_check_var(struct fb_var_screeninfo *var,
666 struct fb_info *info)
667 {
668 struct cirrusfb_info *cinfo = info->par;
669 int nom, den; /* translyting from pixels->bytes */
670 int yres, i;
671 static struct { int xres, yres; } modes[] =
672 { { 1600, 1280 },
673 { 1280, 1024 },
674 { 1024, 768 },
675 { 800, 600 },
676 { 640, 480 },
677 { -1, -1 } };
678
679 switch (var->bits_per_pixel) {
680 case 0 ... 1:
681 var->bits_per_pixel = 1;
682 nom = 4;
683 den = 8;
684 break; /* 8 pixel per byte, only 1/4th of mem usable */
685 case 2 ... 8:
686 var->bits_per_pixel = 8;
687 nom = 1;
688 den = 1;
689 break; /* 1 pixel == 1 byte */
690 case 9 ... 16:
691 var->bits_per_pixel = 16;
692 nom = 2;
693 den = 1;
694 break; /* 2 bytes per pixel */
695 case 17 ... 24:
696 var->bits_per_pixel = 24;
697 nom = 3;
698 den = 1;
699 break; /* 3 bytes per pixel */
700 case 25 ... 32:
701 var->bits_per_pixel = 32;
702 nom = 4;
703 den = 1;
704 break; /* 4 bytes per pixel */
705 default:
706 printk ("cirrusfb: mode %dx%dx%d rejected...color depth not supported.\n",
707 var->xres, var->yres, var->bits_per_pixel);
708 DPRINTK ("EXIT - EINVAL error\n");
709 return -EINVAL;
710 }
711
712 if (var->xres * nom / den * var->yres > cinfo->size) {
713 printk ("cirrusfb: mode %dx%dx%d rejected...resolution too high to fit into video memory!\n",
714 var->xres, var->yres, var->bits_per_pixel);
715 DPRINTK ("EXIT - EINVAL error\n");
716 return -EINVAL;
717 }
718
719 /* use highest possible virtual resolution */
720 if (var->xres_virtual == -1 &&
721 var->yres_virtual == -1) {
722 printk ("cirrusfb: using maximum available virtual resolution\n");
723 for (i = 0; modes[i].xres != -1; i++) {
724 if (modes[i].xres * nom / den * modes[i].yres < cinfo->size / 2)
725 break;
726 }
727 if (modes[i].xres == -1) {
728 printk ("cirrusfb: could not find a virtual resolution that fits into video memory!!\n");
729 DPRINTK ("EXIT - EINVAL error\n");
730 return -EINVAL;
731 }
732 var->xres_virtual = modes[i].xres;
733 var->yres_virtual = modes[i].yres;
734
735 printk ("cirrusfb: virtual resolution set to maximum of %dx%d\n",
736 var->xres_virtual, var->yres_virtual);
737 }
738
739 if (var->xres_virtual < var->xres)
740 var->xres_virtual = var->xres;
741 if (var->yres_virtual < var->yres)
742 var->yres_virtual = var->yres;
743
744 if (var->xoffset < 0)
745 var->xoffset = 0;
746 if (var->yoffset < 0)
747 var->yoffset = 0;
748
749 /* truncate xoffset and yoffset to maximum if too high */
750 if (var->xoffset > var->xres_virtual - var->xres)
751 var->xoffset = var->xres_virtual - var->xres - 1;
752 if (var->yoffset > var->yres_virtual - var->yres)
753 var->yoffset = var->yres_virtual - var->yres - 1;
754
755 switch (var->bits_per_pixel) {
756 case 1:
757 var->red.offset = 0;
758 var->red.length = 1;
759 var->green.offset = 0;
760 var->green.length = 1;
761 var->blue.offset = 0;
762 var->blue.length = 1;
763 break;
764
765 case 8:
766 var->red.offset = 0;
767 var->red.length = 6;
768 var->green.offset = 0;
769 var->green.length = 6;
770 var->blue.offset = 0;
771 var->blue.length = 6;
772 break;
773
774 case 16:
775 if(isPReP) {
776 var->red.offset = 2;
777 var->green.offset = -3;
778 var->blue.offset = 8;
779 } else {
780 var->red.offset = 10;
781 var->green.offset = 5;
782 var->blue.offset = 0;
783 }
784 var->red.length = 5;
785 var->green.length = 5;
786 var->blue.length = 5;
787 break;
788
789 case 24:
790 if(isPReP) {
791 var->red.offset = 8;
792 var->green.offset = 16;
793 var->blue.offset = 24;
794 } else {
795 var->red.offset = 16;
796 var->green.offset = 8;
797 var->blue.offset = 0;
798 }
799 var->red.length = 8;
800 var->green.length = 8;
801 var->blue.length = 8;
802 break;
803
804 case 32:
805 if(isPReP) {
806 var->red.offset = 8;
807 var->green.offset = 16;
808 var->blue.offset = 24;
809 } else {
810 var->red.offset = 16;
811 var->green.offset = 8;
812 var->blue.offset = 0;
813 }
814 var->red.length = 8;
815 var->green.length = 8;
816 var->blue.length = 8;
817 break;
818
819 default:
820 DPRINTK("Unsupported bpp size: %d\n", var->bits_per_pixel);
821 assert (FALSE);
822 /* should never occur */
823 break;
824 }
825
826 var->red.msb_right =
827 var->green.msb_right =
828 var->blue.msb_right =
829 var->transp.offset =
830 var->transp.length =
831 var->transp.msb_right = 0;
832
833 yres = var->yres;
834 if (var->vmode & FB_VMODE_DOUBLE)
835 yres *= 2;
836 else if (var->vmode & FB_VMODE_INTERLACED)
837 yres = (yres + 1) / 2;
838
839 if (yres >= 1280) {
840 printk (KERN_WARNING "cirrusfb: ERROR: VerticalTotal >= 1280; special treatment required! (TODO)\n");
841 DPRINTK ("EXIT - EINVAL error\n");
842 return -EINVAL;
843 }
844
845 return 0;
846 }
847
848 static int cirrusfb_decode_var (const struct fb_var_screeninfo *var,
849 struct cirrusfb_regs *regs,
850 const struct fb_info *info)
851 {
852 long freq;
853 long maxclock;
854 int maxclockidx = 0;
855 struct cirrusfb_info *cinfo = info->par;
856 int xres, hfront, hsync, hback;
857 int yres, vfront, vsync, vback;
858
859 switch(var->bits_per_pixel) {
860 case 1:
861 regs->line_length = var->xres_virtual / 8;
862 regs->visual = FB_VISUAL_MONO10;
863 maxclockidx = 0;
864 break;
865
866 case 8:
867 regs->line_length = var->xres_virtual;
868 regs->visual = FB_VISUAL_PSEUDOCOLOR;
869 maxclockidx = 1;
870 break;
871
872 case 16:
873 regs->line_length = var->xres_virtual * 2;
874 regs->visual = FB_VISUAL_DIRECTCOLOR;
875 maxclockidx = 2;
876 break;
877
878 case 24:
879 regs->line_length = var->xres_virtual * 3;
880 regs->visual = FB_VISUAL_DIRECTCOLOR;
881 maxclockidx = 3;
882 break;
883
884 case 32:
885 regs->line_length = var->xres_virtual * 4;
886 regs->visual = FB_VISUAL_DIRECTCOLOR;
887 maxclockidx = 4;
888 break;
889
890 default:
891 DPRINTK("Unsupported bpp size: %d\n", var->bits_per_pixel);
892 assert (FALSE);
893 /* should never occur */
894 break;
895 }
896
897 regs->type = FB_TYPE_PACKED_PIXELS;
898
899 /* convert from ps to kHz */
900 freq = 1000000000 / var->pixclock;
901
902 DPRINTK ("desired pixclock: %ld kHz\n", freq);
903
904 maxclock = cirrusfb_board_info[cinfo->btype].maxclock[maxclockidx];
905 regs->multiplexing = 0;
906
907 /* If the frequency is greater than we can support, we might be able
908 * to use multiplexing for the video mode */
909 if (freq > maxclock) {
910 switch (cinfo->btype) {
911 case BT_ALPINE:
912 case BT_GD5480:
913 regs->multiplexing = 1;
914 break;
915
916 default:
917 printk (KERN_WARNING "cirrusfb: ERROR: Frequency greater than maxclock (%ld kHz)\n", maxclock);
918 DPRINTK ("EXIT - return -EINVAL\n");
919 return -EINVAL;
920 }
921 }
922 #if 0
923 /* TODO: If we have a 1MB 5434, we need to put ourselves in a mode where
924 * the VCLK is double the pixel clock. */
925 switch (var->bits_per_pixel) {
926 case 16:
927 case 32:
928 if (regs->HorizRes <= 800)
929 freq /= 2; /* Xbh has this type of clock for 32-bit */
930 break;
931 }
932 #endif
933
934 bestclock (freq, &regs->freq, &regs->nom, &regs->den, &regs->div,
935 maxclock);
936 regs->mclk = cirrusfb_get_mclk (freq, var->bits_per_pixel, &regs->divMCLK);
937
938 xres = var->xres;
939 hfront = var->right_margin;
940 hsync = var->hsync_len;
941 hback = var->left_margin;
942
943 yres = var->yres;
944 vfront = var->lower_margin;
945 vsync = var->vsync_len;
946 vback = var->upper_margin;
947
948 if (var->vmode & FB_VMODE_DOUBLE) {
949 yres *= 2;
950 vfront *= 2;
951 vsync *= 2;
952 vback *= 2;
953 } else if (var->vmode & FB_VMODE_INTERLACED) {
954 yres = (yres + 1) / 2;
955 vfront = (vfront + 1) / 2;
956 vsync = (vsync + 1) / 2;
957 vback = (vback + 1) / 2;
958 }
959 regs->HorizRes = xres;
960 regs->HorizTotal = (xres + hfront + hsync + hback) / 8 - 5;
961 regs->HorizDispEnd = xres / 8 - 1;
962 regs->HorizBlankStart = xres / 8;
963 regs->HorizBlankEnd = regs->HorizTotal + 5; /* does not count with "-5" */
964 regs->HorizSyncStart = (xres + hfront) / 8 + 1;
965 regs->HorizSyncEnd = (xres + hfront + hsync) / 8 + 1;
966
967 regs->VertRes = yres;
968 regs->VertTotal = yres + vfront + vsync + vback - 2;
969 regs->VertDispEnd = yres - 1;
970 regs->VertBlankStart = yres;
971 regs->VertBlankEnd = regs->VertTotal;
972 regs->VertSyncStart = yres + vfront - 1;
973 regs->VertSyncEnd = yres + vfront + vsync - 1;
974
975 if (regs->VertRes >= 1024) {
976 regs->VertTotal /= 2;
977 regs->VertSyncStart /= 2;
978 regs->VertSyncEnd /= 2;
979 regs->VertDispEnd /= 2;
980 }
981 if (regs->multiplexing) {
982 regs->HorizTotal /= 2;
983 regs->HorizSyncStart /= 2;
984 regs->HorizSyncEnd /= 2;
985 regs->HorizDispEnd /= 2;
986 }
987
988 return 0;
989 }
990
991
992 static void cirrusfb_set_mclk (const struct cirrusfb_info *cinfo, int val, int div)
993 {
994 assert (cinfo != NULL);
995
996 if (div == 2) {
997 /* VCLK = MCLK/2 */
998 unsigned char old = vga_rseq (cinfo->regbase, CL_SEQR1E);
999 vga_wseq (cinfo->regbase, CL_SEQR1E, old | 0x1);
1000 vga_wseq (cinfo->regbase, CL_SEQR1F, 0x40 | (val & 0x3f));
1001 } else if (div == 1) {
1002 /* VCLK = MCLK */
1003 unsigned char old = vga_rseq (cinfo->regbase, CL_SEQR1E);
1004 vga_wseq (cinfo->regbase, CL_SEQR1E, old & ~0x1);
1005 vga_wseq (cinfo->regbase, CL_SEQR1F, 0x40 | (val & 0x3f));
1006 } else {
1007 vga_wseq (cinfo->regbase, CL_SEQR1F, val & 0x3f);
1008 }
1009 }
1010
1011 /*************************************************************************
1012 cirrusfb_set_par_foo()
1013
1014 actually writes the values for a new video mode into the hardware,
1015 **************************************************************************/
1016 static int cirrusfb_set_par_foo (struct fb_info *info)
1017 {
1018 struct cirrusfb_info *cinfo = info->par;
1019 struct fb_var_screeninfo *var = &info->var;
1020 struct cirrusfb_regs regs;
1021 u8 __iomem *regbase = cinfo->regbase;
1022 unsigned char tmp;
1023 int offset = 0, err;
1024 const struct cirrusfb_board_info_rec *bi;
1025
1026 DPRINTK ("ENTER\n");
1027 DPRINTK ("Requested mode: %dx%dx%d\n",
1028 var->xres, var->yres, var->bits_per_pixel);
1029 DPRINTK ("pixclock: %d\n", var->pixclock);
1030
1031 init_vgachip (cinfo);
1032
1033 err = cirrusfb_decode_var(var, &regs, info);
1034 if(err) {
1035 /* should never happen */
1036 DPRINTK("mode change aborted. invalid var.\n");
1037 return -EINVAL;
1038 }
1039
1040 bi = &cirrusfb_board_info[cinfo->btype];
1041
1042
1043 /* unlock register VGA_CRTC_H_TOTAL..CRT7 */
1044 vga_wcrt (regbase, VGA_CRTC_V_SYNC_END, 0x20); /* previously: 0x00) */
1045
1046 /* if debugging is enabled, all parameters get output before writing */
1047 DPRINTK ("CRT0: %ld\n", regs.HorizTotal);
1048 vga_wcrt (regbase, VGA_CRTC_H_TOTAL, regs.HorizTotal);
1049
1050 DPRINTK ("CRT1: %ld\n", regs.HorizDispEnd);
1051 vga_wcrt (regbase, VGA_CRTC_H_DISP, regs.HorizDispEnd);
1052
1053 DPRINTK ("CRT2: %ld\n", regs.HorizBlankStart);
1054 vga_wcrt (regbase, VGA_CRTC_H_BLANK_START, regs.HorizBlankStart);
1055
1056 DPRINTK ("CRT3: 128+%ld\n", regs.HorizBlankEnd % 32); /* + 128: Compatible read */
1057 vga_wcrt (regbase, VGA_CRTC_H_BLANK_END, 128 + (regs.HorizBlankEnd % 32));
1058
1059 DPRINTK ("CRT4: %ld\n", regs.HorizSyncStart);
1060 vga_wcrt (regbase, VGA_CRTC_H_SYNC_START, regs.HorizSyncStart);
1061
1062 tmp = regs.HorizSyncEnd % 32;
1063 if (regs.HorizBlankEnd & 32)
1064 tmp += 128;
1065 DPRINTK ("CRT5: %d\n", tmp);
1066 vga_wcrt (regbase, VGA_CRTC_H_SYNC_END, tmp);
1067
1068 DPRINTK ("CRT6: %ld\n", regs.VertTotal & 0xff);
1069 vga_wcrt (regbase, VGA_CRTC_V_TOTAL, (regs.VertTotal & 0xff));
1070
1071 tmp = 16; /* LineCompare bit #9 */
1072 if (regs.VertTotal & 256)
1073 tmp |= 1;
1074 if (regs.VertDispEnd & 256)
1075 tmp |= 2;
1076 if (regs.VertSyncStart & 256)
1077 tmp |= 4;
1078 if (regs.VertBlankStart & 256)
1079 tmp |= 8;
1080 if (regs.VertTotal & 512)
1081 tmp |= 32;
1082 if (regs.VertDispEnd & 512)
1083 tmp |= 64;
1084 if (regs.VertSyncStart & 512)
1085 tmp |= 128;
1086 DPRINTK ("CRT7: %d\n", tmp);
1087 vga_wcrt (regbase, VGA_CRTC_OVERFLOW, tmp);
1088
1089 tmp = 0x40; /* LineCompare bit #8 */
1090 if (regs.VertBlankStart & 512)
1091 tmp |= 0x20;
1092 if (var->vmode & FB_VMODE_DOUBLE)
1093 tmp |= 0x80;
1094 DPRINTK ("CRT9: %d\n", tmp);
1095 vga_wcrt (regbase, VGA_CRTC_MAX_SCAN, tmp);
1096
1097 DPRINTK ("CRT10: %ld\n", regs.VertSyncStart & 0xff);
1098 vga_wcrt (regbase, VGA_CRTC_V_SYNC_START, (regs.VertSyncStart & 0xff));
1099
1100 DPRINTK ("CRT11: 64+32+%ld\n", regs.VertSyncEnd % 16);
1101 vga_wcrt (regbase, VGA_CRTC_V_SYNC_END, (regs.VertSyncEnd % 16 + 64 + 32));
1102
1103 DPRINTK ("CRT12: %ld\n", regs.VertDispEnd & 0xff);
1104 vga_wcrt (regbase, VGA_CRTC_V_DISP_END, (regs.VertDispEnd & 0xff));
1105
1106 DPRINTK ("CRT15: %ld\n", regs.VertBlankStart & 0xff);
1107 vga_wcrt (regbase, VGA_CRTC_V_BLANK_START, (regs.VertBlankStart & 0xff));
1108
1109 DPRINTK ("CRT16: %ld\n", regs.VertBlankEnd & 0xff);
1110 vga_wcrt (regbase, VGA_CRTC_V_BLANK_END, (regs.VertBlankEnd & 0xff));
1111
1112 DPRINTK ("CRT18: 0xff\n");
1113 vga_wcrt (regbase, VGA_CRTC_LINE_COMPARE, 0xff);
1114
1115 tmp = 0;
1116 if (var->vmode & FB_VMODE_INTERLACED)
1117 tmp |= 1;
1118 if (regs.HorizBlankEnd & 64)
1119 tmp |= 16;
1120 if (regs.HorizBlankEnd & 128)
1121 tmp |= 32;
1122 if (regs.VertBlankEnd & 256)
1123 tmp |= 64;
1124 if (regs.VertBlankEnd & 512)
1125 tmp |= 128;
1126
1127 DPRINTK ("CRT1a: %d\n", tmp);
1128 vga_wcrt (regbase, CL_CRT1A, tmp);
1129
1130 /* set VCLK0 */
1131 /* hardware RefClock: 14.31818 MHz */
1132 /* formula: VClk = (OSC * N) / (D * (1+P)) */
1133 /* Example: VClk = (14.31818 * 91) / (23 * (1+1)) = 28.325 MHz */
1134
1135 vga_wseq (regbase, CL_SEQRB, regs.nom);
1136 tmp = regs.den << 1;
1137 if (regs.div != 0)
1138 tmp |= 1;
1139
1140 if ((cinfo->btype == BT_SD64) ||
1141 (cinfo->btype == BT_ALPINE) ||
1142 (cinfo->btype == BT_GD5480))
1143 tmp |= 0x80; /* 6 bit denom; ONLY 5434!!! (bugged me 10 days) */
1144
1145 DPRINTK ("CL_SEQR1B: %ld\n", (long) tmp);
1146 vga_wseq (regbase, CL_SEQR1B, tmp);
1147
1148 if (regs.VertRes >= 1024)
1149 /* 1280x1024 */
1150 vga_wcrt (regbase, VGA_CRTC_MODE, 0xc7);
1151 else
1152 /* mode control: VGA_CRTC_START_HI enable, ROTATE(?), 16bit
1153 * address wrap, no compat. */
1154 vga_wcrt (regbase, VGA_CRTC_MODE, 0xc3);
1155
1156 /* HAEH? vga_wcrt (regbase, VGA_CRTC_V_SYNC_END, 0x20); * previously: 0x00 unlock VGA_CRTC_H_TOTAL..CRT7 */
1157
1158 /* don't know if it would hurt to also program this if no interlaced */
1159 /* mode is used, but I feel better this way.. :-) */
1160 if (var->vmode & FB_VMODE_INTERLACED)
1161 vga_wcrt (regbase, VGA_CRTC_REGS, regs.HorizTotal / 2);
1162 else
1163 vga_wcrt (regbase, VGA_CRTC_REGS, 0x00); /* interlace control */
1164
1165 vga_wseq (regbase, VGA_SEQ_CHARACTER_MAP, 0);
1166
1167 /* adjust horizontal/vertical sync type (low/high) */
1168 tmp = 0x03; /* enable display memory & CRTC I/O address for color mode */
1169 if (var->sync & FB_SYNC_HOR_HIGH_ACT)
1170 tmp |= 0x40;
1171 if (var->sync & FB_SYNC_VERT_HIGH_ACT)
1172 tmp |= 0x80;
1173 WGen (cinfo, VGA_MIS_W, tmp);
1174
1175 vga_wcrt (regbase, VGA_CRTC_PRESET_ROW, 0); /* Screen A Preset Row-Scan register */
1176 vga_wcrt (regbase, VGA_CRTC_CURSOR_START, 0); /* text cursor on and start line */
1177 vga_wcrt (regbase, VGA_CRTC_CURSOR_END, 31); /* text cursor end line */
1178
1179 /******************************************************
1180 *
1181 * 1 bpp
1182 *
1183 */
1184
1185 /* programming for different color depths */
1186 if (var->bits_per_pixel == 1) {
1187 DPRINTK ("cirrusfb: preparing for 1 bit deep display\n");
1188 vga_wgfx (regbase, VGA_GFX_MODE, 0); /* mode register */
1189
1190 /* SR07 */
1191 switch (cinfo->btype) {
1192 case BT_SD64:
1193 case BT_PICCOLO:
1194 case BT_PICASSO:
1195 case BT_SPECTRUM:
1196 case BT_PICASSO4:
1197 case BT_ALPINE:
1198 case BT_GD5480:
1199 DPRINTK (" (for GD54xx)\n");
1200 vga_wseq (regbase, CL_SEQR7,
1201 regs.multiplexing ?
1202 bi->sr07_1bpp_mux : bi->sr07_1bpp);
1203 break;
1204
1205 case BT_LAGUNA:
1206 DPRINTK (" (for GD546x)\n");
1207 vga_wseq (regbase, CL_SEQR7,
1208 vga_rseq (regbase, CL_SEQR7) & ~0x01);
1209 break;
1210
1211 default:
1212 printk (KERN_WARNING "cirrusfb: unknown Board\n");
1213 break;
1214 }
1215
1216 /* Extended Sequencer Mode */
1217 switch (cinfo->btype) {
1218 case BT_SD64:
1219 /* setting the SEQRF on SD64 is not necessary (only during init) */
1220 DPRINTK ("(for SD64)\n");
1221 vga_wseq (regbase, CL_SEQR1F, 0x1a); /* MCLK select */
1222 break;
1223
1224 case BT_PICCOLO:
1225 DPRINTK ("(for Piccolo)\n");
1226 /* ### ueberall 0x22? */
1227 vga_wseq (regbase, CL_SEQR1F, 0x22); /* ##vorher 1c MCLK select */
1228 vga_wseq (regbase, CL_SEQRF, 0xb0); /* evtl d0 bei 1 bit? avoid FIFO underruns..? */
1229 break;
1230
1231 case BT_PICASSO:
1232 DPRINTK ("(for Picasso)\n");
1233 vga_wseq (regbase, CL_SEQR1F, 0x22); /* ##vorher 22 MCLK select */
1234 vga_wseq (regbase, CL_SEQRF, 0xd0); /* ## vorher d0 avoid FIFO underruns..? */
1235 break;
1236
1237 case BT_SPECTRUM:
1238 DPRINTK ("(for Spectrum)\n");
1239 /* ### ueberall 0x22? */
1240 vga_wseq (regbase, CL_SEQR1F, 0x22); /* ##vorher 1c MCLK select */
1241 vga_wseq (regbase, CL_SEQRF, 0xb0); /* evtl d0? avoid FIFO underruns..? */
1242 break;
1243
1244 case BT_PICASSO4:
1245 case BT_ALPINE:
1246 case BT_GD5480:
1247 case BT_LAGUNA:
1248 DPRINTK (" (for GD54xx)\n");
1249 /* do nothing */
1250 break;
1251
1252 default:
1253 printk (KERN_WARNING "cirrusfb: unknown Board\n");
1254 break;
1255 }
1256
1257 WGen (cinfo, VGA_PEL_MSK, 0x01); /* pixel mask: pass-through for first plane */
1258 if (regs.multiplexing)
1259 WHDR (cinfo, 0x4a); /* hidden dac reg: 1280x1024 */
1260 else
1261 WHDR (cinfo, 0); /* hidden dac: nothing */
1262 vga_wseq (regbase, VGA_SEQ_MEMORY_MODE, 0x06); /* memory mode: odd/even, ext. memory */
1263 vga_wseq (regbase, VGA_SEQ_PLANE_WRITE, 0x01); /* plane mask: only write to first plane */
1264 offset = var->xres_virtual / 16;
1265 }
1266
1267 /******************************************************
1268 *
1269 * 8 bpp
1270 *
1271 */
1272
1273 else if (var->bits_per_pixel == 8) {
1274 DPRINTK ("cirrusfb: preparing for 8 bit deep display\n");
1275 switch (cinfo->btype) {
1276 case BT_SD64:
1277 case BT_PICCOLO:
1278 case BT_PICASSO:
1279 case BT_SPECTRUM:
1280 case BT_PICASSO4:
1281 case BT_ALPINE:
1282 case BT_GD5480:
1283 DPRINTK (" (for GD54xx)\n");
1284 vga_wseq (regbase, CL_SEQR7,
1285 regs.multiplexing ?
1286 bi->sr07_8bpp_mux : bi->sr07_8bpp);
1287 break;
1288
1289 case BT_LAGUNA:
1290 DPRINTK (" (for GD546x)\n");
1291 vga_wseq (regbase, CL_SEQR7,
1292 vga_rseq (regbase, CL_SEQR7) | 0x01);
1293 break;
1294
1295 default:
1296 printk (KERN_WARNING "cirrusfb: unknown Board\n");
1297 break;
1298 }
1299
1300 switch (cinfo->btype) {
1301 case BT_SD64:
1302 vga_wseq (regbase, CL_SEQR1F, 0x1d); /* MCLK select */
1303 break;
1304
1305 case BT_PICCOLO:
1306 vga_wseq (regbase, CL_SEQR1F, 0x22); /* ### vorher 1c MCLK select */
1307 vga_wseq (regbase, CL_SEQRF, 0xb0); /* Fast Page-Mode writes */
1308 break;
1309
1310 case BT_PICASSO:
1311 vga_wseq (regbase, CL_SEQR1F, 0x22); /* ### vorher 1c MCLK select */
1312 vga_wseq (regbase, CL_SEQRF, 0xb0); /* Fast Page-Mode writes */
1313 break;
1314
1315 case BT_SPECTRUM:
1316 vga_wseq (regbase, CL_SEQR1F, 0x22); /* ### vorher 1c MCLK select */
1317 vga_wseq (regbase, CL_SEQRF, 0xb0); /* Fast Page-Mode writes */
1318 break;
1319
1320 case BT_PICASSO4:
1321 #ifdef CONFIG_ZORRO
1322 vga_wseq (regbase, CL_SEQRF, 0xb8); /* ### INCOMPLETE!! */
1323 #endif
1324 /* vga_wseq (regbase, CL_SEQR1F, 0x1c); */
1325 break;
1326
1327 case BT_ALPINE:
1328 DPRINTK (" (for GD543x)\n");
1329 cirrusfb_set_mclk (cinfo, regs.mclk, regs.divMCLK);
1330 /* We already set SRF and SR1F */
1331 break;
1332
1333 case BT_GD5480:
1334 case BT_LAGUNA:
1335 DPRINTK (" (for GD54xx)\n");
1336 /* do nothing */
1337 break;
1338
1339 default:
1340 printk (KERN_WARNING "cirrusfb: unknown Board\n");
1341 break;
1342 }
1343
1344 vga_wgfx (regbase, VGA_GFX_MODE, 64); /* mode register: 256 color mode */
1345 WGen (cinfo, VGA_PEL_MSK, 0xff); /* pixel mask: pass-through all planes */
1346 if (regs.multiplexing)
1347 WHDR (cinfo, 0x4a); /* hidden dac reg: 1280x1024 */
1348 else
1349 WHDR (cinfo, 0); /* hidden dac: nothing */
1350 vga_wseq (regbase, VGA_SEQ_MEMORY_MODE, 0x0a); /* memory mode: chain4, ext. memory */
1351 vga_wseq (regbase, VGA_SEQ_PLANE_WRITE, 0xff); /* plane mask: enable writing to all 4 planes */
1352 offset = var->xres_virtual / 8;
1353 }
1354
1355 /******************************************************
1356 *
1357 * 16 bpp
1358 *
1359 */
1360
1361 else if (var->bits_per_pixel == 16) {
1362 DPRINTK ("cirrusfb: preparing for 16 bit deep display\n");
1363 switch (cinfo->btype) {
1364 case BT_SD64:
1365 vga_wseq (regbase, CL_SEQR7, 0xf7); /* Extended Sequencer Mode: 256c col. mode */
1366 vga_wseq (regbase, CL_SEQR1F, 0x1e); /* MCLK select */
1367 break;
1368
1369 case BT_PICCOLO:
1370 vga_wseq (regbase, CL_SEQR7, 0x87);
1371 vga_wseq (regbase, CL_SEQRF, 0xb0); /* Fast Page-Mode writes */
1372 vga_wseq (regbase, CL_SEQR1F, 0x22); /* MCLK select */
1373 break;
1374
1375 case BT_PICASSO:
1376 vga_wseq (regbase, CL_SEQR7, 0x27);
1377 vga_wseq (regbase, CL_SEQRF, 0xb0); /* Fast Page-Mode writes */
1378 vga_wseq (regbase, CL_SEQR1F, 0x22); /* MCLK select */
1379 break;
1380
1381 case BT_SPECTRUM:
1382 vga_wseq (regbase, CL_SEQR7, 0x87);
1383 vga_wseq (regbase, CL_SEQRF, 0xb0); /* Fast Page-Mode writes */
1384 vga_wseq (regbase, CL_SEQR1F, 0x22); /* MCLK select */
1385 break;
1386
1387 case BT_PICASSO4:
1388 vga_wseq (regbase, CL_SEQR7, 0x27);
1389 /* vga_wseq (regbase, CL_SEQR1F, 0x1c); */
1390 break;
1391
1392 case BT_ALPINE:
1393 DPRINTK (" (for GD543x)\n");
1394 if (regs.HorizRes >= 1024)
1395 vga_wseq (regbase, CL_SEQR7, 0xa7);
1396 else
1397 vga_wseq (regbase, CL_SEQR7, 0xa3);
1398 cirrusfb_set_mclk (cinfo, regs.mclk, regs.divMCLK);
1399 break;
1400
1401 case BT_GD5480:
1402 DPRINTK (" (for GD5480)\n");
1403 vga_wseq (regbase, CL_SEQR7, 0x17);
1404 /* We already set SRF and SR1F */
1405 break;
1406
1407 case BT_LAGUNA:
1408 DPRINTK (" (for GD546x)\n");
1409 vga_wseq (regbase, CL_SEQR7,
1410 vga_rseq (regbase, CL_SEQR7) & ~0x01);
1411 break;
1412
1413 default:
1414 printk (KERN_WARNING "CIRRUSFB: unknown Board\n");
1415 break;
1416 }
1417
1418 vga_wgfx (regbase, VGA_GFX_MODE, 64); /* mode register: 256 color mode */
1419 WGen (cinfo, VGA_PEL_MSK, 0xff); /* pixel mask: pass-through all planes */
1420 #ifdef CONFIG_PCI
1421 WHDR (cinfo, 0xc0); /* Copy Xbh */
1422 #elif defined(CONFIG_ZORRO)
1423 /* FIXME: CONFIG_PCI and CONFIG_ZORRO may be defined both */
1424 WHDR (cinfo, 0xa0); /* hidden dac reg: nothing special */
1425 #endif
1426 vga_wseq (regbase, VGA_SEQ_MEMORY_MODE, 0x0a); /* memory mode: chain4, ext. memory */
1427 vga_wseq (regbase, VGA_SEQ_PLANE_WRITE, 0xff); /* plane mask: enable writing to all 4 planes */
1428 offset = var->xres_virtual / 4;
1429 }
1430
1431 /******************************************************
1432 *
1433 * 32 bpp
1434 *
1435 */
1436
1437 else if (var->bits_per_pixel == 32) {
1438 DPRINTK ("cirrusfb: preparing for 24/32 bit deep display\n");
1439 switch (cinfo->btype) {
1440 case BT_SD64:
1441 vga_wseq (regbase, CL_SEQR7, 0xf9); /* Extended Sequencer Mode: 256c col. mode */
1442 vga_wseq (regbase, CL_SEQR1F, 0x1e); /* MCLK select */
1443 break;
1444
1445 case BT_PICCOLO:
1446 vga_wseq (regbase, CL_SEQR7, 0x85);
1447 vga_wseq (regbase, CL_SEQRF, 0xb0); /* Fast Page-Mode writes */
1448 vga_wseq (regbase, CL_SEQR1F, 0x22); /* MCLK select */
1449 break;
1450
1451 case BT_PICASSO:
1452 vga_wseq (regbase, CL_SEQR7, 0x25);
1453 vga_wseq (regbase, CL_SEQRF, 0xb0); /* Fast Page-Mode writes */
1454 vga_wseq (regbase, CL_SEQR1F, 0x22); /* MCLK select */
1455 break;
1456
1457 case BT_SPECTRUM:
1458 vga_wseq (regbase, CL_SEQR7, 0x85);
1459 vga_wseq (regbase, CL_SEQRF, 0xb0); /* Fast Page-Mode writes */
1460 vga_wseq (regbase, CL_SEQR1F, 0x22); /* MCLK select */
1461 break;
1462
1463 case BT_PICASSO4:
1464 vga_wseq (regbase, CL_SEQR7, 0x25);
1465 /* vga_wseq (regbase, CL_SEQR1F, 0x1c); */
1466 break;
1467
1468 case BT_ALPINE:
1469 DPRINTK (" (for GD543x)\n");
1470 vga_wseq (regbase, CL_SEQR7, 0xa9);
1471 cirrusfb_set_mclk (cinfo, regs.mclk, regs.divMCLK);
1472 break;
1473
1474 case BT_GD5480:
1475 DPRINTK (" (for GD5480)\n");
1476 vga_wseq (regbase, CL_SEQR7, 0x19);
1477 /* We already set SRF and SR1F */
1478 break;
1479
1480 case BT_LAGUNA:
1481 DPRINTK (" (for GD546x)\n");
1482 vga_wseq (regbase, CL_SEQR7,
1483 vga_rseq (regbase, CL_SEQR7) & ~0x01);
1484 break;
1485
1486 default:
1487 printk (KERN_WARNING "cirrusfb: unknown Board\n");
1488 break;
1489 }
1490
1491 vga_wgfx (regbase, VGA_GFX_MODE, 64); /* mode register: 256 color mode */
1492 WGen (cinfo, VGA_PEL_MSK, 0xff); /* pixel mask: pass-through all planes */
1493 WHDR (cinfo, 0xc5); /* hidden dac reg: 8-8-8 mode (24 or 32) */
1494 vga_wseq (regbase, VGA_SEQ_MEMORY_MODE, 0x0a); /* memory mode: chain4, ext. memory */
1495 vga_wseq (regbase, VGA_SEQ_PLANE_WRITE, 0xff); /* plane mask: enable writing to all 4 planes */
1496 offset = var->xres_virtual / 4;
1497 }
1498
1499 /******************************************************
1500 *
1501 * unknown/unsupported bpp
1502 *
1503 */
1504
1505 else {
1506 printk (KERN_ERR "cirrusfb: What's this?? requested color depth == %d.\n",
1507 var->bits_per_pixel);
1508 }
1509
1510 vga_wcrt (regbase, VGA_CRTC_OFFSET, offset & 0xff);
1511 tmp = 0x22;
1512 if (offset & 0x100)
1513 tmp |= 0x10; /* offset overflow bit */
1514
1515 vga_wcrt (regbase, CL_CRT1B, tmp); /* screen start addr #16-18, fastpagemode cycles */
1516
1517 if (cinfo->btype == BT_SD64 ||
1518 cinfo->btype == BT_PICASSO4 ||
1519 cinfo->btype == BT_ALPINE ||
1520 cinfo->btype == BT_GD5480)
1521 vga_wcrt (regbase, CL_CRT1D, 0x00); /* screen start address bit 19 */
1522
1523 vga_wcrt (regbase, VGA_CRTC_CURSOR_HI, 0); /* text cursor location high */
1524 vga_wcrt (regbase, VGA_CRTC_CURSOR_LO, 0); /* text cursor location low */
1525 vga_wcrt (regbase, VGA_CRTC_UNDERLINE, 0); /* underline row scanline = at very bottom */
1526
1527 vga_wattr (regbase, VGA_ATC_MODE, 1); /* controller mode */
1528 vga_wattr (regbase, VGA_ATC_OVERSCAN, 0); /* overscan (border) color */
1529 vga_wattr (regbase, VGA_ATC_PLANE_ENABLE, 15); /* color plane enable */
1530 vga_wattr (regbase, CL_AR33, 0); /* pixel panning */
1531 vga_wattr (regbase, VGA_ATC_COLOR_PAGE, 0); /* color select */
1532
1533 /* [ EGS: SetOffset(); ] */
1534 /* From SetOffset(): Turn on VideoEnable bit in Attribute controller */
1535 AttrOn (cinfo);
1536
1537 vga_wgfx (regbase, VGA_GFX_SR_VALUE, 0); /* set/reset register */
1538 vga_wgfx (regbase, VGA_GFX_SR_ENABLE, 0); /* set/reset enable */
1539 vga_wgfx (regbase, VGA_GFX_COMPARE_VALUE, 0); /* color compare */
1540 vga_wgfx (regbase, VGA_GFX_DATA_ROTATE, 0); /* data rotate */
1541 vga_wgfx (regbase, VGA_GFX_PLANE_READ, 0); /* read map select */
1542 vga_wgfx (regbase, VGA_GFX_MISC, 1); /* miscellaneous register */
1543 vga_wgfx (regbase, VGA_GFX_COMPARE_MASK, 15); /* color don't care */
1544 vga_wgfx (regbase, VGA_GFX_BIT_MASK, 255); /* bit mask */
1545
1546 vga_wseq (regbase, CL_SEQR12, 0x0); /* graphics cursor attributes: nothing special */
1547
1548 /* finally, turn on everything - turn off "FullBandwidth" bit */
1549 /* also, set "DotClock%2" bit where requested */
1550 tmp = 0x01;
1551
1552 /*** FB_VMODE_CLOCK_HALVE in linux/fb.h not defined anymore ?
1553 if (var->vmode & FB_VMODE_CLOCK_HALVE)
1554 tmp |= 0x08;
1555 */
1556
1557 vga_wseq (regbase, VGA_SEQ_CLOCK_MODE, tmp);
1558 DPRINTK ("CL_SEQR1: %d\n", tmp);
1559
1560 cinfo->currentmode = regs;
1561 info->fix.type = regs.type;
1562 info->fix.visual = regs.visual;
1563 info->fix.line_length = regs.line_length;
1564
1565 /* pan to requested offset */
1566 cirrusfb_pan_display (var, info);
1567
1568 #ifdef CIRRUSFB_DEBUG
1569 cirrusfb_dump ();
1570 #endif
1571
1572 DPRINTK ("EXIT\n");
1573 return 0;
1574 }
1575
1576 /* for some reason incomprehensible to me, cirrusfb requires that you write
1577 * the registers twice for the settings to take..grr. -dte */
1578 static int cirrusfb_set_par (struct fb_info *info)
1579 {
1580 cirrusfb_set_par_foo (info);
1581 return cirrusfb_set_par_foo (info);
1582 }
1583
1584 static int cirrusfb_setcolreg (unsigned regno, unsigned red, unsigned green,
1585 unsigned blue, unsigned transp,
1586 struct fb_info *info)
1587 {
1588 struct cirrusfb_info *cinfo = info->par;
1589
1590 if (regno > 255)
1591 return -EINVAL;
1592
1593 if (info->fix.visual == FB_VISUAL_TRUECOLOR) {
1594 u32 v;
1595 red >>= (16 - info->var.red.length);
1596 green >>= (16 - info->var.green.length);
1597 blue >>= (16 - info->var.blue.length);
1598
1599 if (regno>=16)
1600 return 1;
1601 v = (red << info->var.red.offset) |
1602 (green << info->var.green.offset) |
1603 (blue << info->var.blue.offset);
1604
1605 switch (info->var.bits_per_pixel) {
1606 case 8:
1607 ((u8*)(info->pseudo_palette))[regno] = v;
1608 break;
1609 case 16:
1610 ((u16*)(info->pseudo_palette))[regno] = v;
1611 break;
1612 case 24:
1613 case 32:
1614 ((u32*)(info->pseudo_palette))[regno] = v;
1615 break;
1616 }
1617 return 0;
1618 }
1619
1620 cinfo->palette[regno].red = red;
1621 cinfo->palette[regno].green = green;
1622 cinfo->palette[regno].blue = blue;
1623
1624 if (info->var.bits_per_pixel == 8) {
1625 WClut (cinfo, regno, red >> 10, green >> 10, blue >> 10);
1626 }
1627
1628 return 0;
1629
1630 }
1631
1632 /*************************************************************************
1633 cirrusfb_pan_display()
1634
1635 performs display panning - provided hardware permits this
1636 **************************************************************************/
1637 static int cirrusfb_pan_display (struct fb_var_screeninfo *var,
1638 struct fb_info *info)
1639 {
1640 int xoffset = 0;
1641 int yoffset = 0;
1642 unsigned long base;
1643 unsigned char tmp = 0, tmp2 = 0, xpix;
1644 struct cirrusfb_info *cinfo = info->par;
1645
1646 DPRINTK ("ENTER\n");
1647 DPRINTK ("virtual offset: (%d,%d)\n", var->xoffset, var->yoffset);
1648
1649 /* no range checks for xoffset and yoffset, */
1650 /* as fb_pan_display has already done this */
1651 if (var->vmode & FB_VMODE_YWRAP)
1652 return -EINVAL;
1653
1654 info->var.xoffset = var->xoffset;
1655 info->var.yoffset = var->yoffset;
1656
1657 xoffset = var->xoffset * info->var.bits_per_pixel / 8;
1658 yoffset = var->yoffset;
1659
1660 base = yoffset * cinfo->currentmode.line_length + xoffset;
1661
1662 if (info->var.bits_per_pixel == 1) {
1663 /* base is already correct */
1664 xpix = (unsigned char) (var->xoffset % 8);
1665 } else {
1666 base /= 4;
1667 xpix = (unsigned char) ((xoffset % 4) * 2);
1668 }
1669
1670 cirrusfb_WaitBLT(cinfo->regbase); /* make sure all the BLT's are done */
1671
1672 /* lower 8 + 8 bits of screen start address */
1673 vga_wcrt (cinfo->regbase, VGA_CRTC_START_LO, (unsigned char) (base & 0xff));
1674 vga_wcrt (cinfo->regbase, VGA_CRTC_START_HI, (unsigned char) (base >> 8));
1675
1676 /* construct bits 16, 17 and 18 of screen start address */
1677 if (base & 0x10000)
1678 tmp |= 0x01;
1679 if (base & 0x20000)
1680 tmp |= 0x04;
1681 if (base & 0x40000)
1682 tmp |= 0x08;
1683
1684 tmp2 = (vga_rcrt (cinfo->regbase, CL_CRT1B) & 0xf2) | tmp; /* 0xf2 is %11110010, exclude tmp bits */
1685 vga_wcrt (cinfo->regbase, CL_CRT1B, tmp2);
1686
1687 /* construct bit 19 of screen start address */
1688 if (cirrusfb_board_info[cinfo->btype].scrn_start_bit19) {
1689 tmp2 = 0;
1690 if (base & 0x80000)
1691 tmp2 = 0x80;
1692 vga_wcrt (cinfo->regbase, CL_CRT1D, tmp2);
1693 }
1694
1695 /* write pixel panning value to AR33; this does not quite work in 8bpp */
1696 /* ### Piccolo..? Will this work? */
1697 if (info->var.bits_per_pixel == 1)
1698 vga_wattr (cinfo->regbase, CL_AR33, xpix);
1699
1700 cirrusfb_WaitBLT (cinfo->regbase);
1701
1702 DPRINTK ("EXIT\n");
1703 return (0);
1704 }
1705
1706
1707 static int cirrusfb_blank (int blank_mode, struct fb_info *info)
1708 {
1709 /*
1710 * Blank the screen if blank_mode != 0, else unblank. If blank == NULL
1711 * then the caller blanks by setting the CLUT (Color Look Up Table) to all
1712 * black. Return 0 if blanking succeeded, != 0 if un-/blanking failed due
1713 * to e.g. a video mode which doesn't support it. Implements VESA suspend
1714 * and powerdown modes on hardware that supports disabling hsync/vsync:
1715 * blank_mode == 2: suspend vsync
1716 * blank_mode == 3: suspend hsync
1717 * blank_mode == 4: powerdown
1718 */
1719 unsigned char val;
1720 struct cirrusfb_info *cinfo = info->par;
1721 int current_mode = cinfo->blank_mode;
1722
1723 DPRINTK ("ENTER, blank mode = %d\n", blank_mode);
1724
1725 if (info->state != FBINFO_STATE_RUNNING ||
1726 current_mode == blank_mode) {
1727 DPRINTK ("EXIT, returning 0\n");
1728 return 0;
1729 }
1730
1731 /* Undo current */
1732 if (current_mode == FB_BLANK_NORMAL ||
1733 current_mode == FB_BLANK_UNBLANK) {
1734 /* unblank the screen */
1735 val = vga_rseq (cinfo->regbase, VGA_SEQ_CLOCK_MODE);
1736 vga_wseq (cinfo->regbase, VGA_SEQ_CLOCK_MODE, val & 0xdf); /* clear "FullBandwidth" bit */
1737 /* and undo VESA suspend trickery */
1738 vga_wgfx (cinfo->regbase, CL_GRE, 0x00);
1739 }
1740
1741 /* set new */
1742 if(blank_mode > FB_BLANK_NORMAL) {
1743 /* blank the screen */
1744 val = vga_rseq (cinfo->regbase, VGA_SEQ_CLOCK_MODE);
1745 vga_wseq (cinfo->regbase, VGA_SEQ_CLOCK_MODE, val | 0x20); /* set "FullBandwidth" bit */
1746 }
1747
1748 switch (blank_mode) {
1749 case FB_BLANK_UNBLANK:
1750 case FB_BLANK_NORMAL:
1751 break;
1752 case FB_BLANK_VSYNC_SUSPEND:
1753 vga_wgfx (cinfo->regbase, CL_GRE, 0x04);
1754 break;
1755 case FB_BLANK_HSYNC_SUSPEND:
1756 vga_wgfx (cinfo->regbase, CL_GRE, 0x02);
1757 break;
1758 case FB_BLANK_POWERDOWN:
1759 vga_wgfx (cinfo->regbase, CL_GRE, 0x06);
1760 break;
1761 default:
1762 DPRINTK ("EXIT, returning 1\n");
1763 return 1;
1764 }
1765
1766 cinfo->blank_mode = blank_mode;
1767 DPRINTK ("EXIT, returning 0\n");
1768
1769 /* Let fbcon do a soft blank for us */
1770 return (blank_mode == FB_BLANK_NORMAL) ? 1 : 0;
1771 }
1772 /**** END Hardware specific Routines **************************************/
1773 /****************************************************************************/
1774 /**** BEGIN Internal Routines ***********************************************/
1775
1776 static void init_vgachip (struct cirrusfb_info *cinfo)
1777 {
1778 const struct cirrusfb_board_info_rec *bi;
1779
1780 DPRINTK ("ENTER\n");
1781
1782 assert (cinfo != NULL);
1783
1784 bi = &cirrusfb_board_info[cinfo->btype];
1785
1786 /* reset board globally */
1787 switch (cinfo->btype) {
1788 case BT_PICCOLO:
1789 WSFR (cinfo, 0x01);
1790 udelay (500);
1791 WSFR (cinfo, 0x51);
1792 udelay (500);
1793 break;
1794 case BT_PICASSO:
1795 WSFR2 (cinfo, 0xff);
1796 udelay (500);
1797 break;
1798 case BT_SD64:
1799 case BT_SPECTRUM:
1800 WSFR (cinfo, 0x1f);
1801 udelay (500);
1802 WSFR (cinfo, 0x4f);
1803 udelay (500);
1804 break;
1805 case BT_PICASSO4:
1806 vga_wcrt (cinfo->regbase, CL_CRT51, 0x00); /* disable flickerfixer */
1807 mdelay (100);
1808 vga_wgfx (cinfo->regbase, CL_GR2F, 0x00); /* from Klaus' NetBSD driver: */
1809 vga_wgfx (cinfo->regbase, CL_GR33, 0x00); /* put blitter into 542x compat */
1810 vga_wgfx (cinfo->regbase, CL_GR31, 0x00); /* mode */
1811 break;
1812
1813 case BT_GD5480:
1814 vga_wgfx (cinfo->regbase, CL_GR2F, 0x00); /* from Klaus' NetBSD driver: */
1815 break;
1816
1817 case BT_ALPINE:
1818 /* Nothing to do to reset the board. */
1819 break;
1820
1821 default:
1822 printk (KERN_ERR "cirrusfb: Warning: Unknown board type\n");
1823 break;
1824 }
1825
1826 assert (cinfo->size > 0); /* make sure RAM size set by this point */
1827
1828 /* the P4 is not fully initialized here; I rely on it having been */
1829 /* inited under AmigaOS already, which seems to work just fine */
1830 /* (Klaus advised to do it this way) */
1831
1832 if (cinfo->btype != BT_PICASSO4) {
1833 WGen (cinfo, CL_VSSM, 0x10); /* EGS: 0x16 */
1834 WGen (cinfo, CL_POS102, 0x01);
1835 WGen (cinfo, CL_VSSM, 0x08); /* EGS: 0x0e */
1836
1837 if (cinfo->btype != BT_SD64)
1838 WGen (cinfo, CL_VSSM2, 0x01);
1839
1840 vga_wseq (cinfo->regbase, CL_SEQR0, 0x03); /* reset sequencer logic */
1841
1842 vga_wseq (cinfo->regbase, VGA_SEQ_CLOCK_MODE, 0x21); /* FullBandwidth (video off) and 8/9 dot clock */
1843 WGen (cinfo, VGA_MIS_W, 0xc1); /* polarity (-/-), disable access to display memory, VGA_CRTC_START_HI base address: color */
1844
1845 /* vga_wgfx (cinfo->regbase, CL_GRA, 0xce); "magic cookie" - doesn't make any sense to me.. */
1846 vga_wseq (cinfo->regbase, CL_SEQR6, 0x12); /* unlock all extension registers */
1847
1848 vga_wgfx (cinfo->regbase, CL_GR31, 0x04); /* reset blitter */
1849
1850 switch (cinfo->btype) {
1851 case BT_GD5480:
1852 vga_wseq (cinfo->regbase, CL_SEQRF, 0x98);
1853 break;
1854 case BT_ALPINE:
1855 break;
1856 case BT_SD64:
1857 vga_wseq (cinfo->regbase, CL_SEQRF, 0xb8);
1858 break;
1859 default:
1860 vga_wseq (cinfo->regbase, CL_SEQR16, 0x0f);
1861 vga_wseq (cinfo->regbase, CL_SEQRF, 0xb0);
1862 break;
1863 }
1864 }
1865 vga_wseq (cinfo->regbase, VGA_SEQ_PLANE_WRITE, 0xff); /* plane mask: nothing */
1866 vga_wseq (cinfo->regbase, VGA_SEQ_CHARACTER_MAP, 0x00); /* character map select: doesn't even matter in gx mode */
1867 vga_wseq (cinfo->regbase, VGA_SEQ_MEMORY_MODE, 0x0e); /* memory mode: chain-4, no odd/even, ext. memory */
1868
1869 /* controller-internal base address of video memory */
1870 if (bi->init_sr07)
1871 vga_wseq (cinfo->regbase, CL_SEQR7, bi->sr07);
1872
1873 /* vga_wseq (cinfo->regbase, CL_SEQR8, 0x00); *//* EEPROM control: shouldn't be necessary to write to this at all.. */
1874
1875 vga_wseq (cinfo->regbase, CL_SEQR10, 0x00); /* graphics cursor X position (incomplete; position gives rem. 3 bits */
1876 vga_wseq (cinfo->regbase, CL_SEQR11, 0x00); /* graphics cursor Y position (..."... ) */
1877 vga_wseq (cinfo->regbase, CL_SEQR12, 0x00); /* graphics cursor attributes */
1878 vga_wseq (cinfo->regbase, CL_SEQR13, 0x00); /* graphics cursor pattern address */
1879
1880 /* writing these on a P4 might give problems.. */
1881 if (cinfo->btype != BT_PICASSO4) {
1882 vga_wseq (cinfo->regbase, CL_SEQR17, 0x00); /* configuration readback and ext. color */
1883 vga_wseq (cinfo->regbase, CL_SEQR18, 0x02); /* signature generator */
1884 }
1885
1886 /* MCLK select etc. */
1887 if (bi->init_sr1f)
1888 vga_wseq (cinfo->regbase, CL_SEQR1F, bi->sr1f);
1889
1890 vga_wcrt (cinfo->regbase, VGA_CRTC_PRESET_ROW, 0x00); /* Screen A preset row scan: none */
1891 vga_wcrt (cinfo->regbase, VGA_CRTC_CURSOR_START, 0x20); /* Text cursor start: disable text cursor */
1892 vga_wcrt (cinfo->regbase, VGA_CRTC_CURSOR_END, 0x00); /* Text cursor end: - */
1893 vga_wcrt (cinfo->regbase, VGA_CRTC_START_HI, 0x00); /* Screen start address high: 0 */
1894 vga_wcrt (cinfo->regbase, VGA_CRTC_START_LO, 0x00); /* Screen start address low: 0 */
1895 vga_wcrt (cinfo->regbase, VGA_CRTC_CURSOR_HI, 0x00); /* text cursor location high: 0 */
1896 vga_wcrt (cinfo->regbase, VGA_CRTC_CURSOR_LO, 0x00); /* text cursor location low: 0 */
1897
1898 vga_wcrt (cinfo->regbase, VGA_CRTC_UNDERLINE, 0x00); /* Underline Row scanline: - */
1899 vga_wcrt (cinfo->regbase, VGA_CRTC_MODE, 0xc3); /* mode control: timing enable, byte mode, no compat modes */
1900 vga_wcrt (cinfo->regbase, VGA_CRTC_LINE_COMPARE, 0x00); /* Line Compare: not needed */
1901 /* ### add 0x40 for text modes with > 30 MHz pixclock */
1902 vga_wcrt (cinfo->regbase, CL_CRT1B, 0x02); /* ext. display controls: ext.adr. wrap */
1903
1904 vga_wgfx (cinfo->regbase, VGA_GFX_SR_VALUE, 0x00); /* Set/Reset registes: - */
1905 vga_wgfx (cinfo->regbase, VGA_GFX_SR_ENABLE, 0x00); /* Set/Reset enable: - */
1906 vga_wgfx (cinfo->regbase, VGA_GFX_COMPARE_VALUE, 0x00); /* Color Compare: - */
1907 vga_wgfx (cinfo->regbase, VGA_GFX_DATA_ROTATE, 0x00); /* Data Rotate: - */
1908 vga_wgfx (cinfo->regbase, VGA_GFX_PLANE_READ, 0x00); /* Read Map Select: - */
1909 vga_wgfx (cinfo->regbase, VGA_GFX_MODE, 0x00); /* Mode: conf. for 16/4/2 color mode, no odd/even, read/write mode 0 */
1910 vga_wgfx (cinfo->regbase, VGA_GFX_MISC, 0x01); /* Miscellaneous: memory map base address, graphics mode */
1911 vga_wgfx (cinfo->regbase, VGA_GFX_COMPARE_MASK, 0x0f); /* Color Don't care: involve all planes */
1912 vga_wgfx (cinfo->regbase, VGA_GFX_BIT_MASK, 0xff); /* Bit Mask: no mask at all */
1913 if (cinfo->btype == BT_ALPINE)
1914 vga_wgfx (cinfo->regbase, CL_GRB, 0x20); /* (5434 can't have bit 3 set for bitblt) */
1915 else
1916 vga_wgfx (cinfo->regbase, CL_GRB, 0x28); /* Graphics controller mode extensions: finer granularity, 8byte data latches */
1917
1918 vga_wgfx (cinfo->regbase, CL_GRC, 0xff); /* Color Key compare: - */
1919 vga_wgfx (cinfo->regbase, CL_GRD, 0x00); /* Color Key compare mask: - */
1920 vga_wgfx (cinfo->regbase, CL_GRE, 0x00); /* Miscellaneous control: - */
1921 /* vga_wgfx (cinfo->regbase, CL_GR10, 0x00); *//* Background color byte 1: - */
1922 /* vga_wgfx (cinfo->regbase, CL_GR11, 0x00); */
1923
1924 vga_wattr (cinfo->regbase, VGA_ATC_PALETTE0, 0x00); /* Attribute Controller palette registers: "identity mapping" */
1925 vga_wattr (cinfo->regbase, VGA_ATC_PALETTE1, 0x01);
1926 vga_wattr (cinfo->regbase, VGA_ATC_PALETTE2, 0x02);
1927 vga_wattr (cinfo->regbase, VGA_ATC_PALETTE3, 0x03);
1928 vga_wattr (cinfo->regbase, VGA_ATC_PALETTE4, 0x04);
1929 vga_wattr (cinfo->regbase, VGA_ATC_PALETTE5, 0x05);
1930 vga_wattr (cinfo->regbase, VGA_ATC_PALETTE6, 0x06);
1931 vga_wattr (cinfo->regbase, VGA_ATC_PALETTE7, 0x07);
1932 vga_wattr (cinfo->regbase, VGA_ATC_PALETTE8, 0x08);
1933 vga_wattr (cinfo->regbase, VGA_ATC_PALETTE9, 0x09);
1934 vga_wattr (cinfo->regbase, VGA_ATC_PALETTEA, 0x0a);
1935 vga_wattr (cinfo->regbase, VGA_ATC_PALETTEB, 0x0b);
1936 vga_wattr (cinfo->regbase, VGA_ATC_PALETTEC, 0x0c);
1937 vga_wattr (cinfo->regbase, VGA_ATC_PALETTED, 0x0d);
1938 vga_wattr (cinfo->regbase, VGA_ATC_PALETTEE, 0x0e);
1939 vga_wattr (cinfo->regbase, VGA_ATC_PALETTEF, 0x0f);
1940
1941 vga_wattr (cinfo->regbase, VGA_ATC_MODE, 0x01); /* Attribute Controller mode: graphics mode */
1942 vga_wattr (cinfo->regbase, VGA_ATC_OVERSCAN, 0x00); /* Overscan color reg.: reg. 0 */
1943 vga_wattr (cinfo->regbase, VGA_ATC_PLANE_ENABLE, 0x0f); /* Color Plane enable: Enable all 4 planes */
1944 /* ### vga_wattr (cinfo->regbase, CL_AR33, 0x00); * Pixel Panning: - */
1945 vga_wattr (cinfo->regbase, VGA_ATC_COLOR_PAGE, 0x00); /* Color Select: - */
1946
1947 WGen (cinfo, VGA_PEL_MSK, 0xff); /* Pixel mask: no mask */
1948
1949 if (cinfo->btype != BT_ALPINE && cinfo->btype != BT_GD5480)
1950 WGen (cinfo, VGA_MIS_W, 0xc3); /* polarity (-/-), enable display mem, VGA_CRTC_START_HI i/o base = color */
1951
1952 vga_wgfx (cinfo->regbase, CL_GR31, 0x04); /* BLT Start/status: Blitter reset */
1953 vga_wgfx (cinfo->regbase, CL_GR31, 0x00); /* - " - : "end-of-reset" */
1954
1955 /* misc... */
1956 WHDR (cinfo, 0); /* Hidden DAC register: - */
1957
1958 printk (KERN_DEBUG "cirrusfb: This board has %ld bytes of DRAM memory\n", cinfo->size);
1959 DPRINTK ("EXIT\n");
1960 return;
1961 }
1962
1963 static void switch_monitor (struct cirrusfb_info *cinfo, int on)
1964 {
1965 #ifdef CONFIG_ZORRO /* only works on Zorro boards */
1966 static int IsOn = 0; /* XXX not ok for multiple boards */
1967
1968 DPRINTK ("ENTER\n");
1969
1970 if (cinfo->btype == BT_PICASSO4)
1971 return; /* nothing to switch */
1972 if (cinfo->btype == BT_ALPINE)
1973 return; /* nothing to switch */
1974 if (cinfo->btype == BT_GD5480)
1975 return; /* nothing to switch */
1976 if (cinfo->btype == BT_PICASSO) {
1977 if ((on && !IsOn) || (!on && IsOn))
1978 WSFR (cinfo, 0xff);
1979
1980 DPRINTK ("EXIT\n");
1981 return;
1982 }
1983 if (on) {
1984 switch (cinfo->btype) {
1985 case BT_SD64:
1986 WSFR (cinfo, cinfo->SFR | 0x21);
1987 break;
1988 case BT_PICCOLO:
1989 WSFR (cinfo, cinfo->SFR | 0x28);
1990 break;
1991 case BT_SPECTRUM:
1992 WSFR (cinfo, 0x6f);
1993 break;
1994 default: /* do nothing */ break;
1995 }
1996 } else {
1997 switch (cinfo->btype) {
1998 case BT_SD64:
1999 WSFR (cinfo, cinfo->SFR & 0xde);
2000 break;
2001 case BT_PICCOLO:
2002 WSFR (cinfo, cinfo->SFR & 0xd7);
2003 break;
2004 case BT_SPECTRUM:
2005 WSFR (cinfo, 0x4f);
2006 break;
2007 default: /* do nothing */ break;
2008 }
2009 }
2010
2011 DPRINTK ("EXIT\n");
2012 #endif /* CONFIG_ZORRO */
2013 }
2014
2015
2016 /******************************************/
2017 /* Linux 2.6-style accelerated functions */
2018 /******************************************/
2019
2020 static void cirrusfb_prim_fillrect(struct cirrusfb_info *cinfo,
2021 const struct fb_fillrect *region)
2022 {
2023 int m; /* bytes per pixel */
2024 if(cinfo->info->var.bits_per_pixel == 1) {
2025 cirrusfb_RectFill(cinfo->regbase, cinfo->info->var.bits_per_pixel,
2026 region->dx / 8, region->dy,
2027 region->width / 8, region->height,
2028 region->color,
2029 cinfo->currentmode.line_length);
2030 } else {
2031 m = ( cinfo->info->var.bits_per_pixel + 7 ) / 8;
2032 cirrusfb_RectFill(cinfo->regbase, cinfo->info->var.bits_per_pixel,
2033 region->dx * m, region->dy,
2034 region->width * m, region->height,
2035 region->color,
2036 cinfo->currentmode.line_length);
2037 }
2038 return;
2039 }
2040
2041 static void cirrusfb_fillrect (struct fb_info *info, const struct fb_fillrect *region)
2042 {
2043 struct cirrusfb_info *cinfo = info->par;
2044 struct fb_fillrect modded;
2045 int vxres, vyres;
2046
2047 if (info->state != FBINFO_STATE_RUNNING)
2048 return;
2049 if (info->flags & FBINFO_HWACCEL_DISABLED) {
2050 cfb_fillrect(info, region);
2051 return;
2052 }
2053
2054 vxres = info->var.xres_virtual;
2055 vyres = info->var.yres_virtual;
2056
2057 memcpy(&modded, region, sizeof(struct fb_fillrect));
2058
2059 if(!modded.width || !modded.height ||
2060 modded.dx >= vxres || modded.dy >= vyres)
2061 return;
2062
2063 if(modded.dx + modded.width > vxres) modded.width = vxres - modded.dx;
2064 if(modded.dy + modded.height > vyres) modded.height = vyres - modded.dy;
2065
2066 cirrusfb_prim_fillrect(cinfo, &modded);
2067 }
2068
2069 static void cirrusfb_prim_copyarea(struct cirrusfb_info *cinfo,
2070 const struct fb_copyarea *area)
2071 {
2072 int m; /* bytes per pixel */
2073 if(cinfo->info->var.bits_per_pixel == 1) {
2074 cirrusfb_BitBLT(cinfo->regbase, cinfo->info->var.bits_per_pixel,
2075 area->sx / 8, area->sy,
2076 area->dx / 8, area->dy,
2077 area->width / 8, area->height,
2078 cinfo->currentmode.line_length);
2079 } else {
2080 m = ( cinfo->info->var.bits_per_pixel + 7 ) / 8;
2081 cirrusfb_BitBLT(cinfo->regbase, cinfo->info->var.bits_per_pixel,
2082 area->sx * m, area->sy,
2083 area->dx * m, area->dy,
2084 area->width * m, area->height,
2085 cinfo->currentmode.line_length);
2086 }
2087 return;
2088 }
2089
2090
2091 static void cirrusfb_copyarea(struct fb_info *info, const struct fb_copyarea *area)
2092 {
2093 struct cirrusfb_info *cinfo = info->par;
2094 struct fb_copyarea modded;
2095 u32 vxres, vyres;
2096 modded.sx = area->sx;
2097 modded.sy = area->sy;
2098 modded.dx = area->dx;
2099 modded.dy = area->dy;
2100 modded.width = area->width;
2101 modded.height = area->height;
2102
2103 if (info->state != FBINFO_STATE_RUNNING)
2104 return;
2105 if (info->flags & FBINFO_HWACCEL_DISABLED) {
2106 cfb_copyarea(info, area);
2107 return;
2108 }
2109
2110 vxres = info->var.xres_virtual;
2111 vyres = info->var.yres_virtual;
2112
2113 if(!modded.width || !modded.height ||
2114 modded.sx >= vxres || modded.sy >= vyres ||
2115 modded.dx >= vxres || modded.dy >= vyres)
2116 return;
2117
2118 if(modded.sx + modded.width > vxres) modded.width = vxres - modded.sx;
2119 if(modded.dx + modded.width > vxres) modded.width = vxres - modded.dx;
2120 if(modded.sy + modded.height > vyres) modded.height = vyres - modded.sy;
2121 if(modded.dy + modded.height > vyres) modded.height = vyres - modded.dy;
2122
2123 cirrusfb_prim_copyarea(cinfo, &modded);
2124 }
2125
2126 static void cirrusfb_imageblit(struct fb_info *info, const struct fb_image *image)
2127 {
2128 struct cirrusfb_info *cinfo = info->par;
2129
2130 cirrusfb_WaitBLT(cinfo->regbase);
2131 cfb_imageblit(info, image);
2132 }
2133
2134
2135 #ifdef CONFIG_PPC_PREP
2136 #define PREP_VIDEO_BASE ((volatile unsigned long) 0xC0000000)
2137 #define PREP_IO_BASE ((volatile unsigned char *) 0x80000000)
2138 static void get_prep_addrs (unsigned long *display, unsigned long *registers)
2139 {
2140 DPRINTK ("ENTER\n");
2141
2142 *display = PREP_VIDEO_BASE;
2143 *registers = (unsigned long) PREP_IO_BASE;
2144
2145 DPRINTK ("EXIT\n");
2146 }
2147
2148 #endif /* CONFIG_PPC_PREP */
2149
2150
2151 #ifdef CONFIG_PCI
2152 static int release_io_ports = 0;
2153
2154 /* Pulled the logic from XFree86 Cirrus driver to get the memory size,
2155 * based on the DRAM bandwidth bit and DRAM bank switching bit. This
2156 * works with 1MB, 2MB and 4MB configurations (which the Motorola boards
2157 * seem to have. */
2158 static unsigned int cirrusfb_get_memsize (u8 __iomem *regbase)
2159 {
2160 unsigned long mem;
2161 unsigned char SRF;
2162
2163 DPRINTK ("ENTER\n");
2164
2165 SRF = vga_rseq (regbase, CL_SEQRF);
2166 switch ((SRF & 0x18)) {
2167 case 0x08: mem = 512 * 1024; break;
2168 case 0x10: mem = 1024 * 1024; break;
2169 /* 64-bit DRAM data bus width; assume 2MB. Also indicates 2MB memory
2170 * on the 5430. */
2171 case 0x18: mem = 2048 * 1024; break;
2172 default: printk ("CLgenfb: Unknown memory size!\n");
2173 mem = 1024 * 1024;
2174 }
2175 if (SRF & 0x80) {
2176 /* If DRAM bank switching is enabled, there must be twice as much
2177 * memory installed. (4MB on the 5434) */
2178 mem *= 2;
2179 }
2180 /* TODO: Handling of GD5446/5480 (see XF86 sources ...) */
2181
2182 DPRINTK ("EXIT\n");
2183 return mem;
2184 }
2185
2186
2187
2188 static void get_pci_addrs (const struct pci_dev *pdev,
2189 unsigned long *display, unsigned long *registers)
2190 {
2191 assert (pdev != NULL);
2192 assert (display != NULL);
2193 assert (registers != NULL);
2194
2195 DPRINTK ("ENTER\n");
2196
2197 *display = 0;
2198 *registers = 0;
2199
2200 /* This is a best-guess for now */
2201
2202 if (pci_resource_flags(pdev, 0) & IORESOURCE_IO) {
2203 *display = pci_resource_start(pdev, 1);
2204 *registers = pci_resource_start(pdev, 0);
2205 } else {
2206 *display = pci_resource_start(pdev, 0);
2207 *registers = pci_resource_start(pdev, 1);
2208 }
2209
2210 assert (*display != 0);
2211
2212 DPRINTK ("EXIT\n");
2213 }
2214
2215
2216 static void cirrusfb_pci_unmap (struct cirrusfb_info *cinfo)
2217 {
2218 struct pci_dev *pdev = cinfo->pdev;
2219
2220 iounmap(cinfo->fbmem);
2221 #if 0 /* if system didn't claim this region, we would... */
2222 release_mem_region(0xA0000, 65535);
2223 #endif
2224 if (release_io_ports)
2225 release_region(0x3C0, 32);
2226 pci_release_regions(pdev);
2227 framebuffer_release(cinfo->info);
2228 pci_disable_device(pdev);
2229 }
2230 #endif /* CONFIG_PCI */
2231
2232
2233 #ifdef CONFIG_ZORRO
2234 static void __devexit cirrusfb_zorro_unmap (struct cirrusfb_info *cinfo)
2235 {
2236 zorro_release_device(cinfo->zdev);
2237
2238 if (cinfo->btype == BT_PICASSO4) {
2239 cinfo->regbase -= 0x600000;
2240 iounmap ((void *)cinfo->regbase);
2241 iounmap ((void *)cinfo->fbmem);
2242 } else {
2243 if (zorro_resource_start(cinfo->zdev) > 0x01000000)
2244 iounmap ((void *)cinfo->fbmem);
2245 }
2246 framebuffer_release(cinfo->info);
2247 }
2248 #endif /* CONFIG_ZORRO */
2249
2250 static int cirrusfb_set_fbinfo(struct cirrusfb_info *cinfo)
2251 {
2252 struct fb_info *info = cinfo->info;
2253 struct fb_var_screeninfo *var = &info->var;
2254
2255 info->par = cinfo;
2256 info->pseudo_palette = cinfo->pseudo_palette;
2257 info->flags = FBINFO_DEFAULT
2258 | FBINFO_HWACCEL_XPAN
2259 | FBINFO_HWACCEL_YPAN
2260 | FBINFO_HWACCEL_FILLRECT
2261 | FBINFO_HWACCEL_COPYAREA;
2262 if (noaccel)
2263 info->flags |= FBINFO_HWACCEL_DISABLED;
2264 info->fbops = &cirrusfb_ops;
2265 info->screen_base = cinfo->fbmem;
2266 if (cinfo->btype == BT_GD5480) {
2267 if (var->bits_per_pixel == 16)
2268 info->screen_base += 1 * MB_;
2269 if (var->bits_per_pixel == 24 || var->bits_per_pixel == 32)
2270 info->screen_base += 2 * MB_;
2271 }
2272
2273 /* Fill fix common fields */
2274 strlcpy(info->fix.id, cirrusfb_board_info[cinfo->btype].name,
2275 sizeof(info->fix.id));
2276
2277 /* monochrome: only 1 memory plane */
2278 /* 8 bit and above: Use whole memory area */
2279 info->fix.smem_start = cinfo->fbmem_phys;
2280 info->fix.smem_len = (var->bits_per_pixel == 1) ? cinfo->size / 4 : cinfo->size;
2281 info->fix.type = cinfo->currentmode.type;
2282 info->fix.type_aux = 0;
2283 info->fix.visual = cinfo->currentmode.visual;
2284 info->fix.xpanstep = 1;
2285 info->fix.ypanstep = 1;
2286 info->fix.ywrapstep = 0;
2287 info->fix.line_length = cinfo->currentmode.line_length;
2288
2289 /* FIXME: map region at 0xB8000 if available, fill in here */
2290 info->fix.mmio_start = cinfo->fbregs_phys;
2291 info->fix.mmio_len = 0;
2292 info->fix.accel = FB_ACCEL_NONE;
2293
2294 fb_alloc_cmap(&info->cmap, 256, 0);
2295
2296 return 0;
2297 }
2298
2299 static int cirrusfb_register(struct cirrusfb_info *cinfo)
2300 {
2301 struct fb_info *info;
2302 int err;
2303 cirrusfb_board_t btype;
2304
2305 DPRINTK ("ENTER\n");
2306
2307 printk (KERN_INFO "cirrusfb: Driver for Cirrus Logic based graphic boards, v" CIRRUSFB_VERSION "\n");
2308
2309 info = cinfo->info;
2310 btype = cinfo->btype;
2311
2312 /* sanity checks */
2313 assert (btype != BT_NONE);
2314
2315 DPRINTK ("cirrusfb: (RAM start set to: 0x%p)\n", cinfo->fbmem);
2316
2317 /* Make pretend we've set the var so our structures are in a "good" */
2318 /* state, even though we haven't written the mode to the hw yet... */
2319 info->var = cirrusfb_predefined[cirrusfb_def_mode].var;
2320 info->var.activate = FB_ACTIVATE_NOW;
2321
2322 err = cirrusfb_decode_var(&info->var, &cinfo->currentmode, info);
2323 if (err < 0) {
2324 /* should never happen */
2325 DPRINTK("choking on default var... umm, no good.\n");
2326 goto err_unmap_cirrusfb;
2327 }
2328
2329 /* set all the vital stuff */
2330 cirrusfb_set_fbinfo(cinfo);
2331
2332 err = register_framebuffer(info);
2333 if (err < 0) {
2334 printk (KERN_ERR "cirrusfb: could not register fb device; err = %d!\n", err);
2335 goto err_dealloc_cmap;
2336 }
2337
2338 DPRINTK ("EXIT, returning 0\n");
2339 return 0;
2340
2341 err_dealloc_cmap:
2342 fb_dealloc_cmap(&info->cmap);
2343 err_unmap_cirrusfb:
2344 cinfo->unmap(cinfo);
2345 return err;
2346 }
2347
2348 static void __devexit cirrusfb_cleanup (struct fb_info *info)
2349 {
2350 struct cirrusfb_info *cinfo = info->par;
2351 DPRINTK ("ENTER\n");
2352
2353 switch_monitor (cinfo, 0);
2354
2355 unregister_framebuffer (info);
2356 fb_dealloc_cmap (&info->cmap);
2357 printk ("Framebuffer unregistered\n");
2358 cinfo->unmap(cinfo);
2359
2360 DPRINTK ("EXIT\n");
2361 }
2362
2363
2364 #ifdef CONFIG_PCI
2365 static int cirrusfb_pci_register (struct pci_dev *pdev,
2366 const struct pci_device_id *ent)
2367 {
2368 struct cirrusfb_info *cinfo;
2369 struct fb_info *info;
2370 cirrusfb_board_t btype;
2371 unsigned long board_addr, board_size;
2372 int ret;
2373
2374 ret = pci_enable_device(pdev);
2375 if (ret < 0) {
2376 printk(KERN_ERR "cirrusfb: Cannot enable PCI device\n");
2377 goto err_out;
2378 }
2379
2380 info = framebuffer_alloc(sizeof(struct cirrusfb_info), &pdev->dev);
2381 if (!info) {
2382 printk(KERN_ERR "cirrusfb: could not allocate memory\n");
2383 ret = -ENOMEM;
2384 goto err_disable;
2385 }
2386
2387 cinfo = info->par;
2388 cinfo->info = info;
2389 cinfo->pdev = pdev;
2390 cinfo->btype = btype = (cirrusfb_board_t) ent->driver_data;
2391
2392 DPRINTK (" Found PCI device, base address 0 is 0x%lx, btype set to %d\n",
2393 pdev->resource[0].start, btype);
2394 DPRINTK (" base address 1 is 0x%lx\n", pdev->resource[1].start);
2395
2396 if(isPReP) {
2397 pci_write_config_dword (pdev, PCI_BASE_ADDRESS_0, 0x00000000);
2398 #ifdef CONFIG_PPC_PREP
2399 get_prep_addrs (&board_addr, &cinfo->fbregs_phys);
2400 #endif
2401 /* PReP dies if we ioremap the IO registers, but it works w/out... */
2402 cinfo->regbase = (char __iomem *) cinfo->fbregs_phys;
2403 } else {
2404 DPRINTK ("Attempt to get PCI info for Cirrus Graphics Card\n");
2405 get_pci_addrs (pdev, &board_addr, &cinfo->fbregs_phys);
2406 cinfo->regbase = NULL; /* FIXME: this forces VGA. alternatives? */
2407 }
2408
2409 DPRINTK ("Board address: 0x%lx, register address: 0x%lx\n", board_addr, cinfo->fbregs_phys);
2410
2411 board_size = (btype == BT_GD5480) ?
2412 32 * MB_ : cirrusfb_get_memsize (cinfo->regbase);
2413
2414 ret = pci_request_regions(pdev, "cirrusfb");
2415 if (ret <0) {
2416 printk(KERN_ERR "cirrusfb: cannot reserve region 0x%lx, abort\n",
2417 board_addr);
2418 goto err_release_fb;
2419 }
2420 #if 0 /* if the system didn't claim this region, we would... */
2421 if (!request_mem_region(0xA0000, 65535, "cirrusfb")) {
2422 printk(KERN_ERR "cirrusfb: cannot reserve region 0x%lx, abort\n"
2423 ,
2424 0xA0000L);
2425 ret = -EBUSY;
2426 goto err_release_regions;
2427 }
2428 #endif
2429 if (request_region(0x3C0, 32, "cirrusfb"))
2430 release_io_ports = 1;
2431
2432 cinfo->fbmem = ioremap(board_addr, board_size);
2433 if (!cinfo->fbmem) {
2434 ret = -EIO;
2435 goto err_release_legacy;
2436 }
2437
2438 cinfo->fbmem_phys = board_addr;
2439 cinfo->size = board_size;
2440 cinfo->unmap = cirrusfb_pci_unmap;
2441
2442 printk (" RAM (%lu kB) at 0xx%lx, ", cinfo->size / KB_, board_addr);
2443 printk ("Cirrus Logic chipset on PCI bus\n");
2444 pci_set_drvdata(pdev, info);
2445
2446 return cirrusfb_register(cinfo);
2447
2448 err_release_legacy:
2449 if (release_io_ports)
2450 release_region(0x3C0, 32);
2451 #if 0
2452 release_mem_region(0xA0000, 65535);
2453 err_release_regions:
2454 #endif
2455 pci_release_regions(pdev);
2456 err_release_fb:
2457 framebuffer_release(info);
2458 err_disable:
2459 pci_disable_device(pdev);
2460 err_out:
2461 return ret;
2462 }
2463
2464 static void __devexit cirrusfb_pci_unregister (struct pci_dev *pdev)
2465 {
2466 struct fb_info *info = pci_get_drvdata(pdev);
2467 DPRINTK ("ENTER\n");
2468
2469 cirrusfb_cleanup (info);
2470
2471 DPRINTK ("EXIT\n");
2472 }
2473
2474 static struct pci_driver cirrusfb_pci_driver = {
2475 .name = "cirrusfb",
2476 .id_table = cirrusfb_pci_table,
2477 .probe = cirrusfb_pci_register,
2478 .remove = __devexit_p(cirrusfb_pci_unregister),
2479 #ifdef CONFIG_PM
2480 #if 0
2481 .suspend = cirrusfb_pci_suspend,
2482 .resume = cirrusfb_pci_resume,
2483 #endif
2484 #endif
2485 };
2486 #endif /* CONFIG_PCI */
2487
2488
2489 #ifdef CONFIG_ZORRO
2490 static int cirrusfb_zorro_register(struct zorro_dev *z,
2491 const struct zorro_device_id *ent)
2492 {
2493 struct cirrusfb_info *cinfo;
2494 struct fb_info *info;
2495 cirrusfb_board_t btype;
2496 struct zorro_dev *z2 = NULL;
2497 unsigned long board_addr, board_size, size;
2498 int ret;
2499
2500 btype = ent->driver_data;
2501 if (cirrusfb_zorro_table2[btype].id2)
2502 z2 = zorro_find_device(cirrusfb_zorro_table2[btype].id2, NULL);
2503 size = cirrusfb_zorro_table2[btype].size;
2504 printk(KERN_INFO "cirrusfb: %s board detected; ",
2505 cirrusfb_board_info[btype].name);
2506
2507 info = framebuffer_alloc(sizeof(struct cirrusfb_info), &z->dev);
2508 if (!info) {
2509 printk (KERN_ERR "cirrusfb: could not allocate memory\n");
2510 ret = -ENOMEM;
2511 goto err_out;
2512 }
2513
2514 cinfo = info->par;
2515 cinfo->info = info;
2516 cinfo->btype = btype;
2517
2518 assert (z > 0);
2519 assert (z2 >= 0);
2520 assert (btype != BT_NONE);
2521
2522 cinfo->zdev = z;
2523 board_addr = zorro_resource_start(z);
2524 board_size = zorro_resource_len(z);
2525 cinfo->size = size;
2526
2527 if (!zorro_request_device(z, "cirrusfb")) {
2528 printk(KERN_ERR "cirrusfb: cannot reserve region 0x%lx, abort\n",
2529 board_addr);
2530 ret = -EBUSY;
2531 goto err_release_fb;
2532 }
2533
2534 printk (" RAM (%lu MB) at $%lx, ", board_size / MB_, board_addr);
2535
2536 ret = -EIO;
2537
2538 if (btype == BT_PICASSO4) {
2539 printk (" REG at $%lx\n", board_addr + 0x600000);
2540
2541 /* To be precise, for the P4 this is not the */
2542 /* begin of the board, but the begin of RAM. */
2543 /* for P4, map in its address space in 2 chunks (### TEST! ) */
2544 /* (note the ugly hardcoded 16M number) */
2545 cinfo->regbase = ioremap (board_addr, 16777216);
2546 if (!cinfo->regbase)
2547 goto err_release_region;
2548
2549 DPRINTK ("cirrusfb: Virtual address for board set to: $%p\n", cinfo->regbase);
2550 cinfo->regbase += 0x600000;
2551 cinfo->fbregs_phys = board_addr + 0x600000;
2552
2553 cinfo->fbmem_phys = board_addr + 16777216;
2554 cinfo->fbmem = ioremap (cinfo->fbmem_phys, 16777216);
2555 if (!cinfo->fbmem)
2556 goto err_unmap_regbase;
2557 } else {
2558 printk (" REG at $%lx\n", (unsigned long) z2->resource.start);
2559
2560 cinfo->fbmem_phys = board_addr;
2561 if (board_addr > 0x01000000)
2562 cinfo->fbmem = ioremap (board_addr, board_size);
2563 else
2564 cinfo->fbmem = (caddr_t) ZTWO_VADDR (board_addr);
2565 if (!cinfo->fbmem)
2566 goto err_release_region;
2567
2568 /* set address for REG area of board */
2569 cinfo->regbase = (caddr_t) ZTWO_VADDR (z2->resource.start);
2570 cinfo->fbregs_phys = z2->resource.start;
2571
2572 DPRINTK ("cirrusfb: Virtual address for board set to: $%p\n", cinfo->regbase);
2573 }
2574 cinfo->unmap = cirrusfb_zorro_unmap;
2575
2576 printk (KERN_INFO "Cirrus Logic chipset on Zorro bus\n");
2577 zorro_set_drvdata(z, info);
2578
2579 return cirrusfb_register(cinfo);
2580
2581 err_unmap_regbase:
2582 /* Parental advisory: explicit hack */
2583 iounmap(cinfo->regbase - 0x600000);
2584 err_release_region:
2585 release_region(board_addr, board_size);
2586 err_release_fb:
2587 framebuffer_release(info);
2588 err_out:
2589 return ret;
2590 }
2591
2592 void __devexit cirrusfb_zorro_unregister(struct zorro_dev *z)
2593 {
2594 struct fb_info *info = zorro_get_drvdata(z);
2595 DPRINTK ("ENTER\n");
2596
2597 cirrusfb_cleanup (info);
2598
2599 DPRINTK ("EXIT\n");
2600 }
2601
2602 static struct zorro_driver cirrusfb_zorro_driver = {
2603 .name = "cirrusfb",
2604 .id_table = cirrusfb_zorro_table,
2605 .probe = cirrusfb_zorro_register,
2606 .remove = __devexit_p(cirrusfb_zorro_unregister),
2607 };
2608 #endif /* CONFIG_ZORRO */
2609
2610 static int __init cirrusfb_init(void)
2611 {
2612 int error = 0;
2613
2614 #ifndef MODULE
2615 char *option = NULL;
2616
2617 if (fb_get_options("cirrusfb", &option))
2618 return -ENODEV;
2619 cirrusfb_setup(option);
2620 #endif
2621
2622 #ifdef CONFIG_ZORRO
2623 error |= zorro_module_init(&cirrusfb_zorro_driver);
2624 #endif
2625 #ifdef CONFIG_PCI
2626 error |= pci_register_driver(&cirrusfb_pci_driver);
2627 #endif
2628 return error;
2629 }
2630
2631
2632
2633 #ifndef MODULE
2634 static int __init cirrusfb_setup(char *options) {
2635 char *this_opt, s[32];
2636 int i;
2637
2638 DPRINTK ("ENTER\n");
2639
2640 if (!options || !*options)
2641 return 0;
2642
2643 while ((this_opt = strsep (&options, ",")) != NULL) {
2644 if (!*this_opt) continue;
2645
2646 DPRINTK("cirrusfb_setup: option '%s'\n", this_opt);
2647
2648 for (i = 0; i < NUM_TOTAL_MODES; i++) {
2649 sprintf (s, "mode:%s", cirrusfb_predefined[i].name);
2650 if (strcmp (this_opt, s) == 0)
2651 cirrusfb_def_mode = i;
2652 }
2653 if (!strcmp(this_opt, "noaccel"))
2654 noaccel = 1;
2655 }
2656 return 0;
2657 }
2658 #endif
2659
2660
2661 /*
2662 * Modularization
2663 */
2664
2665 MODULE_AUTHOR("Copyright 1999,2000 Jeff Garzik <jgarzik@pobox.com>");
2666 MODULE_DESCRIPTION("Accelerated FBDev driver for Cirrus Logic chips");
2667 MODULE_LICENSE("GPL");
2668
2669 static void __exit cirrusfb_exit (void)
2670 {
2671 #ifdef CONFIG_PCI
2672 pci_unregister_driver(&cirrusfb_pci_driver);
2673 #endif
2674 #ifdef CONFIG_ZORRO
2675 zorro_unregister_driver(&cirrusfb_zorro_driver);
2676 #endif
2677 }
2678
2679 module_init(cirrusfb_init);
2680
2681 #ifdef MODULE
2682 module_exit(cirrusfb_exit);
2683 #endif
2684
2685
2686 /**********************************************************************/
2687 /* about the following functions - I have used the same names for the */
2688 /* functions as Markus Wild did in his Retina driver for NetBSD as */
2689 /* they just made sense for this purpose. Apart from that, I wrote */
2690 /* these functions myself. */
2691 /**********************************************************************/
2692
2693 /*** WGen() - write into one of the external/general registers ***/
2694 static void WGen (const struct cirrusfb_info *cinfo,
2695 int regnum, unsigned char val)
2696 {
2697 unsigned long regofs = 0;
2698
2699 if (cinfo->btype == BT_PICASSO) {
2700 /* Picasso II specific hack */
2701 /* if (regnum == VGA_PEL_IR || regnum == VGA_PEL_D || regnum == CL_VSSM2) */
2702 if (regnum == VGA_PEL_IR || regnum == VGA_PEL_D)
2703 regofs = 0xfff;
2704 }
2705
2706 vga_w (cinfo->regbase, regofs + regnum, val);
2707 }
2708
2709 /*** RGen() - read out one of the external/general registers ***/
2710 static unsigned char RGen (const struct cirrusfb_info *cinfo, int regnum)
2711 {
2712 unsigned long regofs = 0;
2713
2714 if (cinfo->btype == BT_PICASSO) {
2715 /* Picasso II specific hack */
2716 /* if (regnum == VGA_PEL_IR || regnum == VGA_PEL_D || regnum == CL_VSSM2) */
2717 if (regnum == VGA_PEL_IR || regnum == VGA_PEL_D)
2718 regofs = 0xfff;
2719 }
2720
2721 return vga_r (cinfo->regbase, regofs + regnum);
2722 }
2723
2724 /*** AttrOn() - turn on VideoEnable for Attribute controller ***/
2725 static void AttrOn (const struct cirrusfb_info *cinfo)
2726 {
2727 assert (cinfo != NULL);
2728
2729 DPRINTK ("ENTER\n");
2730
2731 if (vga_rcrt (cinfo->regbase, CL_CRT24) & 0x80) {
2732 /* if we're just in "write value" mode, write back the */
2733 /* same value as before to not modify anything */
2734 vga_w (cinfo->regbase, VGA_ATT_IW,
2735 vga_r (cinfo->regbase, VGA_ATT_R));
2736 }
2737 /* turn on video bit */
2738 /* vga_w (cinfo->regbase, VGA_ATT_IW, 0x20); */
2739 vga_w (cinfo->regbase, VGA_ATT_IW, 0x33);
2740
2741 /* dummy write on Reg0 to be on "write index" mode next time */
2742 vga_w (cinfo->regbase, VGA_ATT_IW, 0x00);
2743
2744 DPRINTK ("EXIT\n");
2745 }
2746
2747 /*** WHDR() - write into the Hidden DAC register ***/
2748 /* as the HDR is the only extension register that requires special treatment
2749 * (the other extension registers are accessible just like the "ordinary"
2750 * registers of their functional group) here is a specialized routine for
2751 * accessing the HDR
2752 */
2753 static void WHDR (const struct cirrusfb_info *cinfo, unsigned char val)
2754 {
2755 unsigned char dummy;
2756
2757 if (cinfo->btype == BT_PICASSO) {
2758 /* Klaus' hint for correct access to HDR on some boards */
2759 /* first write 0 to pixel mask (3c6) */
2760 WGen (cinfo, VGA_PEL_MSK, 0x00);
2761 udelay (200);
2762 /* next read dummy from pixel address (3c8) */
2763 dummy = RGen (cinfo, VGA_PEL_IW);
2764 udelay (200);
2765 }
2766 /* now do the usual stuff to access the HDR */
2767
2768 dummy = RGen (cinfo, VGA_PEL_MSK);
2769 udelay (200);
2770 dummy = RGen (cinfo, VGA_PEL_MSK);
2771 udelay (200);
2772 dummy = RGen (cinfo, VGA_PEL_MSK);
2773 udelay (200);
2774 dummy = RGen (cinfo, VGA_PEL_MSK);
2775 udelay (200);
2776
2777 WGen (cinfo, VGA_PEL_MSK, val);
2778 udelay (200);
2779
2780 if (cinfo->btype == BT_PICASSO) {
2781 /* now first reset HDR access counter */
2782 dummy = RGen (cinfo, VGA_PEL_IW);
2783 udelay (200);
2784
2785 /* and at the end, restore the mask value */
2786 /* ## is this mask always 0xff? */
2787 WGen (cinfo, VGA_PEL_MSK, 0xff);
2788 udelay (200);
2789 }
2790 }
2791
2792
2793 /*** WSFR() - write to the "special function register" (SFR) ***/
2794 static void WSFR (struct cirrusfb_info *cinfo, unsigned char val)
2795 {
2796 #ifdef CONFIG_ZORRO
2797 assert (cinfo->regbase != NULL);
2798 cinfo->SFR = val;
2799 z_writeb (val, cinfo->regbase + 0x8000);
2800 #endif
2801 }
2802
2803 /* The Picasso has a second register for switching the monitor bit */
2804 static void WSFR2 (struct cirrusfb_info *cinfo, unsigned char val)
2805 {
2806 #ifdef CONFIG_ZORRO
2807 /* writing an arbitrary value to this one causes the monitor switcher */
2808 /* to flip to Amiga display */
2809 assert (cinfo->regbase != NULL);
2810 cinfo->SFR = val;
2811 z_writeb (val, cinfo->regbase + 0x9000);
2812 #endif
2813 }
2814
2815
2816 /*** WClut - set CLUT entry (range: 0..63) ***/
2817 static void WClut (struct cirrusfb_info *cinfo, unsigned char regnum, unsigned char red,
2818 unsigned char green, unsigned char blue)
2819 {
2820 unsigned int data = VGA_PEL_D;
2821
2822 /* address write mode register is not translated.. */
2823 vga_w (cinfo->regbase, VGA_PEL_IW, regnum);
2824
2825 if (cinfo->btype == BT_PICASSO || cinfo->btype == BT_PICASSO4 ||
2826 cinfo->btype == BT_ALPINE || cinfo->btype == BT_GD5480) {
2827 /* but DAC data register IS, at least for Picasso II */
2828 if (cinfo->btype == BT_PICASSO)
2829 data += 0xfff;
2830 vga_w (cinfo->regbase, data, red);
2831 vga_w (cinfo->regbase, data, green);
2832 vga_w (cinfo->regbase, data, blue);
2833 } else {
2834 vga_w (cinfo->regbase, data, blue);
2835 vga_w (cinfo->regbase, data, green);
2836 vga_w (cinfo->regbase, data, red);
2837 }
2838 }
2839
2840
2841 #if 0
2842 /*** RClut - read CLUT entry (range 0..63) ***/
2843 static void RClut (struct cirrusfb_info *cinfo, unsigned char regnum, unsigned char *red,
2844 unsigned char *green, unsigned char *blue)
2845 {
2846 unsigned int data = VGA_PEL_D;
2847
2848 vga_w (cinfo->regbase, VGA_PEL_IR, regnum);
2849
2850 if (cinfo->btype == BT_PICASSO || cinfo->btype == BT_PICASSO4 ||
2851 cinfo->btype == BT_ALPINE || cinfo->btype == BT_GD5480) {
2852 if (cinfo->btype == BT_PICASSO)
2853 data += 0xfff;
2854 *red = vga_r (cinfo->regbase, data);
2855 *green = vga_r (cinfo->regbase, data);
2856 *blue = vga_r (cinfo->regbase, data);
2857 } else {
2858 *blue = vga_r (cinfo->regbase, data);
2859 *green = vga_r (cinfo->regbase, data);
2860 *red = vga_r (cinfo->regbase, data);
2861 }
2862 }
2863 #endif
2864
2865
2866 /*******************************************************************
2867 cirrusfb_WaitBLT()
2868
2869 Wait for the BitBLT engine to complete a possible earlier job
2870 *********************************************************************/
2871
2872 /* FIXME: use interrupts instead */
2873 static void cirrusfb_WaitBLT (u8 __iomem *regbase)
2874 {
2875 /* now busy-wait until we're done */
2876 while (vga_rgfx (regbase, CL_GR31) & 0x08)
2877 /* do nothing */ ;
2878 }
2879
2880 /*******************************************************************
2881 cirrusfb_BitBLT()
2882
2883 perform accelerated "scrolling"
2884 ********************************************************************/
2885
2886 static void cirrusfb_BitBLT (u8 __iomem *regbase, int bits_per_pixel,
2887 u_short curx, u_short cury, u_short destx, u_short desty,
2888 u_short width, u_short height, u_short line_length)
2889 {
2890 u_short nwidth, nheight;
2891 u_long nsrc, ndest;
2892 u_char bltmode;
2893
2894 DPRINTK ("ENTER\n");
2895
2896 nwidth = width - 1;
2897 nheight = height - 1;
2898
2899 bltmode = 0x00;
2900 /* if source adr < dest addr, do the Blt backwards */
2901 if (cury <= desty) {
2902 if (cury == desty) {
2903 /* if src and dest are on the same line, check x */
2904 if (curx < destx)
2905 bltmode |= 0x01;
2906 } else
2907 bltmode |= 0x01;
2908 }
2909 if (!bltmode) {
2910 /* standard case: forward blitting */
2911 nsrc = (cury * line_length) + curx;
2912 ndest = (desty * line_length) + destx;
2913 } else {
2914 /* this means start addresses are at the end, counting backwards */
2915 nsrc = cury * line_length + curx + nheight * line_length + nwidth;
2916 ndest = desty * line_length + destx + nheight * line_length + nwidth;
2917 }
2918
2919 /*
2920 run-down of registers to be programmed:
2921 destination pitch
2922 source pitch
2923 BLT width/height
2924 source start
2925 destination start
2926 BLT mode
2927 BLT ROP
2928 VGA_GFX_SR_VALUE / VGA_GFX_SR_ENABLE: "fill color"
2929 start/stop
2930 */
2931
2932 cirrusfb_WaitBLT(regbase);
2933
2934 /* pitch: set to line_length */
2935 vga_wgfx (regbase, CL_GR24, line_length & 0xff); /* dest pitch low */
2936 vga_wgfx (regbase, CL_GR25, (line_length >> 8)); /* dest pitch hi */
2937 vga_wgfx (regbase, CL_GR26, line_length & 0xff); /* source pitch low */
2938 vga_wgfx (regbase, CL_GR27, (line_length >> 8)); /* source pitch hi */
2939
2940 /* BLT width: actual number of pixels - 1 */
2941 vga_wgfx (regbase, CL_GR20, nwidth & 0xff); /* BLT width low */
2942 vga_wgfx (regbase, CL_GR21, (nwidth >> 8)); /* BLT width hi */
2943
2944 /* BLT height: actual number of lines -1 */
2945 vga_wgfx (regbase, CL_GR22, nheight & 0xff); /* BLT height low */
2946 vga_wgfx (regbase, CL_GR23, (nheight >> 8)); /* BLT width hi */
2947
2948 /* BLT destination */
2949 vga_wgfx (regbase, CL_GR28, (u_char) (ndest & 0xff)); /* BLT dest low */
2950 vga_wgfx (regbase, CL_GR29, (u_char) (ndest >> 8)); /* BLT dest mid */
2951 vga_wgfx (regbase, CL_GR2A, (u_char) (ndest >> 16)); /* BLT dest hi */
2952
2953 /* BLT source */
2954 vga_wgfx (regbase, CL_GR2C, (u_char) (nsrc & 0xff)); /* BLT src low */
2955 vga_wgfx (regbase, CL_GR2D, (u_char) (nsrc >> 8)); /* BLT src mid */
2956 vga_wgfx (regbase, CL_GR2E, (u_char) (nsrc >> 16)); /* BLT src hi */
2957
2958 /* BLT mode */
2959 vga_wgfx (regbase, CL_GR30, bltmode); /* BLT mode */
2960
2961 /* BLT ROP: SrcCopy */
2962 vga_wgfx (regbase, CL_GR32, 0x0d); /* BLT ROP */
2963
2964 /* and finally: GO! */
2965 vga_wgfx (regbase, CL_GR31, 0x02); /* BLT Start/status */
2966
2967 DPRINTK ("EXIT\n");
2968 }
2969
2970
2971 /*******************************************************************
2972 cirrusfb_RectFill()
2973
2974 perform accelerated rectangle fill
2975 ********************************************************************/
2976
2977 static void cirrusfb_RectFill (u8 __iomem *regbase, int bits_per_pixel,
2978 u_short x, u_short y, u_short width, u_short height,
2979 u_char color, u_short line_length)
2980 {
2981 u_short nwidth, nheight;
2982 u_long ndest;
2983 u_char op;
2984
2985 DPRINTK ("ENTER\n");
2986
2987 nwidth = width - 1;
2988 nheight = height - 1;
2989
2990 ndest = (y * line_length) + x;
2991
2992 cirrusfb_WaitBLT(regbase);
2993
2994 /* pitch: set to line_length */
2995 vga_wgfx (regbase, CL_GR24, line_length & 0xff); /* dest pitch low */
2996 vga_wgfx (regbase, CL_GR25, (line_length >> 8)); /* dest pitch hi */
2997 vga_wgfx (regbase, CL_GR26, line_length & 0xff); /* source pitch low */
2998 vga_wgfx (regbase, CL_GR27, (line_length >> 8)); /* source pitch hi */
2999
3000 /* BLT width: actual number of pixels - 1 */
3001 vga_wgfx (regbase, CL_GR20, nwidth & 0xff); /* BLT width low */
3002 vga_wgfx (regbase, CL_GR21, (nwidth >> 8)); /* BLT width hi */
3003
3004 /* BLT height: actual number of lines -1 */
3005 vga_wgfx (regbase, CL_GR22, nheight & 0xff); /* BLT height low */
3006 vga_wgfx (regbase, CL_GR23, (nheight >> 8)); /* BLT width hi */
3007
3008 /* BLT destination */
3009 vga_wgfx (regbase, CL_GR28, (u_char) (ndest & 0xff)); /* BLT dest low */
3010 vga_wgfx (regbase, CL_GR29, (u_char) (ndest >> 8)); /* BLT dest mid */
3011 vga_wgfx (regbase, CL_GR2A, (u_char) (ndest >> 16)); /* BLT dest hi */
3012
3013 /* BLT source: set to 0 (is a dummy here anyway) */
3014 vga_wgfx (regbase, CL_GR2C, 0x00); /* BLT src low */
3015 vga_wgfx (regbase, CL_GR2D, 0x00); /* BLT src mid */
3016 vga_wgfx (regbase, CL_GR2E, 0x00); /* BLT src hi */
3017
3018 /* This is a ColorExpand Blt, using the */
3019 /* same color for foreground and background */
3020 vga_wgfx (regbase, VGA_GFX_SR_VALUE, color); /* foreground color */
3021 vga_wgfx (regbase, VGA_GFX_SR_ENABLE, color); /* background color */
3022
3023 op = 0xc0;
3024 if (bits_per_pixel == 16) {
3025 vga_wgfx (regbase, CL_GR10, color); /* foreground color */
3026 vga_wgfx (regbase, CL_GR11, color); /* background color */
3027 op = 0x50;
3028 op = 0xd0;
3029 } else if (bits_per_pixel == 32) {
3030 vga_wgfx (regbase, CL_GR10, color); /* foreground color */
3031 vga_wgfx (regbase, CL_GR11, color); /* background color */
3032 vga_wgfx (regbase, CL_GR12, color); /* foreground color */
3033 vga_wgfx (regbase, CL_GR13, color); /* background color */
3034 vga_wgfx (regbase, CL_GR14, 0); /* foreground color */
3035 vga_wgfx (regbase, CL_GR15, 0); /* background color */
3036 op = 0x50;
3037 op = 0xf0;
3038 }
3039 /* BLT mode: color expand, Enable 8x8 copy (faster?) */
3040 vga_wgfx (regbase, CL_GR30, op); /* BLT mode */
3041
3042 /* BLT ROP: SrcCopy */
3043 vga_wgfx (regbase, CL_GR32, 0x0d); /* BLT ROP */
3044
3045 /* and finally: GO! */
3046 vga_wgfx (regbase, CL_GR31, 0x02); /* BLT Start/status */
3047
3048 DPRINTK ("EXIT\n");
3049 }
3050
3051
3052 /**************************************************************************
3053 * bestclock() - determine closest possible clock lower(?) than the
3054 * desired pixel clock
3055 **************************************************************************/
3056 static void bestclock (long freq, long *best, long *nom,
3057 long *den, long *div, long maxfreq)
3058 {
3059 long n, h, d, f;
3060
3061 assert (best != NULL);
3062 assert (nom != NULL);
3063 assert (den != NULL);
3064 assert (div != NULL);
3065 assert (maxfreq > 0);
3066
3067 *nom = 0;
3068 *den = 0;
3069 *div = 0;
3070
3071 DPRINTK ("ENTER\n");
3072
3073 if (freq < 8000)
3074 freq = 8000;
3075
3076 if (freq > maxfreq)
3077 freq = maxfreq;
3078
3079 *best = 0;
3080 f = freq * 10;
3081
3082 for (n = 32; n < 128; n++) {
3083 d = (143181 * n) / f;
3084 if ((d >= 7) && (d <= 63)) {
3085 if (d > 31)
3086 d = (d / 2) * 2;
3087 h = (14318 * n) / d;
3088 if (abs (h - freq) < abs (*best - freq)) {
3089 *best = h;
3090 *nom = n;
3091 if (d < 32) {
3092 *den = d;
3093 *div = 0;
3094 } else {
3095 *den = d / 2;
3096 *div = 1;
3097 }
3098 }
3099 }
3100 d = ((143181 * n) + f - 1) / f;
3101 if ((d >= 7) && (d <= 63)) {
3102 if (d > 31)
3103 d = (d / 2) * 2;
3104 h = (14318 * n) / d;
3105 if (abs (h - freq) < abs (*best - freq)) {
3106 *best = h;
3107 *nom = n;
3108 if (d < 32) {
3109 *den = d;
3110 *div = 0;
3111 } else {
3112 *den = d / 2;
3113 *div = 1;
3114 }
3115 }
3116 }
3117 }
3118
3119 DPRINTK ("Best possible values for given frequency:\n");
3120 DPRINTK (" best: %ld kHz nom: %ld den: %ld div: %ld\n",
3121 freq, *nom, *den, *div);
3122
3123 DPRINTK ("EXIT\n");
3124 }
3125
3126
3127 /* -------------------------------------------------------------------------
3128 *
3129 * debugging functions
3130 *
3131 * -------------------------------------------------------------------------
3132 */
3133
3134 #ifdef CIRRUSFB_DEBUG
3135
3136 /**
3137 * cirrusfb_dbg_print_byte
3138 * @name: name associated with byte value to be displayed
3139 * @val: byte value to be displayed
3140 *
3141 * DESCRIPTION:
3142 * Display an indented string, along with a hexidecimal byte value, and
3143 * its decoded bits. Bits 7 through 0 are listed in left-to-right
3144 * order.
3145 */
3146
3147 static
3148 void cirrusfb_dbg_print_byte (const char *name, unsigned char val)
3149 {
3150 DPRINTK ("%8s = 0x%02X (bits 7-0: %c%c%c%c%c%c%c%c)\n",
3151 name, val,
3152 val & 0x80 ? '1' : '0',
3153 val & 0x40 ? '1' : '0',
3154 val & 0x20 ? '1' : '0',
3155 val & 0x10 ? '1' : '0',
3156 val & 0x08 ? '1' : '0',
3157 val & 0x04 ? '1' : '0',
3158 val & 0x02 ? '1' : '0',
3159 val & 0x01 ? '1' : '0');
3160 }
3161
3162
3163 /**
3164 * cirrusfb_dbg_print_regs
3165 * @base: If using newmmio, the newmmio base address, otherwise %NULL
3166 * @reg_class: type of registers to read: %CRT, or %SEQ
3167 *
3168 * DESCRIPTION:
3169 * Dumps the given list of VGA CRTC registers. If @base is %NULL,
3170 * old-style I/O ports are queried for information, otherwise MMIO is
3171 * used at the given @base address to query the information.
3172 */
3173
3174 static
3175 void cirrusfb_dbg_print_regs (caddr_t regbase, cirrusfb_dbg_reg_class_t reg_class,...)
3176 {
3177 va_list list;
3178 unsigned char val = 0;
3179 unsigned reg;
3180 char *name;
3181
3182 va_start (list, reg_class);
3183
3184 name = va_arg (list, char *);
3185 while (name != NULL) {
3186 reg = va_arg (list, int);
3187
3188 switch (reg_class) {
3189 case CRT:
3190 val = vga_rcrt (regbase, (unsigned char) reg);
3191 break;
3192 case SEQ:
3193 val = vga_rseq (regbase, (unsigned char) reg);
3194 break;
3195 default:
3196 /* should never occur */
3197 assert (FALSE);
3198 break;
3199 }
3200
3201 cirrusfb_dbg_print_byte (name, val);
3202
3203 name = va_arg (list, char *);
3204 }
3205
3206 va_end (list);
3207 }
3208
3209
3210 /**
3211 * cirrusfb_dump
3212 * @cirrusfbinfo:
3213 *
3214 * DESCRIPTION:
3215 */
3216
3217 static
3218 void cirrusfb_dump (void)
3219 {
3220 cirrusfb_dbg_reg_dump (NULL);
3221 }
3222
3223
3224 /**
3225 * cirrusfb_dbg_reg_dump
3226 * @base: If using newmmio, the newmmio base address, otherwise %NULL
3227 *
3228 * DESCRIPTION:
3229 * Dumps a list of interesting VGA and CIRRUSFB registers. If @base is %NULL,
3230 * old-style I/O ports are queried for information, otherwise MMIO is
3231 * used at the given @base address to query the information.
3232 */
3233
3234 static
3235 void cirrusfb_dbg_reg_dump (caddr_t regbase)
3236 {
3237 DPRINTK ("CIRRUSFB VGA CRTC register dump:\n");
3238
3239 cirrusfb_dbg_print_regs (regbase, CRT,
3240 "CR00", 0x00,
3241 "CR01", 0x01,
3242 "CR02", 0x02,
3243 "CR03", 0x03,
3244 "CR04", 0x04,
3245 "CR05", 0x05,
3246 "CR06", 0x06,
3247 "CR07", 0x07,
3248 "CR08", 0x08,
3249 "CR09", 0x09,
3250 "CR0A", 0x0A,
3251 "CR0B", 0x0B,
3252 "CR0C", 0x0C,
3253 "CR0D", 0x0D,
3254 "CR0E", 0x0E,
3255 "CR0F", 0x0F,
3256 "CR10", 0x10,
3257 "CR11", 0x11,
3258 "CR12", 0x12,
3259 "CR13", 0x13,
3260 "CR14", 0x14,
3261 "CR15", 0x15,
3262 "CR16", 0x16,
3263 "CR17", 0x17,
3264 "CR18", 0x18,
3265 "CR22", 0x22,
3266 "CR24", 0x24,
3267 "CR26", 0x26,
3268 "CR2D", 0x2D,
3269 "CR2E", 0x2E,
3270 "CR2F", 0x2F,
3271 "CR30", 0x30,
3272 "CR31", 0x31,
3273 "CR32", 0x32,
3274 "CR33", 0x33,
3275 "CR34", 0x34,
3276 "CR35", 0x35,
3277 "CR36", 0x36,
3278 "CR37", 0x37,
3279 "CR38", 0x38,
3280 "CR39", 0x39,
3281 "CR3A", 0x3A,
3282 "CR3B", 0x3B,
3283 "CR3C", 0x3C,
3284 "CR3D", 0x3D,
3285 "CR3E", 0x3E,
3286 "CR3F", 0x3F,
3287 NULL);
3288
3289 DPRINTK ("\n");
3290
3291 DPRINTK ("CIRRUSFB VGA SEQ register dump:\n");
3292
3293 cirrusfb_dbg_print_regs (regbase, SEQ,
3294 "SR00", 0x00,
3295 "SR01", 0x01,
3296 "SR02", 0x02,
3297 "SR03", 0x03,
3298 "SR04", 0x04,
3299 "SR08", 0x08,
3300 "SR09", 0x09,
3301 "SR0A", 0x0A,
3302 "SR0B", 0x0B,
3303 "SR0D", 0x0D,
3304 "SR10", 0x10,
3305 "SR11", 0x11,
3306 "SR12", 0x12,
3307 "SR13", 0x13,
3308 "SR14", 0x14,
3309 "SR15", 0x15,
3310 "SR16", 0x16,
3311 "SR17", 0x17,
3312 "SR18", 0x18,
3313 "SR19", 0x19,
3314 "SR1A", 0x1A,
3315 "SR1B", 0x1B,
3316 "SR1C", 0x1C,
3317 "SR1D", 0x1D,
3318 "SR1E", 0x1E,
3319 "SR1F", 0x1F,
3320 NULL);
3321
3322 DPRINTK ("\n");
3323 }
3324
3325 #endif /* CIRRUSFB_DEBUG */
3326
Verdex Pro support