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