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