8e024aad1b5733a30c39019cebe80e46d2a37459
[linux-3.10.git] / drivers / video / pm3fb.c
1 /*
2  *  linux/drivers/video/pm3fb.c -- 3DLabs Permedia3 frame buffer device
3  *  
4  *  Copyright (C) 2001 Romain Dolbeau <dolbeau@irisa.fr>
5  *  Based on code written by:
6  *           Sven Luther, <luther@dpt-info.u-strasbg.fr>
7  *           Alan Hourihane, <alanh@fairlite.demon.co.uk>
8  *           Russel King, <rmk@arm.linux.org.uk>
9  *  Based on linux/drivers/video/skeletonfb.c:
10  *      Copyright (C) 1997 Geert Uytterhoeven
11  *  Based on linux/driver/video/pm2fb.c:
12  *      Copyright (C) 1998-1999 Ilario Nardinocchi (nardinoc@CS.UniBO.IT)
13  *      Copyright (C) 1999 Jakub Jelinek (jakub@redhat.com)
14  *
15  *  This file is subject to the terms and conditions of the GNU General Public
16  *  License. See the file COPYING in the main directory of this archive for
17  *  more details.
18  *
19  *  $Header: /cvsroot/linux/drivers/video/pm3fb.c,v 1.1 2002/02/25 19:11:06 marcelo Exp $
20  *
21  *  CHANGELOG:
22  *  Mon Feb 11 10:35:48 MET 2002, v 1.4.11B: Cosmetic update.
23  *  Wed Jan 23 14:16:59 MET 2002, v 1.4.11: Preliminary 2.5.x support, patch for 2.5.2.
24  *  Wed Nov 28 11:08:29 MET 2001, v 1.4.10: potential bug fix for SDRAM-based board, patch for 2.4.16.
25  *  Thu Sep 20 10:24:42 MET DST 2001, v 1.4.9: sync bug fix, preliminary flatpanel support, better timings.
26  *  Tue Aug 28 10:13:01 MET DST 2001, v 1.4.8: memory timings check, minor bug fixes.
27  *  Wed Jul 18 19:06:14 CEST 2001, v 1.4.7: Mode fix (800x600-100, 1024x768-100 changed), using HW panning + accel bug fix.
28  *  Mon Jun 25 10:33:56 MET DST 2001, v 1.4.6: Depth 12 fix, chip reset ioctl, moved memory erase ioctl to DEBUG.
29  *  Wed Jun 20 11:13:08 MET DST 2001, v 1.4.5: Fixed missing blinking cursor in 8bpp, code cleaning, memory erase IOCTL.
30  *  Mon Jun 18 16:00:27 CEST 2001, v 1.4.4: Depth 12 (RGBA 4444) support, code cleaning.
31  *  Fri Jun 15 13:53:01 CEST 2001, v 1.4.3: Removed warnings, depth 15 support, add 'depth' option.
32  *  Thu Jun 14 10:13:52 MET DST 2001, v 1.4.2: Fixed depth switching bug, preliminary 15bpp (RGB5551) support.
33  *  Thu Apr 12 11:16:45 MET DST 2001, v 1.4.1B: Doc updates.
34  *  Fri Apr  6 11:12:53 MET DST 2001, v 1.4.1: Configure.help, minor cleanup
35  *  Thu Mar 29 10:56:50 MET DST 2001, v 1.4.0: Module & module options support (note: linux patch changed, 2.2.19 added).
36  *  Thu Mar 15 15:30:31 MET 2001, v 1.3.2: Fixed mirroring bug on little-endian.
37  *  Wed Mar 14 21:25:54 CET 2001, v 1.3.1: Fixed bug in BlockMove (_bmov).
38  *  Tue Mar 13 10:53:19 MET 2001, v 1.3.0: Character drawing hardware support (in all width between 1 and 16), fixes.
39  *  Thu Mar  8 10:20:16 MET 2001, v 1.2.2: Better J2000 support, "font:" option.
40  *  Tue Mar  6 21:25:04 CET 2001, v 1.2.1: Better acceleration support.
41  *  Mon Mar  5 21:54:17 CET 2001, v 1.2.0: Partial acceleration support (clear & bmove)
42  *  Mon Mar  5 12:52:15 CET 2001, v 1.1.3: Big pan_display fix.
43  *  Sun Mar  4 22:21:50 CET 2001, v 1.1.2: (numerous) bug fixes.
44  *  Fri Mar  2 15:54:07 CET 2001, v 1.1.1: Might have Appian J2000 support, resource mangement in 2.4
45  *  Wed Feb 28 18:21:35 CET 2001, v 1.1.0: Might have multiple boards support (added, but not yest tested)
46  *  Tue Feb 27 17:31:12 CET 2001, v 1.0.6: fixes boot-time mode select, add more default mode
47  *  Tue Feb 27 14:01:36 CET 2001, v 1.0.5: fixes (1.0.4 was broken for 2.2), cleaning up
48  *  Mon Feb 26 23:17:36 CET 2001, v 1.0.4: preliminary 2.4.x support, dropped (useless on pm3) partial product, more OF fix
49  *  Mon Feb 26 20:59:05 CET 2001, v 1.0.3: No more shadow register (and wasted memory), endianess fix, use OF-preset resolution by default
50  *  Wed Feb 21 22:09:30 CET 2001, v 1.0.2: Code cleaning for future multiboard support, better OF support, bugs fix
51  *  Wed Feb 21 19:58:56 CET 2001, v 1.0.1: OpenFirmware support, fixed memory detection, better debug support, code cleaning
52  *  Wed Feb 21 14:47:06 CET 2001, v 1.0.0: First working version
53  */
54
55 #include <linux/config.h>
56 #include <linux/module.h>
57 #include <linux/kernel.h>
58 #include <linux/errno.h>
59 #include <linux/string.h>
60 #include <linux/mm.h>
61 #include <linux/tty.h>
62 #include <linux/slab.h>
63 #include <linux/vmalloc.h>
64 #include <linux/delay.h>
65 #include <linux/interrupt.h>
66 #include <linux/fb.h>
67 #include <linux/init.h>
68 #include <linux/pci.h>
69 #include <linux/ioport.h>
70
71 #include <video/fbcon.h>
72 #include <video/fbcon-mfb.h>
73 #include <video/fbcon-cfb2.h>
74 #include <video/fbcon-cfb4.h>
75 #include <video/fbcon-cfb8.h>
76 #include <video/fbcon-cfb16.h>
77 #include <video/fbcon-cfb24.h>
78 #include <video/fbcon-cfb32.h>
79 #include <video/pm3fb.h>
80
81 #include <asm/io.h>
82 #include <asm/uaccess.h>
83
84 #ifdef CONFIG_FB_OF
85 #include <asm/prom.h>
86 #endif
87
88 /* ************************************* */
89 /* ***** The various "global" data ***** */
90 /* ************************************* */
91
92 /* those will need a rework for multiple board support */
93 /* Driver name */
94 static const char permedia3_name[16] = "Permedia3";
95
96 /* the fb_par struct, mandatory */
97 struct pm3fb_par {
98         u32 pixclock;           /* pixclock in KHz */
99
100         u32 width;              /* width of virtual screen */
101         u32 height;             /* height of virtual screen */
102
103         u32 hsstart;            /* horiz. sync start */
104         u32 hsend;              /* horiz. sync end */
105         u32 hbend;              /* horiz. blank end (also gate end) */
106         u32 htotal;             /* total width (w/ sync & blank) */
107
108         u32 vsstart;            /* vert. sync start */
109         u32 vsend;              /* vert. sync end */
110         u32 vbend;              /* vert. blank end */
111         u32 vtotal;             /* total height (w/ sync & blank) */
112
113         u32 stride;             /* screen stride */
114         u32 base;               /* screen base (xoffset+yoffset) in 128 bits unit */
115         /* NOTE : unlike other pm3 stuff above, stored *after* shiftbpp. don't ask */
116         u32 depth;              /* screen depth (8, 12, 15, 16 or 32) */
117         u32 video;              /* video control (hsync,vsync) */
118 };
119
120 /* memory timings */
121 struct pm3fb_timings
122 {
123         unsigned long caps;
124         unsigned long timings;
125         unsigned long control;
126         unsigned long refresh;
127         unsigned long powerdown;
128 };
129 typedef enum pm3fb_timing_result { pm3fb_timing_ok, pm3fb_timing_problem, pm3fb_timing_retry } pm3fb_timing_result;
130 #define PM3FB_UNKNOWN_TIMING_VALUE ((unsigned long)-1)
131 #define PM3FB_UNKNOWN_TIMINGS { PM3FB_UNKNOWN_TIMING_VALUE, PM3FB_UNKNOWN_TIMING_VALUE, PM3FB_UNKNOWN_TIMING_VALUE, PM3FB_UNKNOWN_TIMING_VALUE, PM3FB_UNKNOWN_TIMING_VALUE }
132
133 /* the fb_info struct, mandatory */
134 struct pm3fb_info {
135         struct fb_info_gen gen;
136         unsigned long board_num; /* internal board number */
137         unsigned long use_current;
138         struct pm3fb_par *current_par;
139         struct pci_dev *dev;    /* PCI device */
140         unsigned long board_type; /* index in the cardbase */
141         unsigned char *fb_base; /* framebuffer memory base */
142         u32 fb_size;            /* framebuffer memory size */
143         unsigned char *p_fb;    /* physical address of frame buffer */
144         unsigned char *v_fb;    /* virtual address of frame buffer */
145         unsigned char *pIOBase; /* physical address of registers region, must be rg_base or rg_base+PM2_REGS_SIZE depending on the host endianness */
146         unsigned char *vIOBase; /* address of registers after ioremap() */
147         struct {
148                 u8 transp;
149                 u8 red;
150                 u8 green;
151                 u8 blue;
152         } palette[256];
153         union {
154 #ifdef FBCON_HAS_CFB16
155                 u16 cmap12[16]; /* RGBA 4444 */
156                 u16 cmap15[16]; /* RGBA 5551 */
157                 u16 cmap16[16]; /* RGBA 5650 */
158 #endif
159 #ifdef FBCON_HAS_CFB32
160                 u32 cmap32[16];
161 #endif
162         } cmap;
163         struct pm3fb_timings memt;
164 };
165
166 /* regular resolution database*/
167 static struct {
168         char name[16];
169         struct pm3fb_par user_mode;
170 } mode_base[] __initdata = {
171         {
172                 "default-800x600", {
173         49500, 800, 600, 16, 96, 256, 1056, 1, 4, 25, 625,
174                             800, 0, 8,
175                             PM3VideoControl_ENABLE |
176                             PM3VideoControl_HSYNC_ACTIVE_HIGH
177                             |
178                             PM3VideoControl_VSYNC_ACTIVE_HIGH
179                             | PM3VideoControl_PIXELSIZE_8BIT}}, {
180                 "1024x768-74", {
181         78752, 1024, 768, 32, 128, 304, 1328, 1, 4, 38,
182                             806, 1024, 0, 8,
183                             PM3VideoControl_ENABLE |
184                             PM3VideoControl_HSYNC_ACTIVE_HIGH
185                             |
186                             PM3VideoControl_VSYNC_ACTIVE_HIGH
187                             | PM3VideoControl_PIXELSIZE_8BIT}}, {
188                 "1024x768-74-32", {
189                         78752, 1024, 768, 32, 128, 304, 1328, 1, 4, 38,
190                         806, 1024, 0, 32,
191                         PM3VideoControl_ENABLE |
192                         PM3VideoControl_HSYNC_ACTIVE_HIGH
193                         |
194                         PM3VideoControl_VSYNC_ACTIVE_HIGH
195                         | PM3VideoControl_PIXELSIZE_32BIT}},
196 /* Generated mode : "1600x1024", for the SGI 1600SW flat panel*/
197         {
198                 "SGI1600SW", {
199                         108000, 1600, 1024, 16, 56, 104, 1704, 3, 6, 32,
200                         1056, 1600, 0, 8,
201                         PM3VideoControl_ENABLE|
202                         PM3VideoControl_HSYNC_ACTIVE_LOW|PM3VideoControl_VSYNC_ACTIVE_LOW|
203                         PM3VideoControl_PIXELSIZE_32BIT}}, 
204 /* ##### auto-generated mode, by fbtimings2pm3 */
205 /* Generated mode : "640x480-60" */
206         {
207                 "640x480-60", {
208         25174, 640, 480, 16, 112, 160, 800, 10, 12, 45,
209                             525, 640, 0, 8,
210                             PM3VideoControl_ENABLE |
211                             PM3VideoControl_HSYNC_ACTIVE_LOW
212                             |
213                             PM3VideoControl_VSYNC_ACTIVE_LOW
214                             | PM3VideoControl_PIXELSIZE_8BIT}},
215 /* Generated mode : "640x480-72" */
216         {
217                 "640x480-72", {
218         31199, 640, 480, 24, 64, 192, 832, 9, 12, 40, 520,
219                             640, 0, 8,
220                             PM3VideoControl_ENABLE |
221                             PM3VideoControl_HSYNC_ACTIVE_LOW
222                             |
223                             PM3VideoControl_VSYNC_ACTIVE_LOW
224                             | PM3VideoControl_PIXELSIZE_8BIT}},
225 /* Generated mode : "640x480-75" */
226         {
227                 "640x480-75", {
228         31499, 640, 480, 16, 80, 200, 840, 1, 4, 20, 500,
229                             640, 0, 8,
230                             PM3VideoControl_ENABLE |
231                             PM3VideoControl_HSYNC_ACTIVE_LOW
232                             |
233                             PM3VideoControl_VSYNC_ACTIVE_LOW
234                             | PM3VideoControl_PIXELSIZE_8BIT}},
235 /* Generated mode : "640x480-90" */
236         {
237                 "640x480-90", {
238         39909, 640, 480, 32, 72, 192, 832, 25, 39, 53, 533,
239                             640, 0, 8,
240                             PM3VideoControl_ENABLE |
241                             PM3VideoControl_HSYNC_ACTIVE_LOW
242                             |
243                             PM3VideoControl_VSYNC_ACTIVE_LOW
244                             | PM3VideoControl_PIXELSIZE_8BIT}},
245 /* Generated mode : "640x480-100" */
246         {
247                 "640x480-100", {
248         44899, 640, 480, 32, 160, 208, 848, 22, 34, 51,
249                             531, 640, 0, 8,
250                             PM3VideoControl_ENABLE |
251                             PM3VideoControl_HSYNC_ACTIVE_LOW
252                             |
253                             PM3VideoControl_VSYNC_ACTIVE_LOW
254                             | PM3VideoControl_PIXELSIZE_8BIT}},
255 /* Generated mode : "800x600-48-lace" */
256 /* INTERLACED NOT SUPPORTED
257   {"800x600-48-lace", {35999, 800, 600, 80, 208, 264, 1064, 11, 23, 102, 702, 800, 0, 8, PM3VideoControl_ENABLE|PM3VideoControl_HSYNC_ACTIVE_HIGH|PM3VideoControl_VSYNC_ACTIVE_HIGH|PM3VideoControl_PIXELSIZE_8BIT}}, 
258    INTERLACED NOT SUPPORTED */
259 /* Generated mode : "800x600-56" */
260         {
261                 "800x600-56", {
262         35999, 800, 600, 24, 96, 224, 1024, 1, 3, 25, 625,
263                             800, 0, 8,
264                             PM3VideoControl_ENABLE |
265                             PM3VideoControl_HSYNC_ACTIVE_HIGH
266                             |
267                             PM3VideoControl_VSYNC_ACTIVE_HIGH
268                             | PM3VideoControl_PIXELSIZE_8BIT}},
269 /* Generated mode : "800x600-60" */
270         {
271                 "800x600-60", {
272         40000, 800, 600, 40, 168, 256, 1056, 1, 5, 28, 628,
273                             800, 0, 8,
274                             PM3VideoControl_ENABLE |
275                             PM3VideoControl_HSYNC_ACTIVE_HIGH
276                             |
277                             PM3VideoControl_VSYNC_ACTIVE_HIGH
278                             | PM3VideoControl_PIXELSIZE_8BIT}},
279 /* Generated mode : "800x600-70" */
280         {
281                 "800x600-70", {
282         44899, 800, 600, 24, 168, 208, 1008, 9, 21, 36,
283                             636, 800, 0, 8,
284                             PM3VideoControl_ENABLE |
285                             PM3VideoControl_HSYNC_ACTIVE_HIGH
286                             |
287                             PM3VideoControl_VSYNC_ACTIVE_LOW
288                             | PM3VideoControl_PIXELSIZE_8BIT}},
289 /* Generated mode : "800x600-72" */
290         {
291                 "800x600-72", {
292         50000, 800, 600, 56, 176, 240, 1040, 37, 43, 66,
293                             666, 800, 0, 8,
294                             PM3VideoControl_ENABLE |
295                             PM3VideoControl_HSYNC_ACTIVE_HIGH
296                             |
297                             PM3VideoControl_VSYNC_ACTIVE_HIGH
298                             | PM3VideoControl_PIXELSIZE_8BIT}},
299 /* Generated mode : "800x600-75" */
300         {
301                 "800x600-75", {
302         49497, 800, 600, 16, 96, 256, 1056, 1, 4, 25, 625,
303                             800, 0, 8,
304                             PM3VideoControl_ENABLE |
305                             PM3VideoControl_HSYNC_ACTIVE_HIGH
306                             |
307                             PM3VideoControl_VSYNC_ACTIVE_HIGH
308                             | PM3VideoControl_PIXELSIZE_8BIT}},
309 /* Generated mode : "800x600-90" */
310         {
311                 "800x600-90", {
312         56637, 800, 600, 8, 72, 192, 992, 8, 19, 35, 635,
313                             800, 0, 8,
314                             PM3VideoControl_ENABLE |
315                             PM3VideoControl_HSYNC_ACTIVE_HIGH
316                             |
317                             PM3VideoControl_VSYNC_ACTIVE_HIGH
318                             | PM3VideoControl_PIXELSIZE_8BIT}},
319 /* Generated mode : "800x600-100", from /etc/fb.modes */
320 /* DISABLED, hsstart == 0
321         {
322                 "800x600-100", {
323         67499, 800, 600, 0, 64, 280, 1080, 7, 11, 25, 625,
324                             800, 0, 8,
325                             PM3VideoControl_ENABLE |
326                             PM3VideoControl_HSYNC_ACTIVE_HIGH
327                             |
328                             PM3VideoControl_VSYNC_ACTIVE_HIGH
329                             | PM3VideoControl_PIXELSIZE_8BIT}},
330 */
331 /* Generated mode : "800x600-100", from ??? */
332         {
333                 "800x600-100", {
334                         69650, 800, 600, 64, 128, 288, 1088, 4, 10, 40, 640, 800, 0, 8,
335                         PM3VideoControl_ENABLE|PM3VideoControl_HSYNC_ACTIVE_LOW|
336                         PM3VideoControl_VSYNC_ACTIVE_LOW|PM3VideoControl_PIXELSIZE_8BIT}},
337 /* Generated mode : "1024x768-43-lace" */
338 /* INTERLACED NOT SUPPORTED
339   {"1024x768-43-lace", {44899, 1024, 768, 8, 184, 240, 1264, 1, 9, 49, 817, 1024, 0, 8, PM3VideoControl_ENABLE|PM3VideoControl_HSYNC_ACTIVE_HIGH|PM3VideoControl_VSYNC_ACTIVE_HIGH|PM3VideoControl_PIXELSIZE_8BIT}}, 
340    INTERLACED NOT SUPPORTED */
341 /* Generated mode : "1024x768-60" */
342         {
343                 "1024x768-60", {
344         64998, 1024, 768, 24, 160, 320, 1344, 3, 9, 38,
345                             806, 1024, 0, 8,
346                             PM3VideoControl_ENABLE |
347                             PM3VideoControl_HSYNC_ACTIVE_LOW
348                             |
349                             PM3VideoControl_VSYNC_ACTIVE_LOW
350                             | PM3VideoControl_PIXELSIZE_8BIT}},
351 /* Generated mode : "1024x768-70" */
352         {
353                 "1024x768-70", {
354         74996, 1024, 768, 24, 160, 304, 1328, 3, 9, 38,
355                             806, 1024, 0, 8,
356                             PM3VideoControl_ENABLE |
357                             PM3VideoControl_HSYNC_ACTIVE_LOW
358                             |
359                             PM3VideoControl_VSYNC_ACTIVE_LOW
360                             | PM3VideoControl_PIXELSIZE_8BIT}},
361 /* Generated mode : "1024x768-72" */
362         {
363                 "1024x768-72", {
364         74996, 10224, 768, 24, 160, 264, 10488, 3, 9, 38,
365                             806, 10224, 0, 8,
366                             PM3VideoControl_ENABLE |
367                             PM3VideoControl_HSYNC_ACTIVE_LOW
368                             |
369                             PM3VideoControl_VSYNC_ACTIVE_LOW
370                             | PM3VideoControl_PIXELSIZE_8BIT}},
371 /* Generated mode : "1024x768-75" */
372         {
373                 "1024x768-75", {
374         78746, 1024, 768, 16, 112, 288, 1312, 1, 4, 32,
375                             800, 1024, 0, 8,
376                             PM3VideoControl_ENABLE |
377                             PM3VideoControl_HSYNC_ACTIVE_HIGH
378                             |
379                             PM3VideoControl_VSYNC_ACTIVE_HIGH
380                             | PM3VideoControl_PIXELSIZE_8BIT}},
381 /* Generated mode : "1024x768-90" */
382         {
383                 "1024x768-90", {
384         100000, 1024, 768, 0, 96, 288, 1312, 21, 36, 77,
385                             845, 1024, 0, 8,
386                             PM3VideoControl_ENABLE |
387                             PM3VideoControl_HSYNC_ACTIVE_LOW
388                             |
389                             PM3VideoControl_VSYNC_ACTIVE_LOW
390                             | PM3VideoControl_PIXELSIZE_8BIT}},
391 /* Generated mode : "1024x768-100", from /etc/fb.modes */
392 /* DISABLED, vsstart == 0
393         {
394                 "1024x768-100", {
395         109998, 1024, 768, 0, 88, 368, 1392, 0, 8, 24, 792,
396                             1024, 0, 8,
397                             PM3VideoControl_ENABLE |
398                             PM3VideoControl_HSYNC_ACTIVE_LOW
399                             |
400                             PM3VideoControl_VSYNC_ACTIVE_LOW
401                             | PM3VideoControl_PIXELSIZE_8BIT}},
402 */
403 /* Generated mode : "1024x768-100", from ??? */
404         {
405                 "1024x768-100", {
406                         115500, 1024, 768, 32, 224, 416, 1440, 3, 13, 34, 802, 1024, 0, 8,
407                         PM3VideoControl_ENABLE|PM3VideoControl_HSYNC_ACTIVE_LOW|
408                         PM3VideoControl_VSYNC_ACTIVE_LOW|PM3VideoControl_PIXELSIZE_8BIT}},
409 /* Generated mode : "1152x864-43-lace" */
410 /* INTERLACED NOT SUPPORTED
411   {"1152x864-43-lace", {64998, 1152, 864, 72, 200, 264, 1416, 78, 87, 191, 1055, 1152, 0, 8, PM3VideoControl_ENABLE|PM3VideoControl_HSYNC_ACTIVE_HIGH|PM3VideoControl_VSYNC_ACTIVE_HIGH|PM3VideoControl_PIXELSIZE_8BIT}}, 
412    INTERLACED NOT SUPPORTED */
413 /* Generated mode : "1152x864-47-lace" */
414 /* INTERLACED NOT SUPPORTED
415   {"1152x864-47-lace", {64998, 1152, 864, 88, 216, 296, 1448, 30, 39, 83, 947, 1152, 0, 8, PM3VideoControl_ENABLE|PM3VideoControl_HSYNC_ACTIVE_HIGH|PM3VideoControl_VSYNC_ACTIVE_HIGH|PM3VideoControl_PIXELSIZE_8BIT}}, 
416    INTERLACED NOT SUPPORTED */
417 /* Generated mode : "1152x864-60" */
418         {
419                 "1152x864-60", {
420         80000, 1152, 864, 64, 176, 304, 1456, 6, 11, 52,
421                             916, 1152, 0, 8,
422                             PM3VideoControl_ENABLE |
423                             PM3VideoControl_HSYNC_ACTIVE_HIGH
424                             |
425                             PM3VideoControl_VSYNC_ACTIVE_HIGH
426                             | PM3VideoControl_PIXELSIZE_8BIT}},
427 /* Generated mode : "1152x864-70" */
428         {
429                 "1152x864-70", {
430         100000, 1152, 864, 40, 192, 360, 1512, 13, 24, 81,
431                             945, 1152, 0, 8,
432                             PM3VideoControl_ENABLE |
433                             PM3VideoControl_HSYNC_ACTIVE_HIGH
434                             |
435                             PM3VideoControl_VSYNC_ACTIVE_HIGH
436                             | PM3VideoControl_PIXELSIZE_8BIT}},
437 /* Generated mode : "1152x864-75" */
438         {
439                 "1152x864-75", {
440         109998, 1152, 864, 24, 168, 312, 1464, 45, 53, 138,
441                             1002, 1152, 0, 8,
442                             PM3VideoControl_ENABLE |
443                             PM3VideoControl_HSYNC_ACTIVE_HIGH
444                             |
445                             PM3VideoControl_VSYNC_ACTIVE_HIGH
446                             | PM3VideoControl_PIXELSIZE_8BIT}},
447 /* Generated mode : "1152x864-80" */
448         {
449                 "1152x864-80", {
450         109998, 1152, 864, 16, 128, 288, 1440, 30, 37, 94,
451                             958, 1152, 0, 8,
452                             PM3VideoControl_ENABLE |
453                             PM3VideoControl_HSYNC_ACTIVE_HIGH
454                             |
455                             PM3VideoControl_VSYNC_ACTIVE_HIGH
456                             | PM3VideoControl_PIXELSIZE_8BIT}},
457 /* Generated mode : "1280x1024-43-lace" */
458 /* INTERLACED NOT SUPPORTED
459   {"1280x1024-43-lace", {80000, 1024, 1024, 80, 160, 320, 1344, 50, 60, 125, 1149, 1024, 0, 8, PM3VideoControl_ENABLE|PM3VideoControl_HSYNC_ACTIVE_HIGH|PM3VideoControl_VSYNC_ACTIVE_HIGH|PM3VideoControl_PIXELSIZE_8BIT}}, 
460    INTERLACED NOT SUPPORTED */
461 /* Generated mode : "1280x1024-47-lace" */
462 /* INTERLACED NOT SUPPORTED
463   {"1280x1024-47-lace", {80000, 1280, 1024, 80, 160, 320, 1600, 1, 11, 29, 1053, 1280, 0, 8, PM3VideoControl_ENABLE|PM3VideoControl_HSYNC_ACTIVE_HIGH|PM3VideoControl_VSYNC_ACTIVE_HIGH|PM3VideoControl_PIXELSIZE_8BIT}}, 
464    INTERLACED NOT SUPPORTED */
465 /* Generated mode : "1280x1024-60" */
466         {
467                 "1280x1024-60", {
468         107991, 1280, 1024, 48, 160, 408, 1688, 1, 4, 42,
469                             1066, 1280, 0, 8,
470                             PM3VideoControl_ENABLE |
471                             PM3VideoControl_HSYNC_ACTIVE_HIGH
472                             |
473                             PM3VideoControl_VSYNC_ACTIVE_HIGH
474                             | PM3VideoControl_PIXELSIZE_8BIT}},
475 /* Generated mode : "1280x1024-70" */
476         {
477                 "1280x1024-70", {
478         125992, 1280, 1024, 80, 192, 408, 1688, 1, 6, 42,
479                             1066, 1280, 0, 8,
480                             PM3VideoControl_ENABLE |
481                             PM3VideoControl_HSYNC_ACTIVE_HIGH
482                             |
483                             PM3VideoControl_VSYNC_ACTIVE_HIGH
484                             | PM3VideoControl_PIXELSIZE_8BIT}},
485 /* Generated mode : "1280x1024-74" */
486         {
487                 "1280x1024-74", {
488         134989, 1280, 1024, 32, 176, 432, 1712, 0, 30, 40,
489                             1064, 1280, 0, 8,
490                             PM3VideoControl_ENABLE |
491                             PM3VideoControl_HSYNC_ACTIVE_HIGH
492                             |
493                             PM3VideoControl_VSYNC_ACTIVE_HIGH
494                             | PM3VideoControl_PIXELSIZE_8BIT}},
495 /* Generated mode : "1280x1024-75" */
496         {
497                 "1280x1024-75", {
498         134989, 1280, 1024, 16, 160, 408, 1688, 1, 4, 42,
499                             1066, 1280, 0, 8,
500                             PM3VideoControl_ENABLE |
501                             PM3VideoControl_HSYNC_ACTIVE_HIGH
502                             |
503                             PM3VideoControl_VSYNC_ACTIVE_HIGH
504                             | PM3VideoControl_PIXELSIZE_8BIT}},
505 /* Generated mode : "1600x1200-60" */
506         {
507                 "1600x1200-60", {
508         155981, 1600, 1200, 32, 192, 448, 2048, 10, 18, 70,
509                             1270, 1600, 0, 8,
510                             PM3VideoControl_ENABLE |
511                             PM3VideoControl_HSYNC_ACTIVE_LOW
512                             |
513                             PM3VideoControl_VSYNC_ACTIVE_LOW
514                             | PM3VideoControl_PIXELSIZE_8BIT}},
515 /* Generated mode : "1600x1200-66" */
516         {
517                 "1600x1200-66", {
518         171998, 1600, 1200, 40, 176, 480, 2080, 3, 6, 53,
519                             1253, 1600, 0, 8,
520                             PM3VideoControl_ENABLE |
521                             PM3VideoControl_HSYNC_ACTIVE_LOW
522                             |
523                             PM3VideoControl_VSYNC_ACTIVE_LOW
524                             | PM3VideoControl_PIXELSIZE_8BIT}},
525 /* Generated mode : "1600x1200-76" */
526         {
527                 "1600x1200-76", {
528         197980, 1600, 1200, 40, 176, 480, 2080, 3, 8, 50,
529                             1250, 1600, 0, 8,
530                             PM3VideoControl_ENABLE |
531                             PM3VideoControl_HSYNC_ACTIVE_LOW
532                             |
533                             PM3VideoControl_VSYNC_ACTIVE_LOW
534                             | PM3VideoControl_PIXELSIZE_8BIT}},
535 /* ##### end of auto-generated mode */
536         {
537         "\0",}
538 };
539
540 /* more mandatory stuff (see skeletonfb.c + framebuffer driver HOWTO */
541 static struct pm3fb_info fb_info[PM3_MAX_BOARD];
542 static struct pm3fb_par current_par[PM3_MAX_BOARD];
543 static int current_par_valid[PM3_MAX_BOARD];
544 /* to allow explicit filtering of board */
545 short bus[PM3_MAX_BOARD];
546 short slot[PM3_MAX_BOARD];
547 short func[PM3_MAX_BOARD];
548 short disable[PM3_MAX_BOARD];
549 short noaccel[PM3_MAX_BOARD];
550 char fontn[PM3_MAX_BOARD][PM3_FONTNAME_SIZE];
551 short depth[PM3_MAX_BOARD];
552 short flatpanel[PM3_MAX_BOARD];
553 static struct display disp[PM3_MAX_BOARD];
554 static char g_options[PM3_OPTIONS_SIZE] __initdata = "pm3fb,dummy";
555 short printtimings = 0;
556 short forcesize[PM3_MAX_BOARD];
557
558 /* ********************* */
559 /* ***** prototype ***** */
560 /* ********************* */
561 /* card-specific */
562 static void pm3fb_j2000_setup(struct pm3fb_info *l_fb_info);
563 /* permedia3-specific */
564 static pm3fb_timing_result pm3fb_preserve_memory_timings(struct pm3fb_info *l_fb_info);
565 static pm3fb_timing_result pm3fb_try_memory_timings(struct pm3fb_info *l_fb_info);
566 static void pm3fb_write_memory_timings(struct pm3fb_info *l_fb_info);
567 static unsigned long pm3fb_read_dac_reg(struct pm3fb_info *l_fb_info,
568                                         unsigned long r);
569 static unsigned long pm3fb_CalculateClock(struct pm3fb_info *l_fb_info, unsigned long reqclock, /* In kHz units */
570                                           unsigned long refclock,       /* In kHz units */
571                                           unsigned char *prescale,      /* ClkPreScale */
572                                           unsigned char *feedback,      /* ClkFeedBackScale */
573                                           unsigned char *postscale
574                                           /* ClkPostScale */ );
575 static void pm3fb_clear_memory(struct pm3fb_info *l_fb_info, u32 cc);
576 static void pm3fb_clear_colormap(struct pm3fb_info *l_fb_info, unsigned char r, unsigned char g, unsigned char b);
577 static void pm3fb_common_init(struct pm3fb_info *l_fb_info);
578 static int pm3fb_Shiftbpp(struct pm3fb_info *l_fb_info,
579                           unsigned long depth, int v);
580 static int pm3fb_Unshiftbpp(struct pm3fb_info *l_fb_info,
581                             unsigned long depth, int v);
582 static void pm3fb_mapIO(struct pm3fb_info *l_fb_info);
583 static void pm3fb_unmapIO(struct pm3fb_info *l_fb_info);
584 #if defined(PM3FB_MASTER_DEBUG) && (PM3FB_MASTER_DEBUG >= 2)
585 static void pm3fb_show_cur_mode(struct pm3fb_info *l_fb_info);
586 #endif
587 static void pm3fb_show_cur_timing(struct pm3fb_info *l_fb_info);
588 static void pm3fb_write_mode(struct pm3fb_info *l_fb_info);
589 static void pm3fb_read_mode(struct pm3fb_info *l_fb_info,
590                             struct pm3fb_par *curpar);
591 static unsigned long pm3fb_size_memory(struct pm3fb_info *l_fb_info);
592 /* accelerated permedia3-specific */
593 #ifdef PM3FB_USE_ACCEL
594 static void pm3fb_wait_pm3(struct pm3fb_info *l_fb_info);
595 static void pm3fb_init_engine(struct pm3fb_info *l_fb_info);
596 #ifdef FBCON_HAS_CFB32
597 static void pm3fb_cfb32_clear(struct vc_data *conp,
598                               struct display *p,
599                               int sy, int sx, int height, int width);
600 static void pm3fb_cfb32_clear_margins(struct vc_data *conp,
601                                       struct display *p, int bottom_only);
602 #endif /* FBCON_HAS_CFB32 */
603 #ifdef FBCON_HAS_CFB16
604 static void pm3fb_cfb16_clear(struct vc_data *conp,
605                               struct display *p,
606                               int sy, int sx, int height, int width);
607 static void pm3fb_cfb16_clear_margins(struct vc_data *conp,
608                                       struct display *p, int bottom_only);
609 #endif /* FBCON_HAS_CFB16 */
610 #ifdef FBCON_HAS_CFB8
611 static void pm3fb_cfb8_clear(struct vc_data *conp,
612                              struct display *p,
613                              int sy, int sx, int height, int width);
614 static void pm3fb_cfb8_clear_margins(struct vc_data *conp,
615                                      struct display *p, int bottom_only);
616 #endif /* FBCON_HAS_CFB8 */
617 #if defined(FBCON_HAS_CFB8) || defined(FBCON_HAS_CFB16) || defined(FBCON_HAS_CFB32)
618 static void pm3fb_cfbX_bmove(struct display *p,
619                              int sy, int sx,
620                              int dy, int dx, int height, int width);
621 static void pm3fb_cfbX_putc(struct vc_data *conp, struct display *p,
622                             int c, int yy, int xx);
623 static void pm3fb_cfbX_putcs(struct vc_data *conp, struct display *p,
624                              const unsigned short *s, int count, int yy,
625                              int xx);
626 static void pm3fb_cfbX_revc(struct display *p, int xx, int yy);
627 #endif /* FBCON_HAS_CFB8 || FBCON_HAS_CFB16 || FBCON_HAS_CFB32 */
628 #endif /* PM3FB_USE_ACCEL */
629 /* pre-init */
630 static void pm3fb_mode_setup(char *mode, unsigned long board_num);
631 static void pm3fb_pciid_setup(char *pciid, unsigned long board_num);
632 static char *pm3fb_boardnum_setup(char *options, unsigned long *bn);
633 static void pm3fb_real_setup(char *options);
634 /* fbdev */
635 static int pm3fb_encode_fix(struct fb_fix_screeninfo *fix,
636                             const void *par, struct fb_info_gen *info);
637 static int pm3fb_decode_var(const struct fb_var_screeninfo *var,
638                             void *par, struct fb_info_gen *info);
639 static void pm3fb_encode_depth(struct fb_var_screeninfo *var, long d);
640 static int pm3fb_encode_var(struct fb_var_screeninfo *var,
641                             const void *par, struct fb_info_gen *info);
642 static void pm3fb_get_par(void *par, struct fb_info_gen *info);
643 static void pm3fb_set_par(const void *par, struct fb_info_gen *info);
644 static void pm3fb_set_color(struct pm3fb_info *l_fb_info,
645                             unsigned char regno, unsigned char r,
646                             unsigned char g, unsigned char b);
647 static int pm3fb_getcolreg(unsigned regno, unsigned *red, unsigned *green,
648                            unsigned *blue, unsigned *transp,
649                            struct fb_info *info);
650 static int pm3fb_setcolreg(unsigned regno, unsigned red, unsigned green,
651                            unsigned blue, unsigned transp,
652                            struct fb_info *info);
653 static int pm3fb_blank(int blank_mode, struct fb_info_gen *info);
654 static void pm3fb_set_disp(const void *par, struct display *disp,
655                            struct fb_info_gen *info);
656 static void pm3fb_detect(void);
657 static int pm3fb_pan_display(const struct fb_var_screeninfo *var,
658                              struct fb_info_gen *info);
659 static int pm3fb_ioctl(struct inode *inode, struct file *file,
660                        u_int cmd, u_long arg, int con,
661                        struct fb_info *info);
662
663
664 /* the struct that hold them together */
665 struct fbgen_hwswitch pm3fb_switch = {
666         pm3fb_detect, pm3fb_encode_fix, pm3fb_decode_var, pm3fb_encode_var,
667         pm3fb_get_par, pm3fb_set_par, pm3fb_getcolreg, 
668         pm3fb_pan_display, pm3fb_blank, pm3fb_set_disp
669 };
670
671 static struct fb_ops pm3fb_ops = {
672         .owner =        THIS_MODULE,
673         .fb_get_fix =   fbgen_get_fix,
674         .fb_get_var =   fbgen_get_var,
675         .fb_set_var =   fbgen_set_var,
676         .fb_get_cmap =  fbgen_get_cmap,
677         .fb_set_cmap =  fbgen_set_cmap,
678         .fb_setcolreg = pm3fb_setcolreg,
679         .fb_pan_display =fbgen_pan_display,
680         .fb_blank =     fbgen_blank,
681         .fb_ioctl =     pm3fb_ioctl,
682 };
683
684 #ifdef PM3FB_USE_ACCEL
685 #ifdef FBCON_HAS_CFB32
686 static struct display_switch pm3fb_cfb32 = {
687         fbcon_cfb32_setup, pm3fb_cfbX_bmove, pm3fb_cfb32_clear,
688         pm3fb_cfbX_putc, pm3fb_cfbX_putcs, pm3fb_cfbX_revc,
689         NULL /* cursor() */ , NULL /* set_font() */ ,
690         pm3fb_cfb32_clear_margins,
691         FONTWIDTHRANGE(1, 16)   /* true only if accelerated... */
692 };
693 #endif /* FBCON_HAS_CFB32 */
694 #ifdef FBCON_HAS_CFB16
695 static struct display_switch pm3fb_cfb16 = {
696         fbcon_cfb16_setup, pm3fb_cfbX_bmove, pm3fb_cfb16_clear,
697         pm3fb_cfbX_putc, pm3fb_cfbX_putcs, pm3fb_cfbX_revc,
698         NULL /* cursor() */ , NULL /* set_font() */ ,
699         pm3fb_cfb16_clear_margins,
700         FONTWIDTHRANGE(1, 16)   /* true only if accelerated... */
701 };
702 #endif /* FBCON_HAS_CFB16 */
703 #ifdef FBCON_HAS_CFB8
704 static struct display_switch pm3fb_cfb8 = {
705         fbcon_cfb8_setup, pm3fb_cfbX_bmove, pm3fb_cfb8_clear,
706         pm3fb_cfbX_putc, pm3fb_cfbX_putcs, pm3fb_cfbX_revc,
707         NULL /* cursor() */ , NULL /* set_font() */ ,
708         pm3fb_cfb8_clear_margins,
709         FONTWIDTHRANGE(1, 16)   /* true only if accelerated... */
710 };
711 #endif /* FBCON_HAS_CFB8 */
712 #endif /* PM3FB_USE_ACCEL */
713
714 /* ****************************** */
715 /* ***** card-specific data ***** */
716 /* ****************************** */
717 struct pm3fb_card_timings {
718         unsigned long memsize; /* 0 for last value (i.e. default) */
719         struct pm3fb_timings memt;
720 };
721
722 static struct pm3fb_card_timings t_FormacProFormance3[] = {
723         { 16, { 0x02e311b8, 0x06100205, 0x08000002, 0x00000079, 0x00000000} },
724         { 0, { 0x02e311b8, 0x06100205, 0x08000002, 0x00000079, 0x00000000} } /* from 16 MB PF3 */
725 };
726
727 static struct pm3fb_card_timings t_AppianJeronimo2000[] = {
728         { 32, { 0x02e311B8, 0x07424905, 0x0c000003, 0x00000061, 0x00000000} },
729         { 0, { 0x02e311B8, 0x07424905, 0x0c000003, 0x00000061, 0x00000000} } /* from 32MB J2000 */
730 };
731
732 static struct pm3fb_card_timings t_3DLabsOxygenVX1[] = {
733         { 32, { 0x30e311b8, 0x08501204, 0x08000002, 0x0000006b, 0x00000000} },
734         { 0, { 0x30e311b8, 0x08501204, 0x08000002, 0x0000006b, 0x00000000} } /* from 32MB VX1 */
735 };
736
737 static struct {
738                 char cardname[32]; /* recognized card name */
739                 u16 subvendor; /* subvendor of the card */
740                 u16 subdevice; /* subdevice of the card */
741                 u8  func; /* function of the card to which the extra init apply */
742                 void (*specific_setup)(struct pm3fb_info *l_fb_info); /* card/func specific setup, done before _any_ FB access */
743         struct pm3fb_card_timings *c_memt; /* defauls timings for the boards */
744 } cardbase[] = {
745         { "Unknown Permedia3 board", 0xFFFF, 0xFFFF, 0xFF, NULL, NULL },
746         { "Appian Jeronimo 2000 head 1", 0x1097, 0x3d32, 1, NULL,
747           t_AppianJeronimo2000
748         },
749         { "Appian Jeronimo 2000 head 2", 0x1097, 0x3d32, 2, pm3fb_j2000_setup,
750           t_AppianJeronimo2000
751         },
752         { "Formac ProFormance 3", PCI_VENDOR_ID_3DLABS, 0x000a, 0, NULL, /* Formac use 3DLabs ID ?!? */
753           t_FormacProFormance3
754         },
755         { "3DLabs Permedia3 Create!", PCI_VENDOR_ID_3DLABS, 0x0127, 0, NULL, NULL },
756         { "3DLabs Oxygen VX1 PCI", PCI_VENDOR_ID_3DLABS, 0x0121, 0, NULL,
757           t_3DLabsOxygenVX1
758         },
759         { "3DLabs Oxygen VX1 AGP", PCI_VENDOR_ID_3DLABS, 0x0125, 0, NULL, NULL },
760         { "3DLabs Oxygen VX1-16 AGP", PCI_VENDOR_ID_3DLABS, 0x0140, 0, NULL, NULL },
761         { "3DLabs Oxygen VX1-1600SW PCI", PCI_VENDOR_ID_3DLABS, 0x0800, 0, NULL, NULL },
762         { "\0", 0x0, 0x0, 0, NULL, NULL }
763 };
764
765 /* ********************************** */
766 /* ***** card-specific function ***** */
767 /* ********************************** */
768 static void pm3fb_j2000_setup(struct pm3fb_info *l_fb_info)
769 {       /* the appian j2000 require more initialization of the second head */
770         /* l_fb_info must point to the _second_ head of the J2000 */
771         
772         DTRACE;
773
774         l_fb_info->memt = t_AppianJeronimo2000[0].memt; /* 32 MB, first and only j2000 ? */
775         
776         pm3fb_write_memory_timings(l_fb_info);
777 }
778
779 /* *************************************** */
780 /* ***** permedia3-specific function ***** */
781 /* *************************************** */
782 static pm3fb_timing_result pm3fb_preserve_memory_timings(struct pm3fb_info *l_fb_info)
783 {
784         l_fb_info->memt.caps = PM3_READ_REG(PM3LocalMemCaps);
785         l_fb_info->memt.timings = PM3_READ_REG(PM3LocalMemTimings);
786         l_fb_info->memt.control = PM3_READ_REG(PM3LocalMemControl);
787         l_fb_info->memt.refresh = PM3_READ_REG(PM3LocalMemRefresh);
788         l_fb_info->memt.powerdown = PM3_READ_REG(PM3LocalMemPowerDown);
789
790         if ((l_fb_info->memt.caps == PM3FB_UNKNOWN_TIMING_VALUE) ||
791             (l_fb_info->memt.timings == PM3FB_UNKNOWN_TIMING_VALUE) ||
792             (l_fb_info->memt.control == PM3FB_UNKNOWN_TIMING_VALUE) ||
793             (l_fb_info->memt.refresh == PM3FB_UNKNOWN_TIMING_VALUE) ||
794             (l_fb_info->memt.powerdown == PM3FB_UNKNOWN_TIMING_VALUE))
795         {
796                 printk(KERN_ERR "pm3fb: invalid memory timings in permedia3 board #%ld\n", l_fb_info->board_num);
797                 return(pm3fb_try_memory_timings(l_fb_info));
798         }
799         return(pm3fb_timing_ok);
800 }
801
802 static pm3fb_timing_result pm3fb_try_memory_timings(struct pm3fb_info *l_fb_info)
803 {
804         if (cardbase[l_fb_info->board_type].c_memt)
805         {
806                 int i = 0, done = 0;
807                 while (!done)
808                 {
809                         if ((cardbase[l_fb_info->board_type].c_memt[i].memsize == l_fb_info->fb_size)
810                             || !(cardbase[l_fb_info->board_type].c_memt[i].memsize))
811                         { /* will use the 0-sized timings by default */
812                                 done = 1;
813                                 l_fb_info->memt = cardbase[l_fb_info->board_type].c_memt[i].memt;
814                                 printk(KERN_WARNING  "pm3fb: trying to use predefined memory timings for permedia3 board #%ld (%s, %ld MB)\n",
815                                        l_fb_info->board_num,
816                                        cardbase[l_fb_info->board_type].cardname,
817                                        cardbase[l_fb_info->board_type].c_memt[i].memsize);
818                                 pm3fb_write_memory_timings(l_fb_info);
819                                 return(pm3fb_timing_retry);
820                         }
821                         i++;
822                 }
823         } else
824                 return(pm3fb_timing_problem);
825         return(pm3fb_timing_ok);
826 }
827
828 static void pm3fb_write_memory_timings(struct pm3fb_info *l_fb_info)
829 {
830         unsigned char m, n, p;
831         unsigned long clockused;
832         
833         PM3_SLOW_WRITE_REG(PM3LocalMemCaps, l_fb_info->memt.caps);
834         PM3_SLOW_WRITE_REG(PM3LocalMemTimings, l_fb_info->memt.timings);
835         PM3_SLOW_WRITE_REG(PM3LocalMemControl, l_fb_info->memt.control);
836         PM3_SLOW_WRITE_REG(PM3LocalMemRefresh, l_fb_info->memt.refresh);
837         PM3_SLOW_WRITE_REG(PM3LocalMemPowerDown, l_fb_info->memt.powerdown);
838
839         clockused =
840             pm3fb_CalculateClock(l_fb_info, 2 * 105000, PM3_REF_CLOCK, &m,
841                                  &n, &p);
842
843         PM3_WRITE_DAC_REG(PM3RD_KClkPreScale, m);
844         PM3_WRITE_DAC_REG(PM3RD_KClkFeedbackScale, n);
845         PM3_WRITE_DAC_REG(PM3RD_KClkPostScale, p);
846         PM3_WRITE_DAC_REG(PM3RD_KClkControl,
847                           PM3RD_KClkControl_STATE_RUN |
848                           PM3RD_KClkControl_SOURCE_PLL |
849                           PM3RD_KClkControl_ENABLE);
850         PM3_WRITE_DAC_REG(PM3RD_MClkControl,
851                           PM3RD_MClkControl_STATE_RUN |
852                           PM3RD_MClkControl_SOURCE_KCLK |
853                           PM3RD_MClkControl_ENABLE);
854         PM3_WRITE_DAC_REG(PM3RD_SClkControl,
855                           PM3RD_SClkControl_STATE_RUN |
856                           PM3RD_SClkControl_SOURCE_PCLK |
857                           PM3RD_SClkControl_ENABLE);
858 }
859
860 static unsigned long pm3fb_read_dac_reg(struct pm3fb_info *l_fb_info,
861                                         unsigned long r)
862 {
863         DASSERT((l_fb_info->vIOBase != (unsigned char *) (-1)),
864                 "l_fb_info->vIOBase mapped in read dac reg\n");
865         PM3_SET_INDEX(r);
866         mb();
867         return (PM3_READ_REG(PM3RD_IndexedData));
868 }
869
870 /* Calculating various clock parameter */
871 static unsigned long pm3fb_CalculateClock(struct pm3fb_info *l_fb_info, unsigned long reqclock, /* In kHz units */
872                                           unsigned long refclock,       /* In kHz units */
873                                           unsigned char *prescale,      /* ClkPreScale */
874                                           unsigned char *feedback,      /* ClkFeedBackScale */
875                                           unsigned char *postscale
876                                           /* ClkPostScale */ )
877 {
878         int f, pre, post;
879         unsigned long freq;
880         long freqerr = 1000;
881         unsigned long actualclock = 0;
882
883         DTRACE;
884
885         for (f = 1; f < 256; f++) {
886                 for (pre = 1; pre < 256; pre++) {
887                         for (post = 0; post < 5; post++) {
888                                 freq =
889                                     ((2 * refclock * f) /
890                                      (pre * (1 << post)));
891                                 if ((reqclock > freq - freqerr)
892                                     && (reqclock < freq + freqerr)) {
893                                         freqerr =
894                                             (reqclock >
895                                              freq) ? reqclock -
896                                             freq : freq - reqclock;
897                                         *feedback = f;
898                                         *prescale = pre;
899                                         *postscale = post;
900                                         actualclock = freq;
901                                 }
902                         }
903                 }
904         }
905
906         return (actualclock);
907 }
908
909 static int pm3fb_Shiftbpp(struct pm3fb_info *l_fb_info,
910                           unsigned long depth, int v)
911 {
912         DTRACE;
913         
914         switch (depth) {
915         case 8:
916                 return (v >> 4);
917         case 12:
918         case 15:
919         case 16:
920                 return (v >> 3);
921         case 32:
922                 return (v >> 2);
923         }
924         DPRINTK(1, "Unsupported depth %ld\n", depth);
925         return (0);
926 }
927
928 static int pm3fb_Unshiftbpp(struct pm3fb_info *l_fb_info,
929                             unsigned long depth, int v)
930 {
931         DTRACE;
932
933         switch (depth) {
934         case 8:
935                 return (v << 4);
936         case 12:        
937         case 15:
938         case 16:
939                 return (v << 3);
940         case 32:
941                 return (v << 2);
942         }
943         DPRINTK(1, "Unsupported depth %ld\n", depth);
944         return (0);
945 }
946
947 static void pm3fb_mapIO(struct pm3fb_info *l_fb_info)
948 {
949         DTRACE;
950
951         l_fb_info->vIOBase =
952             ioremap((unsigned long) l_fb_info->pIOBase, PM3_REGS_SIZE);
953         l_fb_info->v_fb =
954             ioremap((unsigned long) l_fb_info->p_fb, l_fb_info->fb_size);
955         DPRINTK(2, "IO mapping : IOBase %lx / %lx, fb %lx / %lx\n",
956                 (unsigned long) l_fb_info->pIOBase,
957                 (unsigned long) l_fb_info->vIOBase,
958                 (unsigned long) l_fb_info->p_fb,
959                 (unsigned long) l_fb_info->v_fb);
960 }
961
962 static void pm3fb_unmapIO(struct pm3fb_info *l_fb_info)
963 {
964         DTRACE;
965
966         iounmap(l_fb_info->vIOBase);
967         iounmap(l_fb_info->v_fb);
968         l_fb_info->vIOBase = (unsigned char *) -1;
969         l_fb_info->v_fb = (unsigned char *) -1;
970 }
971
972 #if defined(PM3FB_MASTER_DEBUG) && (PM3FB_MASTER_DEBUG >= 2)
973 static void pm3fb_show_cur_mode(struct pm3fb_info *l_fb_info)
974 {
975         DPRINTK(2, "PM3Aperture0: 0x%08x\n", PM3_READ_REG(PM3Aperture0));
976         DPRINTK(2, "PM3Aperture1: 0x%08x\n", PM3_READ_REG(PM3Aperture1));
977         DPRINTK(2, "PM3ByAperture1Mode: 0x%08x\n",
978                 PM3_READ_REG(PM3ByAperture1Mode));
979         DPRINTK(2, "PM3ByAperture2Mode: 0x%08x\n",
980                 PM3_READ_REG(PM3ByAperture2Mode));
981         DPRINTK(2, "PM3ChipConfig: 0x%08x\n", PM3_READ_REG(PM3ChipConfig));
982         DPRINTK(2, "PM3FIFODis: 0x%08x\n", PM3_READ_REG(PM3FIFODis));
983         DPRINTK(2, "PM3HTotal: 0x%08x\n", PM3_READ_REG(PM3HTotal));
984         DPRINTK(2, "PM3HbEnd: 0x%08x\n", PM3_READ_REG(PM3HbEnd));
985         DPRINTK(2, "PM3HgEnd: 0x%08x\n", PM3_READ_REG(PM3HgEnd));
986         DPRINTK(2, "PM3HsEnd: 0x%08x\n", PM3_READ_REG(PM3HsEnd));
987         DPRINTK(2, "PM3HsStart: 0x%08x\n", PM3_READ_REG(PM3HsStart));
988         DPRINTK(2, "PM3MemBypassWriteMask: 0x%08x\n",
989                 PM3_READ_REG(PM3MemBypassWriteMask));
990         DPRINTK(2, "PM3RD_IndexControl: 0x%08x\n",
991                 PM3_READ_REG(PM3RD_IndexControl));
992         DPRINTK(2, "PM3ScreenBase: 0x%08x\n", PM3_READ_REG(PM3ScreenBase));
993         DPRINTK(2, "PM3ScreenStride: 0x%08x\n",
994                 PM3_READ_REG(PM3ScreenStride));
995         DPRINTK(2, "PM3VClkCtl: 0x%08x\n", PM3_READ_REG(PM3VClkCtl));
996         DPRINTK(2, "PM3VTotal: 0x%08x\n", PM3_READ_REG(PM3VTotal));
997         DPRINTK(2, "PM3VbEnd: 0x%08x\n", PM3_READ_REG(PM3VbEnd));
998         DPRINTK(2, "PM3VideoControl: 0x%08x\n",
999                 PM3_READ_REG(PM3VideoControl));
1000         DPRINTK(2, "PM3VsEnd: 0x%08x\n", PM3_READ_REG(PM3VsEnd));
1001         DPRINTK(2, "PM3VsStart: 0x%08x\n", PM3_READ_REG(PM3VsStart));
1002
1003         DPRINTK(2, "PM3RD_ColorFormat: %ld\n",
1004                 PM3_READ_DAC_REG(PM3RD_ColorFormat));
1005         DPRINTK(2, "PM3RD_DACControl: %ld\n",
1006                 PM3_READ_DAC_REG(PM3RD_DACControl));
1007         DPRINTK(2, "PM3RD_DClk0FeedbackScale: %ld\n",
1008                 PM3_READ_DAC_REG(PM3RD_DClk0FeedbackScale));
1009         DPRINTK(2, "PM3RD_DClk0PostScale: %ld\n",
1010                 PM3_READ_DAC_REG(PM3RD_DClk0PostScale));
1011         DPRINTK(2, "PM3RD_DClk0PreScale: %ld\n",
1012                 PM3_READ_DAC_REG(PM3RD_DClk0PreScale));
1013         DPRINTK(2, "[not set] PM3RD_IndexControl: %ld\n",
1014                 PM3_READ_DAC_REG(PM3RD_IndexControl));
1015         DPRINTK(2, "PM3RD_MiscControl: %ld\n",
1016                 PM3_READ_DAC_REG(PM3RD_MiscControl));
1017         DPRINTK(2, "PM3RD_PixelSize: %ld\n",
1018                 PM3_READ_DAC_REG(PM3RD_PixelSize));
1019         DPRINTK(2, "PM3RD_SyncControl: %ld\n",
1020                 PM3_READ_DAC_REG(PM3RD_SyncControl));
1021 }
1022
1023 #endif /* defined(PM3FB_MASTER_DEBUG) && (PM3FB_MASTER_DEBUG >= 2) */
1024 static void pm3fb_show_cur_timing(struct pm3fb_info *l_fb_info)
1025 {
1026         u16 subvendor, subdevice;
1027
1028         if ((!pci_read_config_word
1029              (l_fb_info->dev, PCI_SUBSYSTEM_VENDOR_ID, &subvendor))
1030             &&
1031             (!pci_read_config_word
1032              (l_fb_info->dev, PCI_SUBSYSTEM_ID, &subdevice))) {
1033                 /* well, nothing... */
1034         } else {
1035                 subvendor = subdevice = (u16)-1;
1036         }
1037
1038         printk(KERN_INFO "pm3fb: memory timings for board #%ld (subvendor: 0x%hx, subdevice: 0x%hx)\n", l_fb_info->board_num, subvendor, subdevice);
1039         printk(KERN_INFO " PM3LocalMemCaps: 0x%08x\n",
1040                PM3_READ_REG(PM3LocalMemCaps));
1041         printk(KERN_INFO " PM3LocalMemTimings: 0x%08x\n",
1042                PM3_READ_REG(PM3LocalMemTimings));
1043         printk(KERN_INFO " PM3LocalMemControl: 0x%08x\n",
1044                PM3_READ_REG(PM3LocalMemControl));
1045         printk(KERN_INFO " PM3LocalMemRefresh: 0x%08x\n",
1046                PM3_READ_REG(PM3LocalMemRefresh));
1047         printk(KERN_INFO " PM3LocalMemPowerDown: 0x%08x\n",
1048                PM3_READ_REG(PM3LocalMemPowerDown));
1049 }
1050
1051 /* write the mode to registers */
1052 static void pm3fb_write_mode(struct pm3fb_info *l_fb_info)
1053 {
1054         char tempsync = 0x00, tempmisc = 0x00;
1055         DTRACE;
1056
1057         PM3_SLOW_WRITE_REG(PM3MemBypassWriteMask, 0xffffffff);
1058         PM3_SLOW_WRITE_REG(PM3Aperture0, 0x00000000);
1059         PM3_SLOW_WRITE_REG(PM3Aperture1, 0x00000000);
1060         PM3_SLOW_WRITE_REG(PM3FIFODis, 0x00000007);
1061
1062         PM3_SLOW_WRITE_REG(PM3HTotal,
1063                            pm3fb_Shiftbpp(l_fb_info,
1064                                           l_fb_info->current_par->depth,
1065                                           l_fb_info->current_par->htotal -
1066                                           1));
1067         PM3_SLOW_WRITE_REG(PM3HsEnd,
1068                            pm3fb_Shiftbpp(l_fb_info,
1069                                           l_fb_info->current_par->depth,
1070                                           l_fb_info->current_par->hsend));
1071         PM3_SLOW_WRITE_REG(PM3HsStart,
1072                            pm3fb_Shiftbpp(l_fb_info,
1073                                           l_fb_info->current_par->depth,
1074                                           l_fb_info->current_par->
1075                                           hsstart));
1076         PM3_SLOW_WRITE_REG(PM3HbEnd,
1077                            pm3fb_Shiftbpp(l_fb_info,
1078                                           l_fb_info->current_par->depth,
1079                                           l_fb_info->current_par->hbend));
1080         PM3_SLOW_WRITE_REG(PM3HgEnd,
1081                            pm3fb_Shiftbpp(l_fb_info,
1082                                           l_fb_info->current_par->depth,
1083                                           l_fb_info->current_par->hbend));
1084         PM3_SLOW_WRITE_REG(PM3ScreenStride,
1085                            pm3fb_Shiftbpp(l_fb_info,
1086                                           l_fb_info->current_par->depth,
1087                                           l_fb_info->current_par->stride));
1088         PM3_SLOW_WRITE_REG(PM3VTotal, l_fb_info->current_par->vtotal - 1);
1089         PM3_SLOW_WRITE_REG(PM3VsEnd, l_fb_info->current_par->vsend - 1);
1090         PM3_SLOW_WRITE_REG(PM3VsStart,
1091                            l_fb_info->current_par->vsstart - 1);
1092         PM3_SLOW_WRITE_REG(PM3VbEnd, l_fb_info->current_par->vbend);
1093
1094         switch (l_fb_info->current_par->depth) {
1095         case 8:
1096                 PM3_SLOW_WRITE_REG(PM3ByAperture1Mode,
1097                                    PM3ByApertureMode_PIXELSIZE_8BIT);
1098                 PM3_SLOW_WRITE_REG(PM3ByAperture2Mode,
1099                                    PM3ByApertureMode_PIXELSIZE_8BIT);
1100                 break;
1101
1102         case 12:
1103         case 15:
1104         case 16:
1105 #ifndef __BIG_ENDIAN
1106                 PM3_SLOW_WRITE_REG(PM3ByAperture1Mode,
1107                                    PM3ByApertureMode_PIXELSIZE_16BIT);
1108                 PM3_SLOW_WRITE_REG(PM3ByAperture2Mode,
1109                                    PM3ByApertureMode_PIXELSIZE_16BIT);
1110 #else
1111                 PM3_SLOW_WRITE_REG(PM3ByAperture1Mode,
1112                                    PM3ByApertureMode_PIXELSIZE_16BIT |
1113                                    PM3ByApertureMode_BYTESWAP_BADC);
1114                 PM3_SLOW_WRITE_REG(PM3ByAperture2Mode,
1115                                    PM3ByApertureMode_PIXELSIZE_16BIT |
1116                                    PM3ByApertureMode_BYTESWAP_BADC);
1117 #endif /* ! __BIG_ENDIAN */
1118                 break;
1119
1120         case 32:
1121 #ifndef __BIG_ENDIAN
1122                 PM3_SLOW_WRITE_REG(PM3ByAperture1Mode,
1123                                    PM3ByApertureMode_PIXELSIZE_32BIT);
1124                 PM3_SLOW_WRITE_REG(PM3ByAperture2Mode,
1125                                    PM3ByApertureMode_PIXELSIZE_32BIT);
1126 #else
1127                 PM3_SLOW_WRITE_REG(PM3ByAperture1Mode,
1128                                    PM3ByApertureMode_PIXELSIZE_32BIT |
1129                                    PM3ByApertureMode_BYTESWAP_DCBA);
1130                 PM3_SLOW_WRITE_REG(PM3ByAperture2Mode,
1131                                    PM3ByApertureMode_PIXELSIZE_32BIT |
1132                                    PM3ByApertureMode_BYTESWAP_DCBA);
1133 #endif /* ! __BIG_ENDIAN */
1134                 break;
1135
1136         default:
1137                 DPRINTK(1, "Unsupported depth %d\n",
1138                         l_fb_info->current_par->depth);
1139                 break;
1140         }
1141
1142         /*
1143          * Oxygen VX1 - it appears that setting PM3VideoControl and
1144          * then PM3RD_SyncControl to the same SYNC settings undoes
1145          * any net change - they seem to xor together.  Only set the
1146          * sync options in PM3RD_SyncControl.  --rmk
1147          */
1148         {
1149                 unsigned int video = l_fb_info->current_par->video;
1150
1151                 video &= ~(PM3VideoControl_HSYNC_MASK |
1152                            PM3VideoControl_VSYNC_MASK);
1153                 video |= PM3VideoControl_HSYNC_ACTIVE_HIGH |
1154                          PM3VideoControl_VSYNC_ACTIVE_HIGH;
1155                 PM3_SLOW_WRITE_REG(PM3VideoControl, video);
1156         }
1157         PM3_SLOW_WRITE_REG(PM3VClkCtl,
1158                            (PM3_READ_REG(PM3VClkCtl) & 0xFFFFFFFC));
1159         PM3_SLOW_WRITE_REG(PM3ScreenBase, l_fb_info->current_par->base);
1160         PM3_SLOW_WRITE_REG(PM3ChipConfig,
1161                            (PM3_READ_REG(PM3ChipConfig) & 0xFFFFFFFD));
1162
1163         {
1164                 unsigned char m;        /* ClkPreScale */
1165                 unsigned char n;        /* ClkFeedBackScale */
1166                 unsigned char p;        /* ClkPostScale */
1167                 (void)pm3fb_CalculateClock(l_fb_info, l_fb_info->current_par->pixclock, PM3_REF_CLOCK, &m, &n, &p);
1168
1169                 DPRINTK(2,
1170                         "Pixclock: %d, Pre: %d, Feedback: %d, Post: %d\n",
1171                         l_fb_info->current_par->pixclock, (int) m, (int) n,
1172                         (int) p);
1173
1174                 PM3_WRITE_DAC_REG(PM3RD_DClk0PreScale, m);
1175                 PM3_WRITE_DAC_REG(PM3RD_DClk0FeedbackScale, n);
1176                 PM3_WRITE_DAC_REG(PM3RD_DClk0PostScale, p);
1177         }
1178         /*
1179            PM3_WRITE_DAC_REG(PM3RD_IndexControl, 0x00);
1180          */
1181         /*
1182            PM3_SLOW_WRITE_REG(PM3RD_IndexControl, 0x00);
1183          */
1184         if ((l_fb_info->current_par->video & PM3VideoControl_HSYNC_MASK) ==
1185             PM3VideoControl_HSYNC_ACTIVE_HIGH)
1186                 tempsync |= PM3RD_SyncControl_HSYNC_ACTIVE_HIGH;
1187         if ((l_fb_info->current_par->video & PM3VideoControl_VSYNC_MASK) ==
1188             PM3VideoControl_VSYNC_ACTIVE_HIGH)
1189                 tempsync |= PM3RD_SyncControl_VSYNC_ACTIVE_HIGH;
1190         
1191         PM3_WRITE_DAC_REG(PM3RD_SyncControl, tempsync);
1192         DPRINTK(2, "PM3RD_SyncControl: %d\n", tempsync);
1193         
1194         if (flatpanel[l_fb_info->board_num])
1195         {
1196                 PM3_WRITE_DAC_REG(PM3RD_DACControl, PM3RD_DACControl_BLANK_PEDESTAL_ENABLE);
1197                 PM3_WAIT(2);
1198                 PM3_WRITE_REG(PM3VSConfiguration, 0x06);
1199                 PM3_WRITE_REG(0x5a00, 1 << 14); /* black magic... */
1200                 tempmisc = PM3RD_MiscControl_VSB_OUTPUT_ENABLE;
1201         }
1202         else
1203                 PM3_WRITE_DAC_REG(PM3RD_DACControl, 0x00);
1204
1205         switch (l_fb_info->current_par->depth) {
1206         case 8:
1207                 PM3_WRITE_DAC_REG(PM3RD_PixelSize,
1208                                   PM3RD_PixelSize_8_BIT_PIXELS);
1209                 PM3_WRITE_DAC_REG(PM3RD_ColorFormat,
1210                                   PM3RD_ColorFormat_CI8_COLOR |
1211                                   PM3RD_ColorFormat_COLOR_ORDER_BLUE_LOW);
1212                 tempmisc |= PM3RD_MiscControl_HIGHCOLOR_RES_ENABLE;
1213                 break;
1214         case 12:
1215                 PM3_WRITE_DAC_REG(PM3RD_PixelSize,
1216                                   PM3RD_PixelSize_16_BIT_PIXELS);
1217                 PM3_WRITE_DAC_REG(PM3RD_ColorFormat,
1218                                   PM3RD_ColorFormat_4444_COLOR |
1219                                   PM3RD_ColorFormat_COLOR_ORDER_BLUE_LOW |
1220                                   PM3RD_ColorFormat_LINEAR_COLOR_EXT_ENABLE);
1221                 tempmisc |= PM3RD_MiscControl_DIRECTCOLOR_ENABLE |
1222                         PM3RD_MiscControl_HIGHCOLOR_RES_ENABLE;
1223                 break;          
1224         case 15:
1225                 PM3_WRITE_DAC_REG(PM3RD_PixelSize,
1226                                   PM3RD_PixelSize_16_BIT_PIXELS);
1227                 PM3_WRITE_DAC_REG(PM3RD_ColorFormat,
1228                                   PM3RD_ColorFormat_5551_FRONT_COLOR |
1229                                   PM3RD_ColorFormat_COLOR_ORDER_BLUE_LOW |
1230                                   PM3RD_ColorFormat_LINEAR_COLOR_EXT_ENABLE);
1231                 tempmisc |= PM3RD_MiscControl_DIRECTCOLOR_ENABLE |
1232                         PM3RD_MiscControl_HIGHCOLOR_RES_ENABLE;
1233                 break;          
1234         case 16:
1235                 PM3_WRITE_DAC_REG(PM3RD_PixelSize,
1236                                   PM3RD_PixelSize_16_BIT_PIXELS);
1237                 PM3_WRITE_DAC_REG(PM3RD_ColorFormat,
1238                                   PM3RD_ColorFormat_565_FRONT_COLOR |
1239                                   PM3RD_ColorFormat_COLOR_ORDER_BLUE_LOW |
1240                                   PM3RD_ColorFormat_LINEAR_COLOR_EXT_ENABLE);
1241                 tempmisc |= PM3RD_MiscControl_DIRECTCOLOR_ENABLE |
1242                         PM3RD_MiscControl_HIGHCOLOR_RES_ENABLE;
1243                 break;
1244         case 32:
1245                 PM3_WRITE_DAC_REG(PM3RD_PixelSize,
1246                                   PM3RD_PixelSize_32_BIT_PIXELS);
1247                 PM3_WRITE_DAC_REG(PM3RD_ColorFormat,
1248                                   PM3RD_ColorFormat_8888_COLOR |
1249                                   PM3RD_ColorFormat_COLOR_ORDER_BLUE_LOW);
1250                 tempmisc |= PM3RD_MiscControl_DIRECTCOLOR_ENABLE |
1251                         PM3RD_MiscControl_HIGHCOLOR_RES_ENABLE;
1252                 break;
1253         }
1254         PM3_WRITE_DAC_REG(PM3RD_MiscControl, tempmisc);
1255         
1256         PM3_SHOW_CUR_MODE;
1257 }
1258
1259 static void pm3fb_read_mode(struct pm3fb_info *l_fb_info,
1260                             struct pm3fb_par *curpar)
1261 {
1262         unsigned long pixsize1, pixsize2, clockused;
1263         unsigned long pre, feedback, post;
1264
1265         DTRACE;
1266
1267         clockused = PM3_READ_REG(PM3VClkCtl);
1268
1269         switch (clockused) {
1270         case 3:
1271                 pre = PM3_READ_DAC_REG(PM3RD_DClk3PreScale);
1272                 feedback = PM3_READ_DAC_REG(PM3RD_DClk3FeedbackScale);
1273                 post = PM3_READ_DAC_REG(PM3RD_DClk3PostScale);
1274
1275                 DPRINTK(2,
1276                         "DClk3 parameter: Pre: %ld, Feedback: %ld, Post: %ld ; giving pixclock: %ld\n",
1277                         pre, feedback, post, PM3_SCALE_TO_CLOCK(pre,
1278                                                                 feedback,
1279                                                                 post));
1280                 break;
1281         case 2:
1282                 pre = PM3_READ_DAC_REG(PM3RD_DClk2PreScale);
1283                 feedback = PM3_READ_DAC_REG(PM3RD_DClk2FeedbackScale);
1284                 post = PM3_READ_DAC_REG(PM3RD_DClk2PostScale);
1285
1286                 DPRINTK(2,
1287                         "DClk2 parameter: Pre: %ld, Feedback: %ld, Post: %ld ; giving pixclock: %ld\n",
1288                         pre, feedback, post, PM3_SCALE_TO_CLOCK(pre,
1289                                                                 feedback,
1290                                                                 post));
1291                 break;
1292         case 1:
1293                 pre = PM3_READ_DAC_REG(PM3RD_DClk1PreScale);
1294                 feedback = PM3_READ_DAC_REG(PM3RD_DClk1FeedbackScale);
1295                 post = PM3_READ_DAC_REG(PM3RD_DClk1PostScale);
1296
1297                 DPRINTK(2,
1298                         "DClk1 parameter: Pre: %ld, Feedback: %ld, Post: %ld ; giving pixclock: %ld\n",
1299                         pre, feedback, post, PM3_SCALE_TO_CLOCK(pre,
1300                                                                 feedback,
1301                                                                 post));
1302                 break;
1303         case 0:
1304                 pre = PM3_READ_DAC_REG(PM3RD_DClk0PreScale);
1305                 feedback = PM3_READ_DAC_REG(PM3RD_DClk0FeedbackScale);
1306                 post = PM3_READ_DAC_REG(PM3RD_DClk0PostScale);
1307
1308                 DPRINTK(2,
1309                         "DClk0 parameter: Pre: %ld, Feedback: %ld, Post: %ld ; giving pixclock: %ld\n",
1310                         pre, feedback, post, PM3_SCALE_TO_CLOCK(pre,
1311                                                                 feedback,
1312                                                                 post));
1313                 break;
1314         default:
1315                 pre = feedback = post = 0;
1316                 DPRINTK(1, "Unknowk D clock used : %ld\n", clockused);
1317                 break;
1318         }
1319
1320         curpar->pixclock = PM3_SCALE_TO_CLOCK(pre, feedback, post);
1321
1322         pixsize1 =
1323             PM3ByApertureMode_PIXELSIZE_MASK &
1324             (PM3_READ_REG(PM3ByAperture1Mode));
1325         pixsize2 =
1326             PM3ByApertureMode_PIXELSIZE_MASK &
1327             (PM3_READ_REG(PM3ByAperture2Mode));
1328
1329         DASSERT((pixsize1 == pixsize2),
1330                 "pixsize the same in both aperture\n");
1331
1332         if (pixsize1 & PM3ByApertureMode_PIXELSIZE_32BIT)
1333                 curpar->depth = 32;
1334         else if (pixsize1 & PM3ByApertureMode_PIXELSIZE_16BIT)
1335         {
1336                 curpar->depth = 16;
1337         }
1338         else
1339                 curpar->depth = 8;
1340
1341         /* not sure if I need to add one on the next ; it give better result with */
1342         curpar->htotal =
1343             pm3fb_Unshiftbpp(l_fb_info, curpar->depth,
1344                              1 + PM3_READ_REG(PM3HTotal));
1345         curpar->hsend =
1346             pm3fb_Unshiftbpp(l_fb_info, curpar->depth,
1347                              PM3_READ_REG(PM3HsEnd));
1348         curpar->hsstart =
1349             pm3fb_Unshiftbpp(l_fb_info, curpar->depth,
1350                              PM3_READ_REG(PM3HsStart));
1351         curpar->hbend =
1352             pm3fb_Unshiftbpp(l_fb_info, curpar->depth,
1353                              PM3_READ_REG(PM3HbEnd));
1354
1355         curpar->stride =
1356             pm3fb_Unshiftbpp(l_fb_info, curpar->depth,
1357                              PM3_READ_REG(PM3ScreenStride));
1358
1359         curpar->vtotal = 1 + PM3_READ_REG(PM3VTotal);
1360         curpar->vsend = 1 + PM3_READ_REG(PM3VsEnd);
1361         curpar->vsstart = 1 + PM3_READ_REG(PM3VsStart);
1362         curpar->vbend = PM3_READ_REG(PM3VbEnd);
1363
1364         curpar->video = PM3_READ_REG(PM3VideoControl);
1365
1366         curpar->base = PM3_READ_REG(PM3ScreenBase);
1367         curpar->width = curpar->htotal - curpar->hbend; /* make virtual == displayed resolution */
1368         curpar->height = curpar->vtotal - curpar->vbend;
1369
1370         DPRINTK(2, "Found : %d * %d, %d Khz, stride is %08x\n",
1371                 curpar->width, curpar->height, curpar->pixclock,
1372                 curpar->stride);
1373 }
1374
1375 static unsigned long pm3fb_size_memory(struct pm3fb_info *l_fb_info)
1376 {
1377         unsigned long memsize = 0, tempBypass, i, temp1, temp2;
1378         u16 subvendor, subdevice;
1379         pm3fb_timing_result ptr;
1380
1381         DTRACE;
1382
1383         l_fb_info->fb_size = 64 * 1024 * 1024;  /* pm3 aperture always 64 MB */
1384         pm3fb_mapIO(l_fb_info); /* temporary map IO */
1385
1386         DASSERT((l_fb_info->vIOBase != NULL),
1387                 "IO successfully mapped before mem detect\n");
1388         DASSERT((l_fb_info->v_fb != NULL),
1389                 "FB successfully mapped before mem detect\n");
1390
1391         /* card-specific stuff, *before* accessing *any* FB memory */
1392         if ((!pci_read_config_word
1393              (l_fb_info->dev, PCI_SUBSYSTEM_VENDOR_ID, &subvendor))
1394             &&
1395             (!pci_read_config_word
1396              (l_fb_info->dev, PCI_SUBSYSTEM_ID, &subdevice))) {
1397                 i = 0; l_fb_info->board_type = 0;
1398                 while ((cardbase[i].cardname[0]) && !(l_fb_info->board_type)) {
1399                         if ((cardbase[i].subvendor == subvendor) &&
1400                             (cardbase[i].subdevice == subdevice) &&
1401                             (cardbase[i].func == PCI_FUNC(l_fb_info->dev->devfn))) {
1402                                 DPRINTK(2, "Card #%ld is an %s\n",
1403                                         l_fb_info->board_num,
1404                                         cardbase[i].cardname);
1405                                 if (cardbase[i].specific_setup)
1406                                         cardbase[i].specific_setup(l_fb_info);
1407                                 l_fb_info->board_type = i;
1408                         }
1409                         i++;
1410                 }
1411                 if (!l_fb_info->board_type) {
1412                         DPRINTK(1, "Card #%ld is an unknown 0x%04x / 0x%04x\n",
1413                                 l_fb_info->board_num, subvendor, subdevice);
1414                 }
1415         } else {
1416                 printk(KERN_ERR "pm3fb: Error: pci_read_config_word failed, board #%ld\n",
1417                        l_fb_info->board_num);
1418         }
1419
1420         if (printtimings)
1421                 pm3fb_show_cur_timing(l_fb_info);
1422         
1423         /* card-specific setup is done, we preserve the final
1424            memory timing for future reference */
1425         if ((ptr = pm3fb_preserve_memory_timings(l_fb_info)) == pm3fb_timing_problem) { /* memory timings were wrong ! oops.... */
1426                 return(0);
1427         }
1428         
1429         tempBypass = PM3_READ_REG(PM3MemBypassWriteMask);
1430
1431         DPRINTK(2, "PM3MemBypassWriteMask was: 0x%08lx\n", tempBypass);
1432
1433         PM3_SLOW_WRITE_REG(PM3MemBypassWriteMask, 0xFFFFFFFF);
1434
1435         /* pm3 split up memory, replicates, and do a lot of nasty stuff IMHO ;-) */
1436         for (i = 0; i < 32; i++) {
1437                 fb_writel(i * 0x00345678,
1438                           (l_fb_info->v_fb + (i * 1048576)));
1439                 mb();
1440                 temp1 = fb_readl((l_fb_info->v_fb + (i * 1048576)));
1441
1442                 /* Let's check for wrapover, write will fail at 16MB boundary */
1443                 if (temp1 == (i * 0x00345678))
1444                         memsize = i;
1445                 else
1446                         break;
1447         }
1448
1449         DPRINTK(2, "First detect pass already got %ld MB\n", memsize + 1);
1450
1451         if (memsize == i) {
1452                 for (i = 0; i < 32; i++) {
1453                         /* Clear first 32MB ; 0 is 0, no need to byteswap */
1454                         writel(0x0000000,
1455                                (l_fb_info->v_fb + (i * 1048576)));
1456                         mb();
1457                 }
1458
1459                 for (i = 32; i < 64; i++) {
1460                         fb_writel(i * 0x00345678,
1461                                   (l_fb_info->v_fb + (i * 1048576)));
1462                         mb();
1463                         temp1 =
1464                             fb_readl((l_fb_info->v_fb + (i * 1048576)));
1465                         temp2 =
1466                             fb_readl((l_fb_info->v_fb +
1467                                       ((i - 32) * 1048576)));
1468                         if ((temp1 == (i * 0x00345678)) && (temp2 == 0))        /* different value, different RAM... */
1469                                 memsize = i;
1470                         else
1471                                 break;
1472                 }
1473         }
1474
1475         DPRINTK(2, "Second detect pass got %ld MB\n", memsize + 1);
1476
1477         PM3_SLOW_WRITE_REG(PM3MemBypassWriteMask, tempBypass);
1478
1479         pm3fb_unmapIO(l_fb_info);
1480         memsize = 1048576 * (memsize + 1);
1481
1482         DPRINTK(2, "Returning 0x%08lx bytes\n", memsize);
1483
1484         if (forcesize[l_fb_info->board_num] && ((forcesize[l_fb_info->board_num] * 1048576) != memsize))
1485         {
1486                 printk(KERN_WARNING "pm3fb: mismatch between probed (%ld MB) and specified (%hd MB) memory size, using SPECIFIED !\n", memsize, forcesize[l_fb_info->board_num]);
1487                 memsize = 1048576 * forcesize[l_fb_info->board_num];
1488         }
1489         
1490         l_fb_info->fb_size = memsize;
1491         
1492         if (ptr == pm3fb_timing_retry)
1493         {
1494                 printk(KERN_WARNING "pm3fb: retrying memory timings check");
1495                 if (pm3fb_try_memory_timings(l_fb_info) == pm3fb_timing_problem)
1496                         return(0);
1497         }
1498         
1499         return (memsize);
1500 }
1501
1502 static void pm3fb_clear_memory(struct pm3fb_info *l_fb_info, u32 cc)
1503 {
1504         int i;
1505
1506         DTRACE;
1507
1508         for (i = 0; i < (l_fb_info->fb_size / sizeof(u32)) ; i++) /* clear entire FB memory to black */
1509         {
1510                 fb_writel(cc, (l_fb_info->v_fb + (i * sizeof(u32))));
1511         }
1512 }
1513
1514 static void pm3fb_clear_colormap(struct pm3fb_info *l_fb_info, unsigned char r, unsigned char g, unsigned char b)
1515 {
1516         int i;
1517
1518         DTRACE;
1519
1520         for (i = 0; i < 256 ; i++) /* fill color map with white */
1521                 pm3fb_set_color(l_fb_info, i, r, g, b);
1522
1523 }
1524
1525 /* common initialisation */
1526 static void pm3fb_common_init(struct pm3fb_info *l_fb_info)
1527 {
1528         DTRACE;
1529
1530         DPRINTK(2, "Initializing board #%ld @ %lx\n", l_fb_info->board_num,
1531                 (unsigned long) l_fb_info);
1532
1533         strcpy(l_fb_info->gen.info.modename, permedia3_name);
1534         disp[l_fb_info->board_num].scrollmode = 0;      /* SCROLL_YNOMOVE; *//* 0 means "let fbcon choose" */
1535         l_fb_info->gen.parsize = sizeof(struct pm3fb_par);
1536         l_fb_info->gen.info.changevar = NULL;
1537         l_fb_info->gen.info.fbops = &pm3fb_ops;
1538         l_fb_info->gen.info.disp = &(disp[l_fb_info->board_num]);
1539         if (fontn[l_fb_info->board_num][0])
1540                 strcpy(l_fb_info->gen.info.fontname,
1541                        fontn[l_fb_info->board_num]);
1542         l_fb_info->gen.info.switch_con = &fbgen_switch;
1543         l_fb_info->gen.info.updatevar = &fbgen_update_var;      /* */
1544         l_fb_info->gen.info.flags = FBINFO_FLAG_DEFAULT;
1545
1546         pm3fb_mapIO(l_fb_info);
1547
1548         pm3fb_clear_memory(l_fb_info, 0);
1549         pm3fb_clear_colormap(l_fb_info, 0, 0, 0);
1550
1551         (void) fbgen_get_var(&(disp[l_fb_info->board_num]).var, -1,
1552                              &l_fb_info->gen.info);
1553
1554         if (depth[l_fb_info->board_num]) /* override mode-defined depth */
1555         {
1556                 pm3fb_encode_depth(&(disp[l_fb_info->board_num]).var, depth[l_fb_info->board_num]);
1557                 (disp[l_fb_info->board_num]).var.bits_per_pixel = depth2bpp(depth[l_fb_info->board_num]);
1558         }
1559
1560         (void) fbgen_do_set_var(&(disp[l_fb_info->board_num]).var, 1,
1561                                 &l_fb_info->gen);
1562
1563         fbgen_set_disp(-1, &l_fb_info->gen);
1564
1565         do_install_cmap(0, &l_fb_info->gen.info);
1566
1567         if (register_framebuffer(&l_fb_info->gen.info) < 0) {
1568                 DPRINTK(1, "Couldn't register framebuffer\n");
1569                 return;
1570         }
1571
1572         PM3_WRITE_DAC_REG(PM3RD_CursorMode,
1573                           PM3RD_CursorMode_CURSOR_DISABLE);
1574         
1575         PM3_SHOW_CUR_MODE;
1576         
1577         pm3fb_write_mode(l_fb_info);
1578         
1579         printk("fb%d: %s, using %uK of video memory (%s)\n",
1580                l_fb_info->gen.info.node,
1581                permedia3_name, (u32) (l_fb_info->fb_size >> 10),
1582                cardbase[l_fb_info->board_type].cardname);
1583 }
1584
1585 /* **************************************************** */
1586 /* ***** accelerated permedia3-specific functions ***** */
1587 /* **************************************************** */
1588 #ifdef PM3FB_USE_ACCEL
1589 static void pm3fb_wait_pm3(struct pm3fb_info *l_fb_info)
1590 {
1591         DTRACE;
1592
1593         PM3_SLOW_WRITE_REG(PM3FilterMode, PM3FilterModeSync);
1594         PM3_SLOW_WRITE_REG(PM3Sync, 0);
1595         mb();
1596         do {
1597                 while ((PM3_READ_REG(PM3OutFIFOWords)) == 0);
1598                 rmb();
1599         } while ((PM3_READ_REG(PM3OutputFifo)) != PM3Sync_Tag);
1600 }
1601
1602 static void pm3fb_init_engine(struct pm3fb_info *l_fb_info)
1603 {
1604         PM3_SLOW_WRITE_REG(PM3FilterMode, PM3FilterModeSync);
1605         PM3_SLOW_WRITE_REG(PM3StatisticMode, 0x0);
1606         PM3_SLOW_WRITE_REG(PM3DeltaMode, 0x0);
1607         PM3_SLOW_WRITE_REG(PM3RasterizerMode, 0x0);
1608         PM3_SLOW_WRITE_REG(PM3ScissorMode, 0x0);
1609         PM3_SLOW_WRITE_REG(PM3LineStippleMode, 0x0);
1610         PM3_SLOW_WRITE_REG(PM3AreaStippleMode, 0x0);
1611         PM3_SLOW_WRITE_REG(PM3GIDMode, 0x0);
1612         PM3_SLOW_WRITE_REG(PM3DepthMode, 0x0);
1613         PM3_SLOW_WRITE_REG(PM3StencilMode, 0x0);
1614         PM3_SLOW_WRITE_REG(PM3StencilData, 0x0);
1615         PM3_SLOW_WRITE_REG(PM3ColorDDAMode, 0x0);
1616         PM3_SLOW_WRITE_REG(PM3TextureCoordMode, 0x0);
1617         PM3_SLOW_WRITE_REG(PM3TextureIndexMode0, 0x0);
1618         PM3_SLOW_WRITE_REG(PM3TextureIndexMode1, 0x0);
1619         PM3_SLOW_WRITE_REG(PM3TextureReadMode, 0x0);
1620         PM3_SLOW_WRITE_REG(PM3LUTMode, 0x0);
1621         PM3_SLOW_WRITE_REG(PM3TextureFilterMode, 0x0);
1622         PM3_SLOW_WRITE_REG(PM3TextureCompositeMode, 0x0);
1623         PM3_SLOW_WRITE_REG(PM3TextureApplicationMode, 0x0);
1624         PM3_SLOW_WRITE_REG(PM3TextureCompositeColorMode1, 0x0);
1625         PM3_SLOW_WRITE_REG(PM3TextureCompositeAlphaMode1, 0x0);
1626         PM3_SLOW_WRITE_REG(PM3TextureCompositeColorMode0, 0x0);
1627         PM3_SLOW_WRITE_REG(PM3TextureCompositeAlphaMode0, 0x0);
1628         PM3_SLOW_WRITE_REG(PM3FogMode, 0x0);
1629         PM3_SLOW_WRITE_REG(PM3ChromaTestMode, 0x0);
1630         PM3_SLOW_WRITE_REG(PM3AlphaTestMode, 0x0);
1631         PM3_SLOW_WRITE_REG(PM3AntialiasMode, 0x0);
1632         PM3_SLOW_WRITE_REG(PM3YUVMode, 0x0);
1633         PM3_SLOW_WRITE_REG(PM3AlphaBlendColorMode, 0x0);
1634         PM3_SLOW_WRITE_REG(PM3AlphaBlendAlphaMode, 0x0);
1635         PM3_SLOW_WRITE_REG(PM3DitherMode, 0x0);
1636         PM3_SLOW_WRITE_REG(PM3LogicalOpMode, 0x0);
1637         PM3_SLOW_WRITE_REG(PM3RouterMode, 0x0);
1638         PM3_SLOW_WRITE_REG(PM3Window, 0x0);
1639
1640         PM3_SLOW_WRITE_REG(PM3Config2D, 0x0);
1641
1642         PM3_SLOW_WRITE_REG(PM3SpanColorMask, 0xffffffff);
1643
1644         PM3_SLOW_WRITE_REG(PM3XBias, 0x0);
1645         PM3_SLOW_WRITE_REG(PM3YBias, 0x0);
1646         PM3_SLOW_WRITE_REG(PM3DeltaControl, 0x0);
1647
1648         PM3_SLOW_WRITE_REG(PM3BitMaskPattern, 0xffffffff);
1649
1650         PM3_SLOW_WRITE_REG(PM3FBDestReadEnables,
1651                            PM3FBDestReadEnables_E(0xff) |
1652                            PM3FBDestReadEnables_R(0xff) |
1653                            PM3FBDestReadEnables_ReferenceAlpha(0xff));
1654         PM3_SLOW_WRITE_REG(PM3FBDestReadBufferAddr0, 0x0);
1655         PM3_SLOW_WRITE_REG(PM3FBDestReadBufferOffset0, 0x0);
1656         PM3_SLOW_WRITE_REG(PM3FBDestReadBufferWidth0,
1657                            PM3FBDestReadBufferWidth_Width(l_fb_info->
1658                                                           current_par->
1659                                                           width));
1660
1661         PM3_SLOW_WRITE_REG(PM3FBDestReadMode,
1662                            PM3FBDestReadMode_ReadEnable |
1663                            PM3FBDestReadMode_Enable0);
1664         PM3_SLOW_WRITE_REG(PM3FBSourceReadBufferAddr, 0x0);
1665         PM3_SLOW_WRITE_REG(PM3FBSourceReadBufferOffset, 0x0);
1666         PM3_SLOW_WRITE_REG(PM3FBSourceReadBufferWidth,
1667                            PM3FBSourceReadBufferWidth_Width(l_fb_info->
1668                                                             current_par->
1669                                                             width));
1670         PM3_SLOW_WRITE_REG(PM3FBSourceReadMode,
1671                            PM3FBSourceReadMode_Blocking |
1672                            PM3FBSourceReadMode_ReadEnable);
1673
1674         {
1675                 unsigned long rm = 1;
1676                 switch (l_fb_info->current_par->depth) {
1677                 case 8:
1678                         PM3_SLOW_WRITE_REG(PM3PixelSize,
1679                                            PM3PixelSize_GLOBAL_8BIT);
1680                         break;
1681                 case 12:
1682                 case 15:
1683                 case 16:
1684                         PM3_SLOW_WRITE_REG(PM3PixelSize,
1685                                            PM3PixelSize_GLOBAL_16BIT);
1686                         break;
1687                 case 32:
1688                         PM3_SLOW_WRITE_REG(PM3PixelSize,
1689                                            PM3PixelSize_GLOBAL_32BIT);
1690                         break;
1691                 default:
1692                         DPRINTK(1, "Unsupported depth %d\n",
1693                                 l_fb_info->current_par->depth);
1694                         break;
1695                 }
1696                 PM3_SLOW_WRITE_REG(PM3RasterizerMode, rm);
1697         }
1698
1699         PM3_SLOW_WRITE_REG(PM3FBSoftwareWriteMask, 0xffffffff);
1700         PM3_SLOW_WRITE_REG(PM3FBHardwareWriteMask, 0xffffffff);
1701         PM3_SLOW_WRITE_REG(PM3FBWriteMode,
1702                            PM3FBWriteMode_WriteEnable |
1703                            PM3FBWriteMode_OpaqueSpan |
1704                            PM3FBWriteMode_Enable0);
1705         PM3_SLOW_WRITE_REG(PM3FBWriteBufferAddr0, 0x0);
1706         PM3_SLOW_WRITE_REG(PM3FBWriteBufferOffset0, 0x0);
1707         PM3_SLOW_WRITE_REG(PM3FBWriteBufferWidth0,
1708                            PM3FBWriteBufferWidth_Width(l_fb_info->
1709                                                        current_par->
1710                                                        width));
1711
1712         PM3_SLOW_WRITE_REG(PM3SizeOfFramebuffer, 0x0);
1713         {
1714                 unsigned long sofb = (8UL * l_fb_info->fb_size) /
1715                         ((depth2bpp(l_fb_info->current_par->depth))
1716                          * l_fb_info->current_par->width);      /* size in lines of FB */
1717                 if (sofb > 4095)
1718                         PM3_SLOW_WRITE_REG(PM3SizeOfFramebuffer, 4095);
1719                 else
1720                         PM3_SLOW_WRITE_REG(PM3SizeOfFramebuffer, sofb);
1721                 
1722                 switch (l_fb_info->current_par->depth) {
1723                 case 8:
1724                         PM3_SLOW_WRITE_REG(PM3DitherMode,
1725                                            (1 << 10) | (2 << 3));
1726                         break;
1727                 case 12:
1728                 case 15:
1729                 case 16:
1730                         PM3_SLOW_WRITE_REG(PM3DitherMode,
1731                                            (1 << 10) | (1 << 3));
1732                         break;
1733                 case 32:
1734                         PM3_SLOW_WRITE_REG(PM3DitherMode,
1735                                            (1 << 10) | (0 << 3));
1736                         break;
1737                 default:
1738                         DPRINTK(1, "Unsupported depth %d\n",
1739                                 l_fb_info->current_par->depth);
1740                         break;
1741                 }
1742         }
1743
1744         PM3_SLOW_WRITE_REG(PM3dXDom, 0x0);
1745         PM3_SLOW_WRITE_REG(PM3dXSub, 0x0);
1746         PM3_SLOW_WRITE_REG(PM3dY, (1 << 16));
1747         PM3_SLOW_WRITE_REG(PM3StartXDom, 0x0);
1748         PM3_SLOW_WRITE_REG(PM3StartXSub, 0x0);
1749         PM3_SLOW_WRITE_REG(PM3StartY, 0x0);
1750         PM3_SLOW_WRITE_REG(PM3Count, 0x0);
1751         
1752 /* Disable LocalBuffer. better safe than sorry */
1753         PM3_SLOW_WRITE_REG(PM3LBDestReadMode, 0x0);
1754         PM3_SLOW_WRITE_REG(PM3LBDestReadEnables, 0x0);
1755         PM3_SLOW_WRITE_REG(PM3LBSourceReadMode, 0x0);
1756         PM3_SLOW_WRITE_REG(PM3LBWriteMode, 0x0);
1757         
1758         pm3fb_wait_pm3(l_fb_info);
1759 }
1760
1761 #ifdef FBCON_HAS_CFB32
1762 static void pm3fb_cfb32_clear(struct vc_data *conp,
1763                               struct display *p,
1764                               int sy, int sx, int height, int width)
1765 {
1766         struct pm3fb_info *l_fb_info = (struct pm3fb_info *) p->fb_info;
1767         u32 c;
1768
1769         DTRACE;
1770
1771         sx = sx * fontwidth(p);
1772         width = width * fontwidth(p);
1773         sy = sy * fontheight(p);
1774         height = height * fontheight(p);
1775         c = ((u32 *) p->dispsw_data)[attr_bgcol_ec(p, conp)];
1776
1777         /* block fills in 32bpp are hard, but in low res (width <= 1600 :-)
1778            we can use 16bpp operations, but not if NoWriteMask is on (SDRAM)  */
1779         if ((l_fb_info->current_par->width > 1600) ||
1780             (l_fb_info->memt.caps & PM3LocalMemCaps_NoWriteMask)) {
1781                 PM3_WAIT(4);
1782
1783                 PM3_WRITE_REG(PM3Config2D,
1784                                           PM3Config2D_UseConstantSource |
1785                                           PM3Config2D_ForegroundROPEnable |
1786                                           (PM3Config2D_ForegroundROP(0x3)) |    /* Ox3 is GXcopy */
1787                                           PM3Config2D_FBWriteEnable);
1788
1789                 PM3_WRITE_REG(PM3ForegroundColor, c);
1790
1791                 PM3_WRITE_REG(PM3RectanglePosition,
1792                               (PM3RectanglePosition_XOffset(sx)) |
1793                               (PM3RectanglePosition_YOffset(sy)));
1794
1795                 PM3_WRITE_REG(PM3Render2D,
1796                               PM3Render2D_XPositive |
1797                               PM3Render2D_YPositive |
1798                               PM3Render2D_Operation_Normal |
1799                               PM3Render2D_SpanOperation |
1800                               (PM3Render2D_Width(width)) |
1801                               (PM3Render2D_Height(height)));
1802         } else {
1803                 PM3_WAIT(8);
1804
1805                 PM3_WRITE_REG(PM3FBBlockColor, c);
1806
1807                 PM3_WRITE_REG(PM3PixelSize, PM3PixelSize_GLOBAL_16BIT);
1808
1809                 PM3_WRITE_REG(PM3FBWriteBufferWidth0,
1810                               PM3FBWriteBufferWidth_Width(l_fb_info->
1811                                                           current_par->
1812                                                           width << 1));
1813
1814                 PM3_WRITE_REG(PM3Config2D,
1815                                           PM3Config2D_UseConstantSource |
1816                                           PM3Config2D_ForegroundROPEnable |
1817                                           (PM3Config2D_ForegroundROP(0x3)) |    /* Ox3 is GXcopy */
1818                                           PM3Config2D_FBWriteEnable);
1819
1820                 PM3_WRITE_REG(PM3RectanglePosition,
1821                               (PM3RectanglePosition_XOffset(sx << 1)) |
1822                               (PM3RectanglePosition_YOffset(sy)));
1823
1824                 PM3_WRITE_REG(PM3Render2D,
1825                               PM3Render2D_XPositive |
1826                               PM3Render2D_YPositive |
1827                               PM3Render2D_Operation_Normal |
1828                               (PM3Render2D_Width(width << 1)) |
1829                               (PM3Render2D_Height(height)));
1830
1831                 PM3_WRITE_REG(PM3FBWriteBufferWidth0,
1832                               PM3FBWriteBufferWidth_Width(l_fb_info->
1833                                                           current_par->
1834                                                           width));
1835
1836                 PM3_WRITE_REG(PM3PixelSize, PM3PixelSize_GLOBAL_32BIT);
1837         }
1838
1839         pm3fb_wait_pm3(l_fb_info);
1840 }
1841
1842 static void pm3fb_cfb32_clear_margins(struct vc_data *conp,
1843                                       struct display *p, int bottom_only)
1844 {
1845         struct pm3fb_info *l_fb_info = (struct pm3fb_info *) p->fb_info;
1846         int sx, sy;
1847         u32 c;
1848
1849         DTRACE;
1850
1851         sx = conp->vc_cols * fontwidth(p);      /* right margin */
1852         sy = conp->vc_rows * fontheight(p);     /* bottom margin */
1853         c = ((u32 *) p->dispsw_data)[attr_bgcol_ec(p, conp)];
1854
1855         if (!bottom_only) {     /* right margin top->bottom */
1856                 PM3_WAIT(4);
1857
1858                 PM3_WRITE_REG(PM3Config2D,
1859                                           PM3Config2D_UseConstantSource |
1860                                           PM3Config2D_ForegroundROPEnable |
1861                                           (PM3Config2D_ForegroundROP(0x3)) |    /* Ox3 is GXcopy */
1862                                           PM3Config2D_FBWriteEnable);
1863
1864                 PM3_WRITE_REG(PM3ForegroundColor, c);
1865
1866                 PM3_WRITE_REG(PM3RectanglePosition,
1867                               (PM3RectanglePosition_XOffset
1868                                (p->var.xoffset +
1869                                 sx)) | (PM3RectanglePosition_YOffset(p->
1870                                                                      var.
1871                                                                      yoffset)));
1872
1873                 PM3_WRITE_REG(PM3Render2D,
1874                               PM3Render2D_XPositive |
1875                               PM3Render2D_YPositive |
1876                               PM3Render2D_Operation_Normal |
1877                               PM3Render2D_SpanOperation |
1878                               (PM3Render2D_Width(p->var.xres - sx)) |
1879                               (PM3Render2D_Height(p->var.yres)));
1880         }
1881
1882         /* bottom margin left -> right */
1883         PM3_WAIT(4);
1884
1885         PM3_WRITE_REG(PM3Config2D,
1886                                   PM3Config2D_UseConstantSource |
1887                                   PM3Config2D_ForegroundROPEnable |
1888                                   (PM3Config2D_ForegroundROP(0x3)) |    /* Ox3 is GXcopy */
1889                                   PM3Config2D_FBWriteEnable);
1890
1891         PM3_WRITE_REG(PM3ForegroundColor, c);
1892
1893         PM3_WRITE_REG(PM3RectanglePosition,
1894                       (PM3RectanglePosition_XOffset(p->var.xoffset)) |
1895                       (PM3RectanglePosition_YOffset(p->var.yoffset + sy)));
1896
1897         PM3_WRITE_REG(PM3Render2D,
1898                       PM3Render2D_XPositive |
1899                       PM3Render2D_YPositive |
1900                       PM3Render2D_Operation_Normal |
1901                       PM3Render2D_SpanOperation |
1902                       (PM3Render2D_Width(p->var.xres)) |
1903                       (PM3Render2D_Height(p->var.yres - sy)));
1904
1905         pm3fb_wait_pm3(l_fb_info);
1906 }
1907 #endif /* FBCON_HAS_CFB32 */
1908 #ifdef FBCON_HAS_CFB16
1909 static void pm3fb_cfb16_clear(struct vc_data *conp,
1910                               struct display *p,
1911                               int sy, int sx, int height, int width)
1912 {
1913         struct pm3fb_info *l_fb_info = (struct pm3fb_info *) p->fb_info;
1914         u32 c;
1915
1916         DTRACE;
1917
1918         sx = sx * fontwidth(p);
1919         width = width * fontwidth(p);
1920         sy = sy * fontheight(p);
1921         height = height * fontheight(p);
1922         c = ((u16 *) p->dispsw_data)[attr_bgcol_ec(p, conp)];
1923         c = c | (c << 16);
1924
1925         PM3_WAIT(4);
1926
1927         if (l_fb_info->memt.caps & PM3LocalMemCaps_NoWriteMask)
1928                 PM3_WRITE_REG(PM3ForegroundColor, c);
1929         else
1930                 PM3_WRITE_REG(PM3FBBlockColor, c);
1931
1932         PM3_WRITE_REG(PM3Config2D,
1933                                   PM3Config2D_UseConstantSource |
1934                                   PM3Config2D_ForegroundROPEnable |
1935                                   (PM3Config2D_ForegroundROP(0x3)) |    /* Ox3 is GXcopy */
1936                                   PM3Config2D_FBWriteEnable);
1937
1938         PM3_WRITE_REG(PM3RectanglePosition,
1939                       (PM3RectanglePosition_XOffset(sx)) |
1940                       (PM3RectanglePosition_YOffset(sy)));
1941         
1942         if (l_fb_info->memt.caps & PM3LocalMemCaps_NoWriteMask)
1943                 PM3_WRITE_REG(PM3Render2D,
1944                               PM3Render2D_XPositive |
1945                               PM3Render2D_YPositive |
1946                               PM3Render2D_Operation_Normal |
1947                               PM3Render2D_SpanOperation |
1948                               (PM3Render2D_Width(width)) |
1949                               (PM3Render2D_Height(height)));
1950         else
1951                 PM3_WRITE_REG(PM3Render2D,
1952                               PM3Render2D_XPositive |
1953                               PM3Render2D_YPositive |
1954                               PM3Render2D_Operation_Normal |
1955                               (PM3Render2D_Width(width)) |
1956                               (PM3Render2D_Height(height)));
1957         
1958         pm3fb_wait_pm3(l_fb_info);
1959 }
1960
1961 static void pm3fb_cfb16_clear_margins(struct vc_data *conp,
1962                                       struct display *p, int bottom_only)
1963 {
1964         struct pm3fb_info *l_fb_info = (struct pm3fb_info *) p->fb_info;
1965         int sx, sy;
1966         u32 c;
1967
1968         DTRACE;
1969
1970         sx = conp->vc_cols * fontwidth(p);      /* right margin */
1971         sy = conp->vc_rows * fontheight(p);     /* bottom margin */
1972         c = ((u16 *) p->dispsw_data)[attr_bgcol_ec(p, conp)];
1973         c = c | (c << 16);
1974
1975         if (!bottom_only) {     /* right margin top->bottom */
1976                 PM3_WAIT(4);
1977
1978                 PM3_WRITE_REG(PM3Config2D,
1979                                           PM3Config2D_UseConstantSource |
1980                                           PM3Config2D_ForegroundROPEnable |
1981                                           (PM3Config2D_ForegroundROP(0x3)) |    /* Ox3 is GXcopy */
1982                                           PM3Config2D_FBWriteEnable);
1983                 
1984                 if (l_fb_info->memt.caps & PM3LocalMemCaps_NoWriteMask)
1985                         PM3_WRITE_REG(PM3ForegroundColor, c);
1986                 else
1987                         PM3_WRITE_REG(PM3FBBlockColor, c);
1988                 
1989                 PM3_WRITE_REG(PM3RectanglePosition,
1990                               (PM3RectanglePosition_XOffset
1991                                (p->var.xoffset +
1992                                 sx)) | (PM3RectanglePosition_YOffset(p->
1993                                                                      var.
1994                                                                      yoffset)));
1995                 if (l_fb_info->memt.caps & PM3LocalMemCaps_NoWriteMask)
1996                         PM3_WRITE_REG(PM3Render2D,
1997                                       PM3Render2D_XPositive |
1998                                       PM3Render2D_YPositive |
1999                                       PM3Render2D_Operation_Normal |
2000                                       PM3Render2D_SpanOperation |
2001                                       (PM3Render2D_Width(p->var.xres - sx)) |
2002                                       (PM3Render2D_Height(p->var.yres)));
2003                 else
2004                         PM3_WRITE_REG(PM3Render2D,
2005                                       PM3Render2D_XPositive |
2006                                       PM3Render2D_YPositive |
2007                                       PM3Render2D_Operation_Normal |
2008                                       (PM3Render2D_Width(p->var.xres - sx)) |
2009                                       (PM3Render2D_Height(p->var.yres)));
2010         }
2011         
2012         /* bottom margin left -> right */
2013         PM3_WAIT(4);
2014         
2015         PM3_WRITE_REG(PM3Config2D,
2016                       PM3Config2D_UseConstantSource |
2017                       PM3Config2D_ForegroundROPEnable |
2018                       (PM3Config2D_ForegroundROP(0x3)) |        /* Ox3 is GXcopy */
2019                       PM3Config2D_FBWriteEnable);
2020         
2021         if (l_fb_info->memt.caps & PM3LocalMemCaps_NoWriteMask)
2022                 PM3_WRITE_REG(PM3ForegroundColor, c);
2023         else
2024                 PM3_WRITE_REG(PM3FBBlockColor, c);
2025         
2026         
2027         PM3_WRITE_REG(PM3RectanglePosition,
2028                       (PM3RectanglePosition_XOffset(p->var.xoffset)) |
2029                       (PM3RectanglePosition_YOffset(p->var.yoffset + sy)));
2030         
2031         if (l_fb_info->memt.caps & PM3LocalMemCaps_NoWriteMask)
2032                 PM3_WRITE_REG(PM3Render2D,
2033                               PM3Render2D_XPositive |
2034                               PM3Render2D_YPositive |
2035                               PM3Render2D_Operation_Normal |
2036                               PM3Render2D_SpanOperation |
2037                               (PM3Render2D_Width(p->var.xres)) |
2038                               (PM3Render2D_Height(p->var.yres - sy)));
2039         else
2040                 PM3_WRITE_REG(PM3Render2D,
2041                               PM3Render2D_XPositive |
2042                               PM3Render2D_YPositive |
2043                               PM3Render2D_Operation_Normal |
2044                               (PM3Render2D_Width(p->var.xres)) |
2045                               (PM3Render2D_Height(p->var.yres - sy)));
2046
2047         pm3fb_wait_pm3(l_fb_info);
2048 }
2049 #endif /* FBCON_HAS_CFB16 */
2050 #ifdef FBCON_HAS_CFB8
2051 static void pm3fb_cfb8_clear(struct vc_data *conp,
2052                              struct display *p,
2053                              int sy, int sx, int height, int width)
2054 {
2055         struct pm3fb_info *l_fb_info = (struct pm3fb_info *) p->fb_info;
2056         u32 c;
2057
2058         DTRACE;
2059
2060         sx = sx * fontwidth(p);
2061         width = width * fontwidth(p);
2062         sy = sy * fontheight(p);
2063         height = height * fontheight(p);
2064
2065         c = attr_bgcol_ec(p, conp);
2066         c |= c << 8;
2067         c |= c << 16;
2068
2069         PM3_WAIT(4);
2070
2071         PM3_WRITE_REG(PM3Config2D,
2072                                   PM3Config2D_UseConstantSource |
2073                                   PM3Config2D_ForegroundROPEnable |
2074                                   (PM3Config2D_ForegroundROP(0x3)) |    /* Ox3 is GXcopy */
2075                                   PM3Config2D_FBWriteEnable);
2076
2077         PM3_WRITE_REG(PM3ForegroundColor, c);
2078
2079         PM3_WRITE_REG(PM3RectanglePosition,
2080                       (PM3RectanglePosition_XOffset(sx)) |
2081                       (PM3RectanglePosition_YOffset(sy)));
2082
2083         PM3_WRITE_REG(PM3Render2D,
2084                       PM3Render2D_XPositive |
2085                       PM3Render2D_YPositive |
2086                       PM3Render2D_Operation_Normal |
2087                       PM3Render2D_SpanOperation |
2088                       (PM3Render2D_Width(width)) |
2089                       (PM3Render2D_Height(height)));
2090
2091         pm3fb_wait_pm3(l_fb_info);
2092 }
2093
2094 static void pm3fb_cfb8_clear_margins(struct vc_data *conp,
2095                                      struct display *p, int bottom_only)
2096 {
2097         struct pm3fb_info *l_fb_info = (struct pm3fb_info *) p->fb_info;
2098         int sx, sy;
2099         u32 c;
2100
2101         DTRACE;
2102
2103         sx = conp->vc_cols * fontwidth(p);      /* right margin */
2104         sy = conp->vc_rows * fontheight(p);     /* bottom margin */
2105         c = attr_bgcol_ec(p, conp);
2106         c |= c << 8;
2107         c |= c << 16;
2108
2109         if (!bottom_only) {     /* right margin top->bottom */
2110                 PM3_WAIT(4);
2111
2112                 PM3_WRITE_REG(PM3Config2D,
2113                                           PM3Config2D_UseConstantSource |
2114                                           PM3Config2D_ForegroundROPEnable |
2115                                           (PM3Config2D_ForegroundROP(0x3)) |    /* Ox3 is GXcopy */
2116                                           PM3Config2D_FBWriteEnable);
2117
2118                 PM3_WRITE_REG(PM3ForegroundColor, c);
2119
2120                 PM3_WRITE_REG(PM3RectanglePosition,
2121                               (PM3RectanglePosition_XOffset
2122                                (p->var.xoffset +
2123                                 sx)) | (PM3RectanglePosition_YOffset(p->
2124                                                                      var.
2125                                                                      yoffset)));
2126
2127                 PM3_WRITE_REG(PM3Render2D,
2128                               PM3Render2D_XPositive |
2129                               PM3Render2D_YPositive |
2130                               PM3Render2D_Operation_Normal |
2131                               PM3Render2D_SpanOperation |
2132                               (PM3Render2D_Width(p->var.xres - sx)) |
2133                               (PM3Render2D_Height(p->var.yres)));
2134         }
2135
2136         /* bottom margin left -> right */
2137         PM3_WAIT(4);
2138
2139         PM3_WRITE_REG(PM3Config2D,
2140                                   PM3Config2D_UseConstantSource |
2141                                   PM3Config2D_ForegroundROPEnable |
2142                                   (PM3Config2D_ForegroundROP(0x3)) |    /* Ox3 is GXcopy */
2143                                   PM3Config2D_FBWriteEnable);
2144
2145         PM3_WRITE_REG(PM3ForegroundColor, c);
2146
2147         PM3_WRITE_REG(PM3RectanglePosition,
2148                       (PM3RectanglePosition_XOffset(p->var.xoffset)) |
2149                       (PM3RectanglePosition_YOffset(p->var.yoffset + sy)));
2150
2151         PM3_WRITE_REG(PM3Render2D,
2152                       PM3Render2D_XPositive |
2153                       PM3Render2D_YPositive |
2154                       PM3Render2D_Operation_Normal |
2155                       PM3Render2D_SpanOperation |
2156                       (PM3Render2D_Width(p->var.xres)) |
2157                       (PM3Render2D_Height(p->var.yres - sy)));
2158
2159         pm3fb_wait_pm3(l_fb_info);
2160 }
2161 #endif /* FBCON_HAS_CFB8 */
2162 #if defined(FBCON_HAS_CFB8) || defined(FBCON_HAS_CFB16) || defined(FBCON_HAS_CFB32)
2163 static void pm3fb_cfbX_bmove(struct display *p,
2164                              int sy, int sx,
2165                              int dy, int dx, int height, int width)
2166 {
2167         struct pm3fb_info *l_fb_info = (struct pm3fb_info *) p->fb_info;
2168         int x_align, o_x, o_y;
2169
2170         DTRACE;
2171
2172         sx = sx * fontwidth(p);
2173         dx = dx * fontwidth(p);
2174         width = width * fontwidth(p);
2175         sy = sy * fontheight(p);
2176         dy = dy * fontheight(p);
2177         height = height * fontheight(p);
2178
2179         o_x = sx - dx;          /*(sx > dx ) ? (sx - dx) : (dx - sx); */
2180         o_y = sy - dy;          /*(sy > dy ) ? (sy - dy) : (dy - sy); */
2181
2182         x_align = (sx & 0x1f);
2183
2184         PM3_WAIT(6);
2185
2186         PM3_WRITE_REG(PM3Config2D,
2187                                   PM3Config2D_UserScissorEnable |
2188                                   PM3Config2D_ForegroundROPEnable |
2189                                   PM3Config2D_Blocking |
2190                                   (PM3Config2D_ForegroundROP(0x3)) |    /* Ox3 is GXcopy */
2191                                   PM3Config2D_FBWriteEnable);
2192
2193         PM3_WRITE_REG(PM3ScissorMinXY,
2194                       ((dy & 0x0fff) << 16) | (dx & 0x0fff));
2195         PM3_WRITE_REG(PM3ScissorMaxXY,
2196                                   (((dy + height) & 0x0fff) << 16) |
2197                                   ((dx + width) & 0x0fff));
2198
2199         PM3_WRITE_REG(PM3FBSourceReadBufferOffset,
2200                       PM3FBSourceReadBufferOffset_XOffset(o_x) |
2201                       PM3FBSourceReadBufferOffset_YOffset(o_y));
2202
2203         PM3_WRITE_REG(PM3RectanglePosition,
2204                       (PM3RectanglePosition_XOffset(dx - x_align)) |
2205                       (PM3RectanglePosition_YOffset(dy)));
2206
2207         PM3_WRITE_REG(PM3Render2D,
2208                       ((sx > dx) ? PM3Render2D_XPositive : 0) |
2209                       ((sy > dy) ? PM3Render2D_YPositive : 0) |
2210                       PM3Render2D_Operation_Normal |
2211                       PM3Render2D_SpanOperation |
2212                       PM3Render2D_FBSourceReadEnable |
2213                       (PM3Render2D_Width(width + x_align)) |
2214                       (PM3Render2D_Height(height)));
2215
2216         pm3fb_wait_pm3(l_fb_info);
2217 }
2218
2219 static void pm3fb_cfbX_putc(struct vc_data *conp, struct display *p,
2220                             int c, int yy, int xx)
2221 {
2222         struct pm3fb_info *l_fb_info = (struct pm3fb_info *) p->fb_info;
2223         u8 *cdat, asx = 0, asy = 0, o_x = 0, o_y = 0;
2224         u32 fgx, bgx, ldat;
2225         int sx, sy, i;
2226
2227         DTRACE;
2228
2229         if (l_fb_info->current_par->depth == 8)
2230                 fgx = attr_fgcol(p, c);
2231         else if (depth2bpp(l_fb_info->current_par->depth) == 16)
2232                 fgx = ((u16 *) p->dispsw_data)[attr_fgcol(p, c)];
2233         else
2234                 fgx = ((u32 *) p->dispsw_data)[attr_fgcol(p, c)];
2235
2236         PM3_COLOR(fgx);
2237
2238         if (l_fb_info->current_par->depth == 8)
2239                 bgx = attr_bgcol(p, c);
2240         else if (depth2bpp(l_fb_info->current_par->depth) == 16)
2241                 bgx = ((u16 *) p->dispsw_data)[attr_bgcol(p, c)];
2242         else
2243                 bgx = ((u32 *) p->dispsw_data)[attr_bgcol(p, c)];
2244
2245         PM3_COLOR(bgx);
2246
2247         PM3_WAIT(4);
2248
2249         PM3_WRITE_REG(PM3Config2D,
2250                                   PM3Config2D_UseConstantSource |
2251                                   PM3Config2D_ForegroundROPEnable |
2252                                   (PM3Config2D_ForegroundROP(0x3)) |    /* Ox3 is GXcopy */
2253                                   PM3Config2D_FBWriteEnable | PM3Config2D_OpaqueSpan);
2254
2255         PM3_WRITE_REG(PM3ForegroundColor, fgx);
2256         PM3_WRITE_REG(PM3FillBackgroundColor, bgx);
2257
2258         /* WARNING : address select X need to specify 8 bits for fontwidth <= 8 */
2259         /* and 16 bits for fontwidth <= 16 */
2260         /* same in _putcs, same for Y and fontheight */
2261         if (fontwidth(p) <= 8)
2262                 asx = 2;
2263         else if (fontwidth(p) <= 16)
2264                 asx = 3;        /* look OK */
2265         if (fontheight(p) <= 8)
2266                 asy = 2;
2267         else if (fontheight(p) <= 16)
2268                 asy = 3;        /* look OK */
2269         else if (fontheight(p) <= 32)
2270                 asy = 4;        /* look OK */
2271
2272         sx = xx * fontwidth(p);
2273         sy = yy * fontheight(p);
2274
2275         if (fontwidth(p) <= 8)
2276                 o_x = (8 - (sx & 0x7)) & 0x7;
2277         else if (fontwidth(p) <= 16)
2278                 o_x = (16 - (sx & 0xF)) & 0xF;
2279         if (fontheight(p) <= 8)
2280                 o_y = (8 - (sy & 0x7)) & 0x7;
2281         else if (fontheight(p) <= 16)
2282                 o_y = (16 - (sy & 0xF)) & 0xF;
2283         else if (fontheight(p) <= 32)
2284                 o_y = (32 - (sy & 0x1F)) & 0x1F;
2285
2286         PM3_WRITE_REG(PM3AreaStippleMode, (o_x << 7) | (o_y << 12) |    /* x_offset, y_offset in pattern */
2287                       (1 << 18) |       /* BE */
2288                       1 | (asx << 1) | (asy << 4) |     /* address select x/y */
2289                       (1 << 20));       /* OpaqueSpan */
2290
2291         if (fontwidth(p) <= 8) {
2292                 cdat = p->fontdata + (c & p->charmask) * fontheight(p);
2293         } else {
2294                 cdat =
2295                     p->fontdata +
2296                     ((c & p->charmask) * (fontheight(p) << 1));
2297         }
2298
2299         PM3_WAIT(2 + fontheight(p));
2300
2301         for (i = 0; i < fontheight(p); i++) {   /* assume fontheight <= 32 */
2302                 if (fontwidth(p) <= 8) {
2303                         ldat = *cdat++;
2304                 } else {        /* assume fontwidth <= 16 ATM */
2305
2306                         ldat = ((*cdat++) << 8);
2307                         ldat |= *cdat++;
2308                 }
2309                 PM3_WRITE_REG(AreaStipplePattern_indexed(i), ldat);
2310         }
2311
2312         PM3_WRITE_REG(PM3RectanglePosition,
2313                       (PM3RectanglePosition_XOffset(sx)) |
2314                       (PM3RectanglePosition_YOffset(sy)));
2315
2316         PM3_WRITE_REG(PM3Render2D,
2317                       PM3Render2D_AreaStippleEnable |
2318                       PM3Render2D_XPositive |
2319                       PM3Render2D_YPositive |
2320                       PM3Render2D_Operation_Normal |
2321                       PM3Render2D_SpanOperation |
2322                       (PM3Render2D_Width(fontwidth(p))) |
2323                       (PM3Render2D_Height(fontheight(p))));
2324
2325         pm3fb_wait_pm3(l_fb_info);
2326 }
2327
2328 static void pm3fb_cfbX_putcs(struct vc_data *conp, struct display *p,
2329                              const unsigned short *s, int count, int yy,
2330                              int xx)
2331 {
2332         struct pm3fb_info *l_fb_info = (struct pm3fb_info *) p->fb_info;
2333         u8 *cdat, asx = 0, asy = 0, o_x = 0, o_y = 0;
2334         u32 fgx, bgx, ldat;
2335         int sx, sy, i, j;
2336         u16 sc;
2337
2338         DTRACE;
2339
2340         sc = scr_readw(s);
2341         if (l_fb_info->current_par->depth == 8)
2342                 fgx = attr_fgcol(p, sc);
2343         else if (depth2bpp(l_fb_info->current_par->depth) == 16)
2344                 fgx = ((u16 *) p->dispsw_data)[attr_fgcol(p, sc)];
2345         else
2346                 fgx = ((u32 *) p->dispsw_data)[attr_fgcol(p, sc)];
2347         
2348         PM3_COLOR(fgx);
2349         
2350         if (l_fb_info->current_par->depth == 8)
2351                 bgx = attr_bgcol(p, sc);
2352         else if (depth2bpp(l_fb_info->current_par->depth) == 16)
2353                 bgx = ((u16 *) p->dispsw_data)[attr_bgcol(p, sc)];
2354         else
2355                 bgx = ((u32 *) p->dispsw_data)[attr_bgcol(p, sc)];
2356         
2357         PM3_COLOR(bgx);
2358
2359         PM3_WAIT(4);
2360
2361         PM3_WRITE_REG(PM3Config2D,
2362                                   PM3Config2D_UseConstantSource |
2363                                   PM3Config2D_ForegroundROPEnable |
2364                                   (PM3Config2D_ForegroundROP(0x3)) |    /* Ox3 is GXcopy */
2365                                   PM3Config2D_FBWriteEnable |
2366                                   PM3Config2D_OpaqueSpan);
2367
2368         PM3_WRITE_REG(PM3ForegroundColor, fgx);
2369         PM3_WRITE_REG(PM3FillBackgroundColor, bgx);
2370
2371         /* WARNING : address select X need to specify 8 bits for fontwidth <= 8 */
2372         /* and 16 bits for fontwidth <= 16 */
2373         /* same in _putc, same for Y and fontheight */
2374         if (fontwidth(p) <= 8)
2375                 asx = 2;
2376         else if (fontwidth(p) <= 16)
2377                 asx = 3;        /* look OK */
2378         if (fontheight(p) <= 8)
2379                 asy = 2;
2380         else if (fontheight(p) <= 16)
2381                 asy = 3;        /* look OK */
2382         else if (fontheight(p) <= 32)
2383                 asy = 4;        /* look OK */
2384
2385         sy = yy * fontheight(p);
2386
2387         if (fontheight(p) <= 8)
2388                 o_y = (8 - (sy & 0x7)) & 0x7;
2389         else if (fontheight(p) <= 16)
2390                 o_y = (16 - (sy & 0xF)) & 0xF;
2391         else if (fontheight(p) <= 32)
2392                 o_y = (32 - (sy & 0x1F)) & 0x1F;
2393
2394         for (j = 0; j < count; j++) {
2395                 sc = scr_readw(s + j);
2396                 if (fontwidth(p) <= 8)
2397                         cdat = p->fontdata +
2398                                 (sc & p->charmask) * fontheight(p);
2399                 else
2400                         cdat = p->fontdata +
2401                                 ((sc & p->charmask) * fontheight(p) << 1);
2402                 
2403                 sx = (xx + j) * fontwidth(p);
2404
2405                 if (fontwidth(p) <= 8)
2406                         o_x = (8 - (sx & 0x7)) & 0x7;
2407                 else if (fontwidth(p) <= 16)
2408                         o_x = (16 - (sx & 0xF)) & 0xF;
2409
2410                 PM3_WAIT(3 + fontheight(p));
2411
2412                 PM3_WRITE_REG(PM3AreaStippleMode, (o_x << 7) | (o_y << 12) | /* x_offset, y_offset in pattern */
2413                               (1 << 18) | /* BE */
2414                               1 | (asx << 1) | (asy << 4) | /* address select x/y */
2415                               (1 << 20)); /* OpaqueSpan */
2416
2417                 for (i = 0; i < fontheight(p); i++) { /* assume fontheight <= 32 */
2418                         if (fontwidth(p) <= 8) {
2419                                 ldat = *cdat++;
2420                         } else { /* assume fontwidth <= 16 ATM */
2421                                 ldat = ((*cdat++) << 8);
2422                                 ldat |= *cdat++;
2423                         }
2424                         PM3_WRITE_REG(AreaStipplePattern_indexed(i), ldat);
2425                 }
2426
2427                 PM3_WRITE_REG(PM3RectanglePosition,
2428                               (PM3RectanglePosition_XOffset(sx)) |
2429                               (PM3RectanglePosition_YOffset(sy)));
2430
2431                 PM3_WRITE_REG(PM3Render2D,
2432                               PM3Render2D_AreaStippleEnable |
2433                               PM3Render2D_XPositive |
2434                               PM3Render2D_YPositive |
2435                               PM3Render2D_Operation_Normal |
2436                               PM3Render2D_SpanOperation |
2437                               (PM3Render2D_Width(fontwidth(p))) |
2438                               (PM3Render2D_Height(fontheight(p))));
2439         }
2440         pm3fb_wait_pm3(l_fb_info);
2441 }
2442
2443 static void pm3fb_cfbX_revc(struct display *p, int xx, int yy)
2444 {
2445         struct pm3fb_info *l_fb_info = (struct pm3fb_info *) p->fb_info;
2446
2447         xx = xx * fontwidth(p);
2448         yy = yy * fontheight(p);
2449
2450         if (l_fb_info->current_par->depth == 8)
2451         {
2452                 if (l_fb_info->memt.caps & PM3LocalMemCaps_NoWriteMask)
2453                         PM3_SLOW_WRITE_REG(PM3FBSoftwareWriteMask, 0x0F0F0F0F);
2454                 else
2455                         PM3_SLOW_WRITE_REG(PM3FBHardwareWriteMask, 0x0F0F0F0F);
2456         }
2457
2458         PM3_WAIT(3);
2459
2460         PM3_WRITE_REG(PM3Config2D,
2461                                   PM3Config2D_UseConstantSource |
2462                                   PM3Config2D_ForegroundROPEnable |
2463                                   (PM3Config2D_ForegroundROP(0xa)) |    /* Oxa is GXinvert */
2464                                   PM3Config2D_FBDestReadEnable |
2465                                   PM3Config2D_FBWriteEnable);
2466
2467         PM3_WRITE_REG(PM3RectanglePosition,
2468                       (PM3RectanglePosition_XOffset(xx)) |
2469                       (PM3RectanglePosition_YOffset(yy)));
2470
2471         PM3_WRITE_REG(PM3Render2D,
2472                       PM3Render2D_XPositive |
2473                       PM3Render2D_YPositive |
2474                       PM3Render2D_Operation_Normal |
2475                       PM3Render2D_SpanOperation |
2476                       (PM3Render2D_Width(fontwidth(p))) |
2477                       (PM3Render2D_Height(fontheight(p))));
2478
2479         pm3fb_wait_pm3(l_fb_info);
2480
2481         if (l_fb_info->current_par->depth == 8)
2482         {
2483                 if (l_fb_info->memt.caps & PM3LocalMemCaps_NoWriteMask)
2484                         PM3_SLOW_WRITE_REG(PM3FBSoftwareWriteMask, 0xFFFFFFFF);
2485                 else
2486                         PM3_SLOW_WRITE_REG(PM3FBHardwareWriteMask, 0xFFFFFFFF);
2487         }
2488 }
2489
2490 #endif /* FBCON_HAS_CFB8 || FBCON_HAS_CFB16 || FBCON_HAS_CFB32 */
2491 #endif /* PM3FB_USE_ACCEL */
2492 /* *********************************** */
2493 /* ***** pre-init board(s) setup ***** */
2494 /* *********************************** */
2495
2496 static void pm3fb_mode_setup(char *mode, unsigned long board_num)
2497 {
2498         struct pm3fb_info *l_fb_info = &(fb_info[board_num]);
2499         struct pm3fb_par *l_fb_par = &(current_par[board_num]);
2500         unsigned long i = 0;
2501
2502         current_par_valid[board_num] = 0;
2503
2504         if (!strncmp(mode, "current", 7)) {
2505                 l_fb_info->use_current = 1;     /* default w/ OpenFirmware */
2506         } else {
2507                 while ((mode_base[i].name[0])
2508                        && (!current_par_valid[board_num])) {
2509                         if (!
2510                             (strncmp
2511                              (mode, mode_base[i].name,
2512                               strlen(mode_base[i].name)))) {
2513                                 memcpy(l_fb_par, &(mode_base[i].user_mode),
2514                                        sizeof(struct pm3fb_par));
2515                                 current_par_valid[board_num] = 1;
2516                                 DPRINTK(2, "Mode set to %s\n",
2517                                         mode_base[i].name);
2518                         }
2519                         i++;
2520                 }
2521                 DASSERT(current_par_valid[board_num],
2522                         "Valid mode on command line\n");
2523         }
2524 }
2525
2526 static void pm3fb_pciid_setup(char *pciid, unsigned long board_num)
2527 {
2528         short l_bus = -1, l_slot = -1, l_func = -1;
2529         char *next;
2530
2531         if (pciid) {
2532                 l_bus = simple_strtoul(pciid, &next, 10);
2533                 if (next && (next[0] == ':')) {
2534                         pciid = next + 1;
2535                         l_slot = simple_strtoul(pciid, &next, 10);
2536                         if (next && (next[0] == ':')) {
2537                                 pciid = next + 1;
2538                                 l_func =
2539                                     simple_strtoul(pciid, (char **) NULL,
2540                                                    10);
2541                         }
2542                 }
2543         } else
2544                 return;
2545
2546         if ((l_bus >= 0) && (l_slot >= 0) && (l_func >= 0)) {
2547                 bus[board_num] = l_bus;
2548                 slot[board_num] = l_slot;
2549                 func[board_num] = l_func;
2550                 DPRINTK(2, "Board #%ld will be PciId: %hd:%hd:%hd\n",
2551                         board_num, l_bus, l_slot, l_func);
2552         } else {
2553                 DPRINTK(1, "Invalid PciId: %hd:%hd:%hd for board #%ld\n",
2554                         l_bus, l_slot, l_func, board_num);
2555         }
2556 }
2557
2558 static void pm3fb_font_setup(char *lf, unsigned long board_num)
2559 {
2560         unsigned long lfs = strlen(lf);
2561
2562         if (lfs > (PM3_FONTNAME_SIZE - 1)) {
2563                 DPRINTK(1, "Fontname %s too long\n", lf);
2564                 return;
2565         }
2566         strlcpy(fontn[board_num], lf, lfs + 1);
2567 }
2568
2569 static void pm3fb_bootdepth_setup(char *bds, unsigned long board_num)
2570 {
2571         unsigned long bd = simple_strtoul(bds, (char **) NULL, 10);
2572
2573         if (!(depth_supported(bd))) {
2574                 printk(KERN_WARNING "pm3fb: ignoring invalid depth %s for board #%ld\n",
2575                        bds, board_num);
2576                 return;
2577         }
2578         depth[board_num] = bd;
2579 }
2580
2581 static void pm3fb_forcesize_setup(char *bds, unsigned long board_num)
2582 {
2583         unsigned long bd = simple_strtoul(bds, (char **) NULL, 10);
2584
2585         if (bd > 64) {
2586                 printk(KERN_WARNING "pm3fb: ignoring invalid memory size %s for board #%ld\n",
2587                        bds, board_num);
2588                 return;
2589         }
2590         forcesize[board_num] = bd;
2591 }
2592
2593 static char *pm3fb_boardnum_setup(char *options, unsigned long *bn)
2594 {
2595         char *next;
2596
2597         if (!(CHAR_IS_NUM(options[0]))) {
2598                 (*bn) = 0;
2599                 return (options);
2600         }
2601
2602         (*bn) = simple_strtoul(options, &next, 10);
2603
2604         if (next && (next[0] == ':') && ((*bn) >= 0)
2605             && ((*bn) <= PM3_MAX_BOARD)) {
2606                 DPRINTK(2, "Board_num seen as %ld\n", (*bn));
2607                 return (next + 1);
2608         } else {
2609                 (*bn) = 0;
2610                 DPRINTK(2, "Board_num default to %ld\n", (*bn));
2611                 return (options);
2612         }
2613 }
2614
2615 static void pm3fb_real_setup(char *options)
2616 {
2617         char *next;
2618         unsigned long i, bn;
2619         struct pm3fb_info *l_fb_info;
2620
2621         DTRACE;
2622
2623         DPRINTK(2, "Options : %s\n", options);
2624
2625         for (i = 0; i < PM3_MAX_BOARD; i++) {
2626                 l_fb_info = &(fb_info[i]);
2627                 memset(l_fb_info, 0, sizeof(struct pm3fb_info));
2628                 l_fb_info->gen.fbhw = &pm3fb_switch;
2629                 l_fb_info->board_num = i;
2630                 current_par_valid[i] = 0;
2631                 slot[i] = -1;
2632                 func[i] = -1;
2633                 bus[i] = -1;
2634                 disable[i] = 0;
2635                 noaccel[i] = 0;
2636                 fontn[i][0] = '\0';
2637                 depth[i] = 0;
2638                 l_fb_info->current_par = &(current_par[i]);
2639         }
2640
2641         /* eat up prefix pm3fb and whatever is used as separator i.e. :,= */
2642         if (!strncmp(options, "pm3fb", 5)) {
2643                 options += 5;
2644                 while (((*options) == ',') || ((*options) == ':')
2645                        || ((*options) == '='))
2646                         options++;
2647         }
2648
2649         while (options) {
2650                 bn = 0;
2651                 if ((next = strchr(options, ','))) {
2652                         (*next) = '\0';
2653                         next++;
2654                 }
2655
2656                 if (!strncmp(options, "mode:", 5)) {
2657                         options = pm3fb_boardnum_setup(options + 5, &bn);
2658                         DPRINTK(2, "Setting mode for board #%ld\n", bn);
2659                         pm3fb_mode_setup(options, bn);
2660                 } else if (!strncmp(options, "off:", 4)) {
2661                         options = pm3fb_boardnum_setup(options + 4, &bn);
2662                         DPRINTK(2, "Disabling board #%ld\n", bn);
2663                         disable[bn] = 1;
2664                 } else if (!strncmp(options, "off", 3)) {       /* disable everything */
2665                         for (i = 0; i < PM3_MAX_BOARD; i++)
2666                                 disable[i] = 1;
2667                 } else if (!strncmp(options, "disable:", 8)) {
2668                         options = pm3fb_boardnum_setup(options + 8, &bn);
2669                         DPRINTK(2, "Disabling board #%ld\n", bn);
2670                         disable[bn] = 1;
2671                 } else if (!strncmp(options, "pciid:", 6)) {
2672                         options = pm3fb_boardnum_setup(options + 6, &bn);
2673                         DPRINTK(2, "Setting PciID for board #%ld\n", bn);
2674                         pm3fb_pciid_setup(options, bn);
2675                 } else if (!strncmp(options, "noaccel:", 8)) {
2676                         options = pm3fb_boardnum_setup(options + 8, &bn);
2677                         noaccel[bn] = 1;
2678                 } else if (!strncmp(options, "font:", 5)) {
2679                         options = pm3fb_boardnum_setup(options + 5, &bn);
2680                         pm3fb_font_setup(options, bn);
2681                 } else if (!strncmp(options, "depth:", 6)) {
2682                         options = pm3fb_boardnum_setup(options + 6, &bn);
2683                         pm3fb_bootdepth_setup(options, bn);
2684                 } else if (!strncmp(options, "printtimings", 12)) {
2685                         printtimings = 1;
2686                 } else if (!strncmp(options, "flatpanel:", 10)) {
2687                         options = pm3fb_boardnum_setup(options + 10, &bn);
2688                         flatpanel[bn] = 1;
2689                 } else if (!strncmp(options, "forcesize:", 10)) {
2690                         options = pm3fb_boardnum_setup(options + 10, &bn);
2691                         pm3fb_forcesize_setup(options, bn);
2692                 }
2693                 options = next;
2694         }
2695 }
2696
2697 /* ********************************************** */
2698 /* ***** framebuffer API standard functions ***** */
2699 /* ********************************************** */
2700
2701 static int pm3fb_encode_fix(struct fb_fix_screeninfo *fix,
2702                             const void *par, struct fb_info_gen *info)
2703 {
2704         struct pm3fb_info *l_fb_info = (struct pm3fb_info *) info;
2705         struct pm3fb_par *p = (struct pm3fb_par *) par;
2706
2707         DTRACE;
2708
2709         strcpy(fix->id, permedia3_name);
2710         fix->smem_start = (unsigned long)l_fb_info->p_fb;
2711         fix->smem_len = l_fb_info->fb_size;
2712         fix->mmio_start = (unsigned long)l_fb_info->pIOBase;
2713         fix->mmio_len = PM3_REGS_SIZE;
2714 #ifdef PM3FB_USE_ACCEL
2715         if (!(noaccel[l_fb_info->board_num]))
2716                 fix->accel = FB_ACCEL_3DLABS_PERMEDIA3;
2717         else
2718 #endif /* PM3FB_USE_ACCEL */
2719                 fix->accel = FB_ACCEL_NONE;
2720         fix->type = FB_TYPE_PACKED_PIXELS;
2721         fix->visual =
2722             (p->depth == 8) ? FB_VISUAL_PSEUDOCOLOR : FB_VISUAL_TRUECOLOR;
2723         if (current_par_valid[l_fb_info->board_num])
2724                 fix->line_length =
2725                         l_fb_info->current_par->width *
2726                         depth2ByPP(l_fb_info->current_par->depth);
2727         else
2728                 fix->line_length = 0;
2729         fix->xpanstep = 64 / depth2bpp(p->depth);
2730         fix->ypanstep = 1;
2731         fix->ywrapstep = 0;
2732         return (0);
2733 }
2734
2735 static int pm3fb_decode_var(const struct fb_var_screeninfo *var,
2736                             void *par, struct fb_info_gen *info)
2737 {
2738         struct pm3fb_info *l_fb_info = (struct pm3fb_info *) info;
2739         struct pm3fb_par *p = (struct pm3fb_par *) par;
2740         struct pm3fb_par temp_p;
2741         u32 xres;
2742
2743         DTRACE;
2744
2745         DASSERT((var != NULL), "fb_var_screeninfo* not NULL");
2746         DASSERT((p != NULL), "pm3fb_par* not NULL");
2747         DASSERT((l_fb_info != NULL), "pm3fb_info* not NULL");
2748
2749         memset(&temp_p, 0, sizeof(struct pm3fb_par));
2750         temp_p.width = (var->xres_virtual + 7) & ~7;
2751         temp_p.height = var->yres_virtual;
2752
2753         if (!(depth_supported(var->bits_per_pixel))) /* round unsupported up to a multiple of 8 */
2754                 temp_p.depth = depth2bpp(var->bits_per_pixel);
2755         else
2756                 temp_p.depth = var->bits_per_pixel;
2757
2758         temp_p.depth = (temp_p.depth > 32) ? 32 : temp_p.depth; /* max 32 */
2759         temp_p.depth = (temp_p.depth == 24) ? 32 : temp_p.depth; /* 24 unsupported, round-up to 32 */
2760
2761         if ((temp_p.depth == 16) && (var->red.length == 5) && (var->green.length == 5) && (var->blue.length == 5))
2762                 temp_p.depth = 15; /* RGBA 5551 is stored as depth 15 */
2763
2764         if ((temp_p.depth == 16) && (var->red.length == 4) && (var->green.length == 4) && (var->blue.length == 4))
2765                 temp_p.depth = 12; /* RGBA 4444  is stored as depth 12 */
2766
2767
2768         DPRINTK(2,
2769                 "xres: %d, yres: %d, vxres: %d, vyres: %d ; xoffset:%d, yoffset: %d\n",
2770                 var->xres, var->yres, var->xres_virtual, var->yres_virtual,
2771                 var->xoffset, var->yoffset);
2772
2773         xres = (var->xres + 31) & ~31;
2774         if (temp_p.width < xres + var->xoffset)
2775                 temp_p.width = xres + var->xoffset;
2776         if (temp_p.height < var->yres + var->yoffset)
2777                 temp_p.height = var->yres + var->yoffset;
2778
2779         if (temp_p.width > 2048) {
2780                 DPRINTK(1, "virtual width not supported: %u\n",
2781                         temp_p.width);
2782                 return (-EINVAL);
2783         }
2784         if (var->yres < 200) {
2785                 DPRINTK(1, "height not supported: %u\n", (u32) var->yres);
2786                 return (-EINVAL);
2787         }
2788         if (temp_p.height < 200 || temp_p.height > 4095) {
2789                 DPRINTK(1, "virtual height not supported: %u\n",
2790                         temp_p.height);
2791                 return (-EINVAL);
2792         }
2793         if (!(depth_supported(temp_p.depth))) {
2794                 DPRINTK(1, "depth not supported: %u\n", temp_p.depth);
2795                 return (-EINVAL);
2796         }
2797         if ((temp_p.width * temp_p.height * depth2ByPP(temp_p.depth)) >
2798             l_fb_info->fb_size) {
2799                 DPRINTK(1, "no memory for screen (%ux%ux%u)\n",
2800                         temp_p.width, temp_p.height, temp_p.depth);
2801                 return (-EINVAL);
2802         }
2803
2804         if ((!var->pixclock) ||
2805             (!var->right_margin) ||
2806             (!var->hsync_len) ||
2807             (!var->left_margin) ||
2808             (!var->lower_margin) ||
2809             (!var->vsync_len) || (!var->upper_margin)
2810             ) {
2811                 unsigned long i = 0, done = 0;
2812                 printk(KERN_WARNING "pm3fb: refusing to use a likely wrong timing\n");
2813
2814                 while ((mode_base[i].user_mode.width) && !done) {
2815                         if ((mode_base[i].user_mode.width == temp_p.width)
2816                             && (mode_base[i].user_mode.height ==
2817                                 temp_p.height)) {
2818                                 printk(KERN_NOTICE "pm3fb: using close match %s\n",
2819                                        mode_base[i].name);
2820                                 temp_p = mode_base[i].user_mode;
2821                                 done = 1;
2822                         }
2823                         i++;
2824                 }
2825                 if (!done)
2826                         return (-EINVAL);
2827         } else {
2828                 temp_p.pixclock = PICOS2KHZ(var->pixclock);
2829                 if (temp_p.pixclock > PM3_MAX_PIXCLOCK) {
2830                         DPRINTK(1, "pixclock too high (%uKHz)\n",
2831                                 temp_p.pixclock);
2832                         return (-EINVAL);
2833                 }
2834
2835                 temp_p.hsstart = var->right_margin;
2836                 temp_p.hsend = var->right_margin + var->hsync_len;
2837                 temp_p.hbend =
2838                     var->right_margin + var->hsync_len + var->left_margin;
2839                 temp_p.htotal = xres + temp_p.hbend;
2840
2841                 temp_p.vsstart = var->lower_margin;
2842                 temp_p.vsend = var->lower_margin + var->vsync_len;
2843                 temp_p.vbend =
2844                     var->lower_margin + var->vsync_len + var->upper_margin;
2845                 temp_p.vtotal = var->yres + temp_p.vbend;
2846
2847                 temp_p.stride = temp_p.width;
2848
2849                 DPRINTK(2, "Using %d * %d, %d Khz, stride is %08x\n",
2850                         temp_p.width, temp_p.height, temp_p.pixclock,
2851                         temp_p.stride);
2852
2853                 temp_p.base =
2854                     pm3fb_Shiftbpp(l_fb_info, temp_p.depth,
2855                                    (var->yoffset * xres) + var->xoffset);
2856
2857                 temp_p.video = 0;
2858
2859                 if (var->sync & FB_SYNC_HOR_HIGH_ACT)
2860                         temp_p.video |= PM3VideoControl_HSYNC_ACTIVE_HIGH;
2861                 else
2862                         temp_p.video |= PM3VideoControl_HSYNC_ACTIVE_LOW;
2863
2864                 if (var->sync & FB_SYNC_VERT_HIGH_ACT)
2865                         temp_p.video |= PM3VideoControl_VSYNC_ACTIVE_HIGH;
2866                 else
2867                         temp_p.video |= PM3VideoControl_VSYNC_ACTIVE_LOW;
2868
2869                 if ((var->vmode & FB_VMODE_MASK) == FB_VMODE_INTERLACED) {
2870                         DPRINTK(1, "Interlaced mode not supported\n\n");
2871                         return (-EINVAL);
2872                 }
2873
2874                 if ((var->vmode & FB_VMODE_MASK) == FB_VMODE_DOUBLE)
2875                         temp_p.video |= PM3VideoControl_LINE_DOUBLE_ON;
2876                 else
2877                         temp_p.video |= PM3VideoControl_LINE_DOUBLE_OFF;
2878
2879                 if (var->activate == FB_ACTIVATE_NOW)
2880                         temp_p.video |= PM3VideoControl_ENABLE;
2881                 else {
2882                         temp_p.video |= PM3VideoControl_DISABLE;
2883                         DPRINTK(2, "PM3Video disabled\n");
2884                 }
2885
2886                 switch (temp_p.depth) {
2887                 case 8:
2888                         temp_p.video |= PM3VideoControl_PIXELSIZE_8BIT;
2889                         break;
2890                 case 12:
2891                 case 15:
2892                 case 16:
2893                         temp_p.video |= PM3VideoControl_PIXELSIZE_16BIT;
2894                         break;
2895                 case 32:
2896                         temp_p.video |= PM3VideoControl_PIXELSIZE_32BIT;
2897                         break;
2898                 default:
2899                         DPRINTK(1, "Unsupported depth\n");
2900                         break;
2901                 }
2902         }
2903         (*p) = temp_p;
2904
2905 #ifdef PM3FB_USE_ACCEL
2906         if (var->accel_flags & FB_ACCELF_TEXT)
2907                 noaccel[l_fb_info->board_num] = 0;
2908         else
2909                 noaccel[l_fb_info->board_num] = 1;
2910 #endif /* PM3FB_USE_ACCEL */
2911
2912         return (0);
2913 }
2914
2915 static void pm3fb_encode_depth(struct fb_var_screeninfo *var, long d)
2916 {
2917         switch (d) {
2918         case 8:
2919                 var->red.length = var->green.length = var->blue.length = 8;
2920                 var->red.offset = var->green.offset = var->blue.offset = 0;
2921                 var->transp.offset = var->transp.length = 0;
2922                 break;
2923
2924         case 12:
2925                 var->red.offset = 8;
2926                 var->red.length = 4;
2927                 var->green.offset = 4;
2928                 var->green.length = 4;
2929                 var->blue.offset = 0;
2930                 var->blue.length = 4;
2931                 var->transp.offset = 12;
2932                 var->transp.length = 4;
2933                 break;
2934
2935         case 15:
2936                 var->red.offset = 10;
2937                 var->red.length = 5;
2938                 var->green.offset = 5;
2939                 var->green.length = 5;
2940                 var->blue.offset = 0;
2941                 var->blue.length = 5;
2942                 var->transp.offset = 15;
2943                 var->transp.length = 1;
2944                 break;
2945
2946         case 16:
2947                 var->red.offset = 11;
2948                 var->red.length = 5;
2949                 var->green.offset = 5;
2950                 var->green.length = 6;
2951                 var->blue.offset = 0;
2952                 var->blue.length = 5;
2953                 var->transp.offset = var->transp.length = 0;
2954                 break;
2955
2956         case 32:
2957                 var->transp.offset = 24;
2958                 var->red.offset = 16;
2959                 var->green.offset = 8;
2960                 var->blue.offset = 0;
2961                 var->red.length = var->green.length =
2962                         var->blue.length = var->transp.length = 8;
2963                 break;
2964
2965         default:
2966                 DPRINTK(1, "Unsupported depth %ld\n", d);
2967                 break;
2968         }
2969 }
2970
2971 static int pm3fb_encode_var(struct fb_var_screeninfo *var,
2972                             const void *par, struct fb_info_gen *info)
2973 {
2974         struct pm3fb_par *p = (struct pm3fb_par *) par;
2975         struct pm3fb_info *l_fb_info = (struct pm3fb_info *) info;
2976
2977         u32 base;
2978
2979         DTRACE;
2980
2981         DASSERT((var != NULL), "fb_var_screeninfo* not NULL");
2982         DASSERT((p != NULL), "pm3fb_par* not NULL");
2983         DASSERT((info != NULL), "fb_info_gen* not NULL");
2984
2985         memset(var, 0, sizeof(struct fb_var_screeninfo));
2986
2987 #ifdef PM3FB_USE_ACCEL
2988         if (!(noaccel[l_fb_info->board_num]))
2989                 var->accel_flags |= FB_ACCELF_TEXT;
2990 #endif /* PM3FB_USE_ACCEL */
2991
2992         var->xres_virtual = p->width;
2993         var->yres_virtual = p->height;
2994         var->xres = p->htotal - p->hbend;
2995         var->yres = p->vtotal - p->vbend;
2996
2997         DPRINTK(2, "xres = %d, yres : %d\n", var->xres, var->yres);
2998
2999         var->right_margin = p->hsstart;
3000         var->hsync_len = p->hsend - p->hsstart;
3001         var->left_margin = p->hbend - p->hsend;
3002         var->lower_margin = p->vsstart;
3003         var->vsync_len = p->vsend - p->vsstart;
3004         var->upper_margin = p->vbend - p->vsend;
3005         var->bits_per_pixel = depth2bpp(p->depth);
3006         
3007         pm3fb_encode_depth(var, p->depth);
3008
3009         base = pm3fb_Unshiftbpp(l_fb_info, p->depth, p->base);
3010
3011         var->xoffset = base % var->xres;
3012         var->yoffset = base / var->xres;
3013
3014         var->height = var->width = -1;
3015
3016         var->pixclock = KHZ2PICOS(p->pixclock);
3017
3018         if ((p->video & PM3VideoControl_HSYNC_MASK) ==
3019             PM3VideoControl_HSYNC_ACTIVE_HIGH)
3020                 var->sync |= FB_SYNC_HOR_HIGH_ACT;
3021         if ((p->video & PM3VideoControl_VSYNC_MASK) ==
3022             PM3VideoControl_VSYNC_ACTIVE_HIGH)
3023                 var->sync |= FB_SYNC_VERT_HIGH_ACT;
3024         if (p->video & PM3VideoControl_LINE_DOUBLE_ON)
3025                 var->vmode = FB_VMODE_DOUBLE;
3026
3027         return (0);
3028 }
3029
3030 static void pm3fb_get_par(void *par, struct fb_info_gen *info)
3031 {
3032         struct pm3fb_info *l_fb_info = (struct pm3fb_info *) info;
3033
3034         DTRACE;
3035
3036         if (!current_par_valid[l_fb_info->board_num]) {
3037                 if (l_fb_info->use_current)
3038                         pm3fb_read_mode(l_fb_info, l_fb_info->current_par);
3039                 else
3040                         memcpy(l_fb_info->current_par,
3041                                &(mode_base[0].user_mode),
3042                                sizeof(struct pm3fb_par));
3043                 current_par_valid[l_fb_info->board_num] = 1;
3044         }
3045         *((struct pm3fb_par *) par) = *(l_fb_info->current_par);
3046 }
3047
3048 static void pm3fb_set_par(const void *par, struct fb_info_gen *info)
3049 {
3050         struct pm3fb_info *l_fb_info = (struct pm3fb_info *) info;
3051
3052         DTRACE;
3053
3054         *(l_fb_info->current_par) = *((struct pm3fb_par *) par);
3055         current_par_valid[l_fb_info->board_num] = 1;
3056
3057         pm3fb_write_mode(l_fb_info);
3058
3059 #ifdef PM3FB_USE_ACCEL
3060         pm3fb_init_engine(l_fb_info);
3061 #endif /* PM3FB_USE_ACCEL */
3062 }
3063
3064 static void pm3fb_set_color(struct pm3fb_info *l_fb_info,
3065                             unsigned char regno, unsigned char r,
3066                             unsigned char g, unsigned char b)
3067 {
3068         DTRACE;