projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[PATCH] gx1fb: (try to) play nicer with various BIOSes
[deliverable/linux.git] / drivers / video / matrox / matroxfb_base.c
CommitLineData
1da177e4
LT		 1/*
2 *
3 * Hardware accelerated Matrox Millennium I, II, Mystique, G100, G200 and G400
4 *
5 * (c) 1998-2002 Petr Vandrovec <vandrove@vc.cvut.cz>
6 *
7 * Portions Copyright (c) 2001 Matrox Graphics Inc.
8 *
9 * Version: 1.65 2002/08/14
10 *
11 * MTRR stuff: 1998 Tom Rini <trini@kernel.crashing.org>
12 *
13 * Contributors: "menion?" <menion@mindless.com>
14 * Betatesting, fixes, ideas
15 *
16 * "Kurt Garloff" <garloff@suse.de>
17 * Betatesting, fixes, ideas, videomodes, videomodes timmings
18 *
19 * "Tom Rini" <trini@kernel.crashing.org>
20 * MTRR stuff, PPC cleanups, betatesting, fixes, ideas
21 *
22 * "Bibek Sahu" <scorpio@dodds.net>
23 * Access device through readb|w|l and write b|w|l
24 * Extensive debugging stuff
25 *
26 * "Daniel Haun" <haund@usa.net>
27 * Testing, hardware cursor fixes
28 *
29 * "Scott Wood" <sawst46+@pitt.edu>
30 * Fixes
31 *
32 * "Gerd Knorr" <kraxel@goldbach.isdn.cs.tu-berlin.de>
33 * Betatesting
34 *
35 * "Kelly French" <targon@hazmat.com>
36 * "Fernando Herrera" <fherrera@eurielec.etsit.upm.es>
37 * Betatesting, bug reporting
38 *
39 * "Pablo Bianucci" <pbian@pccp.com.ar>
40 * Fixes, ideas, betatesting
41 *
42 * "Inaky Perez Gonzalez" <inaky@peloncho.fis.ucm.es>
43 * Fixes, enhandcements, ideas, betatesting
44 *
45 * "Ryuichi Oikawa" <roikawa@rr.iiij4u.or.jp>
46 * PPC betatesting, PPC support, backward compatibility
47 *
48 * "Paul Womar" <Paul@pwomar.demon.co.uk>
49 * "Owen Waller" <O.Waller@ee.qub.ac.uk>
50 * PPC betatesting
51 *
52 * "Thomas Pornin" <pornin@bolet.ens.fr>
53 * Alpha betatesting
54 *
55 * "Pieter van Leuven" <pvl@iae.nl>
56 * "Ulf Jaenicke-Roessler" <ujr@physik.phy.tu-dresden.de>
57 * G100 testing
58 *
59 * "H. Peter Arvin" <hpa@transmeta.com>
60 * Ideas
61 *
62 * "Cort Dougan" <cort@cs.nmt.edu>
63 * CHRP fixes and PReP cleanup
64 *
65 * "Mark Vojkovich" <mvojkovi@ucsd.edu>
66 * G400 support
67 *
68 * "Samuel Hocevar" <sam@via.ecp.fr>
69 * Fixes
70 *
71 * "Anton Altaparmakov" <AntonA@bigfoot.com>
72 * G400 MAX/non-MAX distinction
73 *
74 * "Ken Aaker" <kdaaker@rchland.vnet.ibm.com>
75 * memtype extension (needed for GXT130P RS/6000 adapter)
76 *
77 * "Uns Lider" <unslider@miranda.org>
78 * G100 PLNWT fixes
79 *
80 * "Denis Zaitsev" <zzz@cd-club.ru>
81 * Fixes
82 *
83 * "Mike Pieper" <mike@pieper-family.de>
84 * TVOut enhandcements, V4L2 control interface.
85 *
86 * "Diego Biurrun" <diego@biurrun.de>
87 * DFP testing
88 *
89 * (following author is not in any relation with this code, but his code
90 * is included in this driver)
91 *
92 * Based on framebuffer driver for VBE 2.0 compliant graphic boards
93 * (c) 1998 Gerd Knorr <kraxel@cs.tu-berlin.de>
94 *
95 * (following author is not in any relation with this code, but his ideas
96 * were used when writting this driver)
97 *
98 * FreeVBE/AF (Matrox), "Shawn Hargreaves" <shawn@talula.demon.co.uk>
99 *
100 */
101
102/* make checkconfig does not check included files... */
103#include <linux/config.h>
104#include <linux/version.h>
105
106#include "matroxfb_base.h"
107#include "matroxfb_misc.h"
108#include "matroxfb_accel.h"
109#include "matroxfb_DAC1064.h"
110#include "matroxfb_Ti3026.h"
111#include "matroxfb_maven.h"
112#include "matroxfb_crtc2.h"
113#include "matroxfb_g450.h"
114#include <linux/matroxfb.h>
115#include <linux/interrupt.h>
116#include <asm/uaccess.h>
117
118#ifdef CONFIG_PPC_PMAC
119unsigned char nvram_read_byte(int);
120static int default_vmode = VMODE_NVRAM;
121static int default_cmode = CMODE_NVRAM;
122#endif
123
124static void matroxfb_unregister_device(struct matrox_fb_info* minfo);
125
126/* --------------------------------------------------------------------- */
127
128/*
129 * card parameters
130 */
131
132/* --------------------------------------------------------------------- */
133
134static struct fb_var_screeninfo vesafb_defined = {
135 640,480,640,480,/* W,H, W, H (virtual) load xres,xres_virtual*/
136 0,0, /* virtual -> visible no offset */
137 8, /* depth -> load bits_per_pixel */
138 0, /* greyscale ? */
139 {0,0,0}, /* R */
140 {0,0,0}, /* G */
141 {0,0,0}, /* B */
142 {0,0,0}, /* transparency */
143 0, /* standard pixel format */
144 FB_ACTIVATE_NOW,
145 -1,-1,
146 FB_ACCELF_TEXT, /* accel flags */
147 39721L,48L,16L,33L,10L,
148 96L,2L,~0, /* No sync info */
149 FB_VMODE_NONINTERLACED,
150 0, {0,0,0,0,0}
151};
152
153
154
155/* --------------------------------------------------------------------- */
156static void update_crtc2(WPMINFO unsigned int pos) {
157 struct matroxfb_dh_fb_info* info = ACCESS_FBINFO(crtc2.info);
158
159 /* Make sure that displays are compatible */
160 if (info && (info->fbcon.var.bits_per_pixel == ACCESS_FBINFO(fbcon).var.bits_per_pixel)
161 && (info->fbcon.var.xres_virtual == ACCESS_FBINFO(fbcon).var.xres_virtual)
162 && (info->fbcon.var.green.length == ACCESS_FBINFO(fbcon).var.green.length)
163 ) {
164 switch (ACCESS_FBINFO(fbcon).var.bits_per_pixel) {
165 case 16:
166 case 32:
167 pos = pos * 8;
168 if (info->interlaced) {
169 mga_outl(0x3C2C, pos);
170 mga_outl(0x3C28, pos + ACCESS_FBINFO(fbcon).var.xres_virtual * ACCESS_FBINFO(fbcon).var.bits_per_pixel / 8);
171 } else {
172 mga_outl(0x3C28, pos);
173 }
174 break;
175 }
176 }
177}
178
179static void matroxfb_crtc1_panpos(WPMINFO2) {
180 if (ACCESS_FBINFO(crtc1.panpos) >= 0) {
181 unsigned long flags;
182 int panpos;
183
184 matroxfb_DAC_lock_irqsave(flags);
185 panpos = ACCESS_FBINFO(crtc1.panpos);
186 if (panpos >= 0) {
187 unsigned int extvga_reg;
188
189 ACCESS_FBINFO(crtc1.panpos) = -1; /* No update pending anymore */
190 extvga_reg = mga_inb(M_EXTVGA_INDEX);
191 mga_setr(M_EXTVGA_INDEX, 0x00, panpos);
192 if (extvga_reg != 0x00) {
193 mga_outb(M_EXTVGA_INDEX, extvga_reg);
194 }
195 }
196 matroxfb_DAC_unlock_irqrestore(flags);
197 }
198}
199
200static irqreturn_t matrox_irq(int irq, void *dev_id, struct pt_regs *fp)
201{
202 u_int32_t status;
203 int handled = 0;
204
205 MINFO_FROM(dev_id);
206
207 status = mga_inl(M_STATUS);
208
209 if (status & 0x20) {
210 mga_outl(M_ICLEAR, 0x20);
211 ACCESS_FBINFO(crtc1.vsync.cnt)++;
212 matroxfb_crtc1_panpos(PMINFO2);
213 wake_up_interruptible(&ACCESS_FBINFO(crtc1.vsync.wait));
214 handled = 1;
215 }
216 if (status & 0x200) {
217 mga_outl(M_ICLEAR, 0x200);
218 ACCESS_FBINFO(crtc2.vsync.cnt)++;
219 wake_up_interruptible(&ACCESS_FBINFO(crtc2.vsync.wait));
220 handled = 1;
221 }
222 return IRQ_RETVAL(handled);
223}
224
225int matroxfb_enable_irq(WPMINFO int reenable) {
226 u_int32_t bm;
227
228 if (ACCESS_FBINFO(devflags.accelerator) == FB_ACCEL_MATROX_MGAG400)
229 bm = 0x220;
230 else
231 bm = 0x020;
232
233 if (!test_and_set_bit(0, &ACCESS_FBINFO(irq_flags))) {
234 if (request_irq(ACCESS_FBINFO(pcidev)->irq, matrox_irq,
235 SA_SHIRQ, "matroxfb", MINFO)) {
236 clear_bit(0, &ACCESS_FBINFO(irq_flags));
237 return -EINVAL;
238 }
239 /* Clear any pending field interrupts */
240 mga_outl(M_ICLEAR, bm);
241 mga_outl(M_IEN, mga_inl(M_IEN) | bm);
242 } else if (reenable) {
243 u_int32_t ien;
244
245 ien = mga_inl(M_IEN);
246 if ((ien & bm) != bm) {
247 printk(KERN_DEBUG "matroxfb: someone disabled IRQ [%08X]\n", ien);
248 mga_outl(M_IEN, ien | bm);
249 }
250 }
251 return 0;
252}
253
254static void matroxfb_disable_irq(WPMINFO2) {
255 if (test_and_clear_bit(0, &ACCESS_FBINFO(irq_flags))) {
256 /* Flush pending pan-at-vbl request... */
257 matroxfb_crtc1_panpos(PMINFO2);
258 if (ACCESS_FBINFO(devflags.accelerator) == FB_ACCEL_MATROX_MGAG400)
259 mga_outl(M_IEN, mga_inl(M_IEN) & ~0x220);
260 else
261 mga_outl(M_IEN, mga_inl(M_IEN) & ~0x20);
262 free_irq(ACCESS_FBINFO(pcidev)->irq, MINFO);
263 }
264}
265
266int matroxfb_wait_for_sync(WPMINFO u_int32_t crtc) {
1da177e4
LT		 267 struct matrox_vsync *vs;
268 unsigned int cnt;
269 int ret;
270
271 switch (crtc) {
272 case 0:
273 vs = &ACCESS_FBINFO(crtc1.vsync);
274 break;
275 case 1:
276 if (ACCESS_FBINFO(devflags.accelerator) != FB_ACCEL_MATROX_MGAG400) {
277 return -ENODEV;
278 }
279 vs = &ACCESS_FBINFO(crtc2.vsync);
280 break;
281 default:
282 return -ENODEV;
283 }
284 ret = matroxfb_enable_irq(PMINFO 0);
285 if (ret) {
286 return ret;
287 }
1da177e4
LT		 288
289 cnt = vs->cnt;
290 ret = wait_event_interruptible_timeout(vs->wait, cnt != vs->cnt, HZ/10);
291 if (ret < 0) {
292 return ret;
293 }
294 if (ret == 0) {
295 matroxfb_enable_irq(PMINFO 1);
296 return -ETIMEDOUT;
297 }
298 return 0;
299}
300
301/* --------------------------------------------------------------------- */
302
303static void matrox_pan_var(WPMINFO struct fb_var_screeninfo *var) {
304 unsigned int pos;
305 unsigned short p0, p1, p2;
306#ifdef CONFIG_FB_MATROX_32MB
307 unsigned int p3;
308#endif
309 int vbl;
310 unsigned long flags;
311
312 CRITFLAGS
313
314 DBG(__FUNCTION__)
315
316 if (ACCESS_FBINFO(dead))
317 return;
318
319 ACCESS_FBINFO(fbcon).var.xoffset = var->xoffset;
320 ACCESS_FBINFO(fbcon).var.yoffset = var->yoffset;
321 pos = (ACCESS_FBINFO(fbcon).var.yoffset * ACCESS_FBINFO(fbcon).var.xres_virtual + ACCESS_FBINFO(fbcon).var.xoffset) * ACCESS_FBINFO(curr.final_bppShift) / 32;
322 pos += ACCESS_FBINFO(curr.ydstorg.chunks);
323 p0 = ACCESS_FBINFO(hw).CRTC[0x0D] = pos & 0xFF;
324 p1 = ACCESS_FBINFO(hw).CRTC[0x0C] = (pos & 0xFF00) >> 8;
325 p2 = ACCESS_FBINFO(hw).CRTCEXT[0] = (ACCESS_FBINFO(hw).CRTCEXT[0] & 0xB0) | ((pos >> 16) & 0x0F) | ((pos >> 14) & 0x40);
326#ifdef CONFIG_FB_MATROX_32MB
327 p3 = ACCESS_FBINFO(hw).CRTCEXT[8] = pos >> 21;
328#endif
329
330 /* FB_ACTIVATE_VBL and we can acquire interrupts? Honor FB_ACTIVATE_VBL then... */
331 vbl = (var->activate & FB_ACTIVATE_VBL) && (matroxfb_enable_irq(PMINFO 0) == 0);
332
333 CRITBEGIN
334
335 matroxfb_DAC_lock_irqsave(flags);
336 mga_setr(M_CRTC_INDEX, 0x0D, p0);
337 mga_setr(M_CRTC_INDEX, 0x0C, p1);
338#ifdef CONFIG_FB_MATROX_32MB
339 if (ACCESS_FBINFO(devflags.support32MB))
340 mga_setr(M_EXTVGA_INDEX, 0x08, p3);
341#endif
342 if (vbl) {
343 ACCESS_FBINFO(crtc1.panpos) = p2;
344 } else {
345 /* Abort any pending change */
346 ACCESS_FBINFO(crtc1.panpos) = -1;
347 mga_setr(M_EXTVGA_INDEX, 0x00, p2);
348 }
349 matroxfb_DAC_unlock_irqrestore(flags);
350
351 update_crtc2(PMINFO pos);
352
353 CRITEND
354}
355
356static void matroxfb_remove(WPMINFO int dummy) {
357 /* Currently we are holding big kernel lock on all dead & usecount updates.
358 * Destroy everything after all users release it. Especially do not unregister
359 * framebuffer and iounmap memory, neither fbmem nor fbcon-cfb* does not check
360 * for device unplugged when in use.
361 * In future we should point mmio.vbase & video.vbase somewhere where we can
362 * write data without causing too much damage...
363 */
364
365 ACCESS_FBINFO(dead) = 1;
366 if (ACCESS_FBINFO(usecount)) {
367 /* destroy it later */
368 return;
369 }
370 matroxfb_unregister_device(MINFO);
371 unregister_framebuffer(&ACCESS_FBINFO(fbcon));
372 matroxfb_g450_shutdown(PMINFO2);
373#ifdef CONFIG_MTRR
374 if (ACCESS_FBINFO(mtrr.vram_valid))
375 mtrr_del(ACCESS_FBINFO(mtrr.vram), ACCESS_FBINFO(video.base), ACCESS_FBINFO(video.len));
376#endif
377 mga_iounmap(ACCESS_FBINFO(mmio.vbase));
378 mga_iounmap(ACCESS_FBINFO(video.vbase));
379 release_mem_region(ACCESS_FBINFO(video.base), ACCESS_FBINFO(video.len_maximum));
380 release_mem_region(ACCESS_FBINFO(mmio.base), 16384);
381#ifdef CONFIG_FB_MATROX_MULTIHEAD
382 kfree(minfo);
383#endif
384}
385
386 /*
387 * Open/Release the frame buffer device
388 */
389
390static int matroxfb_open(struct fb_info *info, int user)
391{
392 MINFO_FROM_INFO(info);
393
394 DBG_LOOP(__FUNCTION__)
395
396 if (ACCESS_FBINFO(dead)) {
397 return -ENXIO;
398 }
399 ACCESS_FBINFO(usecount)++;
400 if (user) {
401 ACCESS_FBINFO(userusecount)++;
402 }
403 return(0);
404}
405
406static int matroxfb_release(struct fb_info *info, int user)
407{
408 MINFO_FROM_INFO(info);
409
410 DBG_LOOP(__FUNCTION__)
411
412 if (user) {
413 if (0 == --ACCESS_FBINFO(userusecount)) {
414 matroxfb_disable_irq(PMINFO2);
415 }
416 }
417 if (!(--ACCESS_FBINFO(usecount)) && ACCESS_FBINFO(dead)) {
418 matroxfb_remove(PMINFO 0);
419 }
420 return(0);
421}
422
423static int matroxfb_pan_display(struct fb_var_screeninfo *var,
424 struct fb_info* info) {
425 MINFO_FROM_INFO(info);
426
427 DBG(__FUNCTION__)
428
429 matrox_pan_var(PMINFO var);
430 return 0;
431}
432
433static int matroxfb_get_final_bppShift(CPMINFO int bpp) {
434 int bppshft2;
435
436 DBG(__FUNCTION__)
437
438 bppshft2 = bpp;
439 if (!bppshft2) {
440 return 8;
441 }
442 if (isInterleave(MINFO))
443 bppshft2 >>= 1;
444 if (ACCESS_FBINFO(devflags.video64bits))
445 bppshft2 >>= 1;
446 return bppshft2;
447}
448
449static int matroxfb_test_and_set_rounding(CPMINFO int xres, int bpp) {
450 int over;
451 int rounding;
452
453 DBG(__FUNCTION__)
454
455 switch (bpp) {
456 case 0: return xres;
457 case 4: rounding = 128;
458 break;
459 case 8: rounding = 64; /* doc says 64; 32 is OK for G400 */
460 break;
461 case 16: rounding = 32;
462 break;
463 case 24: rounding = 64; /* doc says 64; 32 is OK for G400 */
464 break;
465 default: rounding = 16;
466 /* on G400, 16 really does not work */
467 if (ACCESS_FBINFO(devflags.accelerator) == FB_ACCEL_MATROX_MGAG400)
468 rounding = 32;
469 break;
470 }
471 if (isInterleave(MINFO)) {
472 rounding *= 2;
473 }
474 over = xres % rounding;
475 if (over)
476 xres += rounding-over;
477 return xres;
478}
479
480static int matroxfb_pitch_adjust(CPMINFO int xres, int bpp) {
481 const int* width;
482 int xres_new;
483
484 DBG(__FUNCTION__)
485
486 if (!bpp) return xres;
487
488 width = ACCESS_FBINFO(capable.vxres);
489
490 if (ACCESS_FBINFO(devflags.precise_width)) {
491 while (*width) {
492 if ((*width >= xres) && (matroxfb_test_and_set_rounding(PMINFO *width, bpp) == *width)) {
493 break;
494 }
495 width++;
496 }
497 xres_new = *width;
498 } else {
499 xres_new = matroxfb_test_and_set_rounding(PMINFO xres, bpp);
500 }
1da177e4
LT		 501 return xres_new;
502}
503
504static int matroxfb_get_cmap_len(struct fb_var_screeninfo *var) {
505
506 DBG(__FUNCTION__)
507
508 switch (var->bits_per_pixel) {
509 case 4:
510 return 16; /* pseudocolor... 16 entries HW palette */
511 case 8:
512 return 256; /* pseudocolor... 256 entries HW palette */
513 case 16:
514 return 16; /* directcolor... 16 entries SW palette */
515 /* Mystique: truecolor, 16 entries SW palette, HW palette hardwired into 1:1 mapping */
516 case 24:
517 return 16; /* directcolor... 16 entries SW palette */
518 /* Mystique: truecolor, 16 entries SW palette, HW palette hardwired into 1:1 mapping */
519 case 32:
520 return 16; /* directcolor... 16 entries SW palette */
521 /* Mystique: truecolor, 16 entries SW palette, HW palette hardwired into 1:1 mapping */
522 }
523 return 16; /* return something reasonable... or panic()? */
524}
525
526static int matroxfb_decode_var(CPMINFO struct fb_var_screeninfo *var, int *visual, int *video_cmap_len, unsigned int* ydstorg) {
527 struct RGBT {
528 unsigned char bpp;
529 struct {
530 unsigned char offset,
531 length;
532 } red,
533 green,
534 blue,
535 transp;
536 signed char visual;
537 };
538 static const struct RGBT table[]= {
539 { 8,{ 0,8},{0,8},{0,8},{ 0,0},MX_VISUAL_PSEUDOCOLOR},
540 {15,{10,5},{5,5},{0,5},{15,1},MX_VISUAL_DIRECTCOLOR},
541 {16,{11,5},{5,6},{0,5},{ 0,0},MX_VISUAL_DIRECTCOLOR},
542 {24,{16,8},{8,8},{0,8},{ 0,0},MX_VISUAL_DIRECTCOLOR},
543 {32,{16,8},{8,8},{0,8},{24,8},MX_VISUAL_DIRECTCOLOR}
544 };
545 struct RGBT const *rgbt;
546 unsigned int bpp = var->bits_per_pixel;
547 unsigned int vramlen;
548 unsigned int memlen;
549
550 DBG(__FUNCTION__)
551
552 switch (bpp) {
553 case 4: if (!ACCESS_FBINFO(capable.cfb4)) return -EINVAL;
554 break;
555 case 8: break;
556 case 16: break;
557 case 24: break;
558 case 32: break;
559 default: return -EINVAL;
560 }
561 *ydstorg = 0;
562 vramlen = ACCESS_FBINFO(video.len_usable);
563 if (var->yres_virtual < var->yres)
564 var->yres_virtual = var->yres;
565 if (var->xres_virtual < var->xres)
566 var->xres_virtual = var->xres;
567
568 var->xres_virtual = matroxfb_pitch_adjust(PMINFO var->xres_virtual, bpp);
569 memlen = var->xres_virtual * bpp * var->yres_virtual / 8;
570 if (memlen > vramlen) {
571 var->yres_virtual = vramlen * 8 / (var->xres_virtual * bpp);
572 memlen = var->xres_virtual * bpp * var->yres_virtual / 8;
573 }
574 /* There is hardware bug that no line can cross 4MB boundary */
575 /* give up for CFB24, it is impossible to easy workaround it */
576 /* for other try to do something */
577 if (!ACCESS_FBINFO(capable.cross4MB) && (memlen > 0x400000)) {
578 if (bpp == 24) {
579 /* sorry */
580 } else {
581 unsigned int linelen;
582 unsigned int m1 = linelen = var->xres_virtual * bpp / 8;
583 unsigned int m2 = PAGE_SIZE; /* or 128 if you do not need PAGE ALIGNED address */
584 unsigned int max_yres;
585
586 while (m1) {
587 int t;
588
589 while (m2 >= m1) m2 -= m1;
590 t = m1;
591 m1 = m2;
592 m2 = t;
593 }
594 m2 = linelen * PAGE_SIZE / m2;
595 *ydstorg = m2 = 0x400000 % m2;
596 max_yres = (vramlen - m2) / linelen;
597 if (var->yres_virtual > max_yres)
598 var->yres_virtual = max_yres;
599 }
600 }
601 /* YDSTLEN contains only signed 16bit value */
602 if (var->yres_virtual > 32767)
603 var->yres_virtual = 32767;
604 /* we must round yres/xres down, we already rounded y/xres_virtual up
605 if it was possible. We should return -EINVAL, but I disagree */
606 if (var->yres_virtual < var->yres)
607 var->yres = var->yres_virtual;
608 if (var->xres_virtual < var->xres)
609 var->xres = var->xres_virtual;
610 if (var->xoffset + var->xres > var->xres_virtual)
611 var->xoffset = var->xres_virtual - var->xres;
612 if (var->yoffset + var->yres > var->yres_virtual)
613 var->yoffset = var->yres_virtual - var->yres;
614
615 if (bpp == 16 && var->green.length == 5) {
616 bpp--; /* an artifical value - 15 */
617 }
618
619 for (rgbt = table; rgbt->bpp < bpp; rgbt++);
620#define SETCLR(clr)\
621 var->clr.offset = rgbt->clr.offset;\
622 var->clr.length = rgbt->clr.length
623 SETCLR(red);
624 SETCLR(green);
625 SETCLR(blue);
626 SETCLR(transp);
627#undef SETCLR
628 *visual = rgbt->visual;
629
630 if (bpp > 8)
631 dprintk("matroxfb: truecolor: "
632 "size=%d:%d:%d:%d, shift=%d:%d:%d:%d\n",
633 var->transp.length, var->red.length, var->green.length, var->blue.length,
634 var->transp.offset, var->red.offset, var->green.offset, var->blue.offset);
635
636 *video_cmap_len = matroxfb_get_cmap_len(var);
637 dprintk(KERN_INFO "requested %d*%d/%dbpp (%d*%d)\n", var->xres, var->yres, var->bits_per_pixel,
638 var->xres_virtual, var->yres_virtual);
639 return 0;
640}
641
642static int matroxfb_setcolreg(unsigned regno, unsigned red, unsigned green,
643 unsigned blue, unsigned transp,
644 struct fb_info *fb_info)
645{
646#ifdef CONFIG_FB_MATROX_MULTIHEAD
647 struct matrox_fb_info* minfo = container_of(fb_info, struct matrox_fb_info, fbcon);
648#endif
649
650 DBG(__FUNCTION__)
651
652 /*
653 * Set a single color register. The values supplied are
654 * already rounded down to the hardware's capabilities
655 * (according to the entries in the `var' structure). Return
656 * != 0 for invalid regno.
657 */
658
659 if (regno >= ACCESS_FBINFO(curr.cmap_len))
660 return 1;
661
662 if (ACCESS_FBINFO(fbcon).var.grayscale) {
663 /* gray = 0.30*R + 0.59*G + 0.11*B */
664 red = green = blue = (red * 77 + green * 151 + blue * 28) >> 8;
665 }
666
667 red = CNVT_TOHW(red, ACCESS_FBINFO(fbcon).var.red.length);
668 green = CNVT_TOHW(green, ACCESS_FBINFO(fbcon).var.green.length);
669 blue = CNVT_TOHW(blue, ACCESS_FBINFO(fbcon).var.blue.length);
670 transp = CNVT_TOHW(transp, ACCESS_FBINFO(fbcon).var.transp.length);
671
672 switch (ACCESS_FBINFO(fbcon).var.bits_per_pixel) {
673 case 4:
674 case 8:
675 mga_outb(M_DAC_REG, regno);
676 mga_outb(M_DAC_VAL, red);
677 mga_outb(M_DAC_VAL, green);
678 mga_outb(M_DAC_VAL, blue);
679 break;
680 case 16:
681 {
682 u_int16_t col =
683 (red << ACCESS_FBINFO(fbcon).var.red.offset) |
684 (green << ACCESS_FBINFO(fbcon).var.green.offset) |
685 (blue << ACCESS_FBINFO(fbcon).var.blue.offset) |
686 (transp << ACCESS_FBINFO(fbcon).var.transp.offset); /* for 1:5:5:5 */
687 ACCESS_FBINFO(cmap[regno]) = col | (col << 16);
688 }
689 break;
690 case 24:
691 case 32:
692 ACCESS_FBINFO(cmap[regno]) =
693 (red << ACCESS_FBINFO(fbcon).var.red.offset) |
694 (green << ACCESS_FBINFO(fbcon).var.green.offset) |
695 (blue << ACCESS_FBINFO(fbcon).var.blue.offset) |
696 (transp << ACCESS_FBINFO(fbcon).var.transp.offset); /* 8:8:8:8 */
697 break;
698 }
699 return 0;
700}
701
702static void matroxfb_init_fix(WPMINFO2)
703{
704 struct fb_fix_screeninfo *fix = &ACCESS_FBINFO(fbcon).fix;
705 DBG(__FUNCTION__)
706
707 strcpy(fix->id,"MATROX");
708
709 fix->xpanstep = 8; /* 8 for 8bpp, 4 for 16bpp, 2 for 32bpp */
710 fix->ypanstep = 1;
711 fix->ywrapstep = 0;
712 fix->mmio_start = ACCESS_FBINFO(mmio.base);
713 fix->mmio_len = ACCESS_FBINFO(mmio.len);
714 fix->accel = ACCESS_FBINFO(devflags.accelerator);
715}
716
717static void matroxfb_update_fix(WPMINFO2)
718{
719 struct fb_fix_screeninfo *fix = &ACCESS_FBINFO(fbcon).fix;
720 DBG(__FUNCTION__)
721
722 fix->smem_start = ACCESS_FBINFO(video.base) + ACCESS_FBINFO(curr.ydstorg.bytes);
723 fix->smem_len = ACCESS_FBINFO(video.len_usable) - ACCESS_FBINFO(curr.ydstorg.bytes);
724}
725
726static int matroxfb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
727{
728 int err;
729 int visual;
730 int cmap_len;
731 unsigned int ydstorg;
732 MINFO_FROM_INFO(info);
733
734 if (ACCESS_FBINFO(dead)) {
735 return -ENXIO;
736 }
737 if ((err = matroxfb_decode_var(PMINFO var, &visual, &cmap_len, &ydstorg)) != 0)
738 return err;
739 return 0;
740}
741
742static int matroxfb_set_par(struct fb_info *info)
743{
744 int err;
745 int visual;
746 int cmap_len;
747 unsigned int ydstorg;
748 struct fb_var_screeninfo *var;
749 MINFO_FROM_INFO(info);
750
751 DBG(__FUNCTION__)
752
753 if (ACCESS_FBINFO(dead)) {
754 return -ENXIO;
755 }
756
757 var = &info->var;
758 if ((err = matroxfb_decode_var(PMINFO var, &visual, &cmap_len, &ydstorg)) != 0)
759 return err;
760 ACCESS_FBINFO(fbcon.screen_base) = vaddr_va(ACCESS_FBINFO(video.vbase)) + ydstorg;
761 matroxfb_update_fix(PMINFO2);
762 ACCESS_FBINFO(fbcon).fix.visual = visual;
763 ACCESS_FBINFO(fbcon).fix.type = FB_TYPE_PACKED_PIXELS;
764 ACCESS_FBINFO(fbcon).fix.type_aux = 0;
765 ACCESS_FBINFO(fbcon).fix.line_length = (var->xres_virtual * var->bits_per_pixel) >> 3;
766 {
767 unsigned int pos;
768
769 ACCESS_FBINFO(curr.cmap_len) = cmap_len;
770 ydstorg += ACCESS_FBINFO(devflags.ydstorg);
771 ACCESS_FBINFO(curr.ydstorg.bytes) = ydstorg;
772 ACCESS_FBINFO(curr.ydstorg.chunks) = ydstorg >> (isInterleave(MINFO)?3:2);
773 if (var->bits_per_pixel == 4)
774 ACCESS_FBINFO(curr.ydstorg.pixels) = ydstorg;
775 else
776 ACCESS_FBINFO(curr.ydstorg.pixels) = (ydstorg * 8) / var->bits_per_pixel;
777 ACCESS_FBINFO(curr.final_bppShift) = matroxfb_get_final_bppShift(PMINFO var->bits_per_pixel);
778 { struct my_timming mt;
779 struct matrox_hw_state* hw;
780 int out;
781
782 matroxfb_var2my(var, &mt);
783 mt.crtc = MATROXFB_SRC_CRTC1;
784 /* CRTC1 delays */
785 switch (var->bits_per_pixel) {
786 case 0: mt.delay = 31 + 0; break;
787 case 16: mt.delay = 21 + 8; break;
788 case 24: mt.delay = 17 + 8; break;
789 case 32: mt.delay = 16 + 8; break;
790 default: mt.delay = 31 + 8; break;
791 }
792
793 hw = &ACCESS_FBINFO(hw);
794
795 down_read(&ACCESS_FBINFO(altout).lock);
796 for (out = 0; out < MATROXFB_MAX_OUTPUTS; out++) {
797 if (ACCESS_FBINFO(outputs[out]).src == MATROXFB_SRC_CRTC1 &&
798 ACCESS_FBINFO(outputs[out]).output->compute) {
799 ACCESS_FBINFO(outputs[out]).output->compute(ACCESS_FBINFO(outputs[out]).data, &mt);
800 }
801 }
802 up_read(&ACCESS_FBINFO(altout).lock);
803 ACCESS_FBINFO(crtc1).pixclock = mt.pixclock;
804 ACCESS_FBINFO(crtc1).mnp = mt.mnp;
805 ACCESS_FBINFO(hw_switch->init(PMINFO &mt));
806 pos = (var->yoffset * var->xres_virtual + var->xoffset) * ACCESS_FBINFO(curr.final_bppShift) / 32;
807 pos += ACCESS_FBINFO(curr.ydstorg.chunks);
808
809 hw->CRTC[0x0D] = pos & 0xFF;
810 hw->CRTC[0x0C] = (pos & 0xFF00) >> 8;
811 hw->CRTCEXT[0] = (hw->CRTCEXT[0] & 0xF0) | ((pos >> 16) & 0x0F) | ((pos >> 14) & 0x40);
812 hw->CRTCEXT[8] = pos >> 21;
813 ACCESS_FBINFO(hw_switch->restore(PMINFO2));
814 update_crtc2(PMINFO pos);
815 down_read(&ACCESS_FBINFO(altout).lock);
816 for (out = 0; out < MATROXFB_MAX_OUTPUTS; out++) {
817 if (ACCESS_FBINFO(outputs[out]).src == MATROXFB_SRC_CRTC1 &&
818 ACCESS_FBINFO(outputs[out]).output->program) {
819 ACCESS_FBINFO(outputs[out]).output->program(ACCESS_FBINFO(outputs[out]).data);
820 }
821 }
822 for (out = 0; out < MATROXFB_MAX_OUTPUTS; out++) {
823 if (ACCESS_FBINFO(outputs[out]).src == MATROXFB_SRC_CRTC1 &&
824 ACCESS_FBINFO(outputs[out]).output->start) {
825 ACCESS_FBINFO(outputs[out]).output->start(ACCESS_FBINFO(outputs[out]).data);
826 }
827 }
828 up_read(&ACCESS_FBINFO(altout).lock);
829 matrox_cfbX_init(PMINFO2);
830 }
831 }
832 ACCESS_FBINFO(initialized) = 1;
833 return 0;
834}
835
836static int matroxfb_get_vblank(WPMINFO struct fb_vblank *vblank)
837{
838 unsigned int sts1;
839
840 matroxfb_enable_irq(PMINFO 0);
841 memset(vblank, 0, sizeof(*vblank));
842 vblank->flags = FB_VBLANK_HAVE_VCOUNT | FB_VBLANK_HAVE_VSYNC |
843 FB_VBLANK_HAVE_VBLANK | FB_VBLANK_HAVE_HBLANK;
844 sts1 = mga_inb(M_INSTS1);
845 vblank->vcount = mga_inl(M_VCOUNT);
846 /* BTW, on my PIII/450 with G400, reading M_INSTS1
847 byte makes this call about 12% slower (1.70 vs. 2.05 us
848 per ioctl()) */
849 if (sts1 & 1)
850 vblank->flags |= FB_VBLANK_HBLANKING;
851 if (sts1 & 8)
852 vblank->flags |= FB_VBLANK_VSYNCING;
853 if (vblank->vcount >= ACCESS_FBINFO(fbcon).var.yres)
854 vblank->flags |= FB_VBLANK_VBLANKING;
855 if (test_bit(0, &ACCESS_FBINFO(irq_flags))) {
856 vblank->flags |= FB_VBLANK_HAVE_COUNT;
857 /* Only one writer, aligned int value...
858 it should work without lock and without atomic_t */
859 vblank->count = ACCESS_FBINFO(crtc1).vsync.cnt;
860 }
861 return 0;
862}
863
864static struct matrox_altout panellink_output = {
865 .name = "Panellink output",
866};
867
868static int matroxfb_ioctl(struct inode *inode, struct file *file,
869 unsigned int cmd, unsigned long arg,
870 struct fb_info *info)
871{
872 void __user *argp = (void __user *)arg;
873 MINFO_FROM_INFO(info);
874
875 DBG(__FUNCTION__)
876
877 if (ACCESS_FBINFO(dead)) {
878 return -ENXIO;
879 }
880
881 switch (cmd) {
882 case FBIOGET_VBLANK:
883 {
884 struct fb_vblank vblank;
885 int err;
886
887 err = matroxfb_get_vblank(PMINFO &vblank);
888 if (err)
889 return err;
890 if (copy_to_user(argp, &vblank, sizeof(vblank)))
891 return -EFAULT;
892 return 0;
893 }
894 case FBIO_WAITFORVSYNC:
895 {
896 u_int32_t crt;
897
898 if (get_user(crt, (u_int32_t __user *)arg))
899 return -EFAULT;
900
901 return matroxfb_wait_for_sync(PMINFO crt);
902 }
903 case MATROXFB_SET_OUTPUT_MODE:
904 {
905 struct matroxioc_output_mode mom;
906 struct matrox_altout *oproc;
907 int val;
908
909 if (copy_from_user(&mom, argp, sizeof(mom)))
910 return -EFAULT;
911 if (mom.output >= MATROXFB_MAX_OUTPUTS)
912 return -ENXIO;
913 down_read(&ACCESS_FBINFO(altout.lock));
914 oproc = ACCESS_FBINFO(outputs[mom.output]).output;
915 if (!oproc) {
916 val = -ENXIO;
917 } else if (!oproc->verifymode) {
918 if (mom.mode == MATROXFB_OUTPUT_MODE_MONITOR) {
919 val = 0;
920 } else {
921 val = -EINVAL;
922 }
923 } else {
924 val = oproc->verifymode(ACCESS_FBINFO(outputs[mom.output]).data, mom.mode);
925 }
926 if (!val) {
927 if (ACCESS_FBINFO(outputs[mom.output]).mode != mom.mode) {
928 ACCESS_FBINFO(outputs[mom.output]).mode = mom.mode;
929 val = 1;
930 }
931 }
932 up_read(&ACCESS_FBINFO(altout.lock));
933 if (val != 1)
934 return val;
935 switch (ACCESS_FBINFO(outputs[mom.output]).src) {
936 case MATROXFB_SRC_CRTC1:
937 matroxfb_set_par(info);
938 break;
939 case MATROXFB_SRC_CRTC2:
940 {
941 struct matroxfb_dh_fb_info* crtc2;
942
943 down_read(&ACCESS_FBINFO(crtc2.lock));
944 crtc2 = ACCESS_FBINFO(crtc2.info);
945 if (crtc2)
946 crtc2->fbcon.fbops->fb_set_par(&crtc2->fbcon);
947 up_read(&ACCESS_FBINFO(crtc2.lock));
948 }
949 break;
950 }
951 return 0;
952 }
953 case MATROXFB_GET_OUTPUT_MODE:
954 {
955 struct matroxioc_output_mode mom;
956 struct matrox_altout *oproc;
957 int val;
958
959 if (copy_from_user(&mom, argp, sizeof(mom)))
960 return -EFAULT;
961 if (mom.output >= MATROXFB_MAX_OUTPUTS)
962 return -ENXIO;
963 down_read(&ACCESS_FBINFO(altout.lock));
964 oproc = ACCESS_FBINFO(outputs[mom.output]).output;
965 if (!oproc) {
966 val = -ENXIO;
967 } else {
968 mom.mode = ACCESS_FBINFO(outputs[mom.output]).mode;
969 val = 0;
970 }
971 up_read(&ACCESS_FBINFO(altout.lock));
972 if (val)
973 return val;
974 if (copy_to_user(argp, &mom, sizeof(mom)))
975 return -EFAULT;
976 return 0;
977 }
978 case MATROXFB_SET_OUTPUT_CONNECTION:
979 {
980 u_int32_t tmp;
981 int i;
982 int changes;
983
984 if (copy_from_user(&tmp, argp, sizeof(tmp)))
985 return -EFAULT;
986 for (i = 0; i < 32; i++) {
987 if (tmp & (1 << i)) {
988 if (i >= MATROXFB_MAX_OUTPUTS)
989 return -ENXIO;
990 if (!ACCESS_FBINFO(outputs[i]).output)
991 return -ENXIO;
992 switch (ACCESS_FBINFO(outputs[i]).src) {
993 case MATROXFB_SRC_NONE:
994 case MATROXFB_SRC_CRTC1:
995 break;
996 default:
997 return -EBUSY;
998 }
999 }
1000 }
1001 if (ACCESS_FBINFO(devflags.panellink)) {
1002 if (tmp & MATROXFB_OUTPUT_CONN_DFP) {
1003 if (tmp & MATROXFB_OUTPUT_CONN_SECONDARY)
1004 return -EINVAL;
1005 for (i = 0; i < MATROXFB_MAX_OUTPUTS; i++) {
1006 if (ACCESS_FBINFO(outputs[i]).src == MATROXFB_SRC_CRTC2) {
1007 return -EBUSY;
1008 }
1009 }
1010 }
1011 }
1012 changes = 0;
1013 for (i = 0; i < MATROXFB_MAX_OUTPUTS; i++) {
1014 if (tmp & (1 << i)) {
1015 if (ACCESS_FBINFO(outputs[i]).src != MATROXFB_SRC_CRTC1) {
1016 changes = 1;
1017 ACCESS_FBINFO(outputs[i]).src = MATROXFB_SRC_CRTC1;
1018 }
1019 } else if (ACCESS_FBINFO(outputs[i]).src == MATROXFB_SRC_CRTC1) {
1020 changes = 1;
1021 ACCESS_FBINFO(outputs[i]).src = MATROXFB_SRC_NONE;
1022 }
1023 }
1024 if (!changes)
1025 return 0;
1026 matroxfb_set_par(info);
1027 return 0;
1028 }
1029 case MATROXFB_GET_OUTPUT_CONNECTION:
1030 {
1031 u_int32_t conn = 0;
1032 int i;
1033
1034 for (i = 0; i < MATROXFB_MAX_OUTPUTS; i++) {
1035 if (ACCESS_FBINFO(outputs[i]).src == MATROXFB_SRC_CRTC1) {
1036 conn |= 1 << i;
1037 }
1038 }
1039 if (put_user(conn, (u_int32_t __user *)arg))
1040 return -EFAULT;
1041 return 0;
1042 }
1043 case MATROXFB_GET_AVAILABLE_OUTPUTS:
1044 {
1045 u_int32_t conn = 0;
1046 int i;
1047
1048 for (i = 0; i < MATROXFB_MAX_OUTPUTS; i++) {
1049 if (ACCESS_FBINFO(outputs[i]).output) {
1050 switch (ACCESS_FBINFO(outputs[i]).src) {
1051 case MATROXFB_SRC_NONE:
1052 case MATROXFB_SRC_CRTC1:
1053 conn |= 1 << i;
1054 break;
1055 }
1056 }
1057 }
1058 if (ACCESS_FBINFO(devflags.panellink)) {
1059 if (conn & MATROXFB_OUTPUT_CONN_DFP)
1060 conn &= ~MATROXFB_OUTPUT_CONN_SECONDARY;
1061 if (conn & MATROXFB_OUTPUT_CONN_SECONDARY)
1062 conn &= ~MATROXFB_OUTPUT_CONN_DFP;
1063 }
1064 if (put_user(conn, (u_int32_t __user *)arg))
1065 return -EFAULT;
1066 return 0;
1067 }
1068 case MATROXFB_GET_ALL_OUTPUTS:
1069 {
1070 u_int32_t conn = 0;
1071 int i;
1072
1073 for (i = 0; i < MATROXFB_MAX_OUTPUTS; i++) {
1074 if (ACCESS_FBINFO(outputs[i]).output) {
1075 conn |= 1 << i;
1076 }
1077 }
1078 if (put_user(conn, (u_int32_t __user *)arg))
1079 return -EFAULT;
1080 return 0;
1081 }
1082 case VIDIOC_QUERYCAP:
1083 {
1084 struct v4l2_capability r;
1085
1086 memset(&r, 0, sizeof(r));
1087 strcpy(r.driver, "matroxfb");
1088 strcpy(r.card, "Matrox");
1089 sprintf(r.bus_info, "PCI:%s", pci_name(ACCESS_FBINFO(pcidev)));
1090 r.version = KERNEL_VERSION(1,0,0);
1091 r.capabilities = V4L2_CAP_VIDEO_OUTPUT;
1092 if (copy_to_user(argp, &r, sizeof(r)))
1093 return -EFAULT;
1094 return 0;
1095
1096 }
1097 case VIDIOC_QUERYCTRL:
1098 {
1099 struct v4l2_queryctrl qctrl;
1100 int err;
1101
1102 if (copy_from_user(&qctrl, argp, sizeof(qctrl)))
1103 return -EFAULT;
1104
1105 down_read(&ACCESS_FBINFO(altout).lock);
1106 if (!ACCESS_FBINFO(outputs[1]).output) {
1107 err = -ENXIO;
1108 } else if (ACCESS_FBINFO(outputs[1]).output->getqueryctrl) {
1109 err = ACCESS_FBINFO(outputs[1]).output->getqueryctrl(ACCESS_FBINFO(outputs[1]).data, &qctrl);
1110 } else {
1111 err = -EINVAL;
1112 }
1113 up_read(&ACCESS_FBINFO(altout).lock);
1114 if (err >= 0 &&
1115 copy_to_user(argp, &qctrl, sizeof(qctrl)))
1116 return -EFAULT;
1117 return err;
1118 }
1119 case VIDIOC_G_CTRL:
1120 {
1121 struct v4l2_control ctrl;
1122 int err;
1123
1124 if (copy_from_user(&ctrl, argp, sizeof(ctrl)))
1125 return -EFAULT;
1126
1127 down_read(&ACCESS_FBINFO(altout).lock);
1128 if (!ACCESS_FBINFO(outputs[1]).output) {
1129 err = -ENXIO;
1130 } else if (ACCESS_FBINFO(outputs[1]).output->getctrl) {
1131 err = ACCESS_FBINFO(outputs[1]).output->getctrl(ACCESS_FBINFO(outputs[1]).data, &ctrl);
1132 } else {
1133 err = -EINVAL;
1134 }
1135 up_read(&ACCESS_FBINFO(altout).lock);
1136 if (err >= 0 &&
1137 copy_to_user(argp, &ctrl, sizeof(ctrl)))
1138 return -EFAULT;
1139 return err;
1140 }
1141 case VIDIOC_S_CTRL_OLD:
1142 case VIDIOC_S_CTRL:
1143 {
1144 struct v4l2_control ctrl;
1145 int err;
1146
1147 if (copy_from_user(&ctrl, argp, sizeof(ctrl)))
1148 return -EFAULT;
1149
1150 down_read(&ACCESS_FBINFO(altout).lock);
1151 if (!ACCESS_FBINFO(outputs[1]).output) {
1152 err = -ENXIO;
1153 } else if (ACCESS_FBINFO(outputs[1]).output->setctrl) {
1154 err = ACCESS_FBINFO(outputs[1]).output->setctrl(ACCESS_FBINFO(outputs[1]).data, &ctrl);
1155 } else {
1156 err = -EINVAL;
1157 }
1158 up_read(&ACCESS_FBINFO(altout).lock);
1159 return err;
1160 }
1161 }
1162 return -ENOTTY;
1163}
1164
1165/* 0 unblank, 1 blank, 2 no vsync, 3 no hsync, 4 off */
1166
1167static int matroxfb_blank(int blank, struct fb_info *info)
1168{
1169 int seq;
1170 int crtc;
1171 CRITFLAGS
1172 MINFO_FROM_INFO(info);
1173
1174 DBG(__FUNCTION__)
1175
1176 if (ACCESS_FBINFO(dead))
1177 return 1;
1178
1179 switch (blank) {
1180 case FB_BLANK_NORMAL: seq = 0x20; crtc = 0x00; break; /* works ??? */
1181 case FB_BLANK_VSYNC_SUSPEND: seq = 0x20; crtc = 0x10; break;
1182 case FB_BLANK_HSYNC_SUSPEND: seq = 0x20; crtc = 0x20; break;
1183 case FB_BLANK_POWERDOWN: seq = 0x20; crtc = 0x30; break;
1184 default: seq = 0x00; crtc = 0x00; break;
1185 }
1186
1187 CRITBEGIN
1188
1189 mga_outb(M_SEQ_INDEX, 1);
1190 mga_outb(M_SEQ_DATA, (mga_inb(M_SEQ_DATA) & ~0x20) | seq);
1191 mga_outb(M_EXTVGA_INDEX, 1);
1192 mga_outb(M_EXTVGA_DATA, (mga_inb(M_EXTVGA_DATA) & ~0x30) | crtc);
1193
1194 CRITEND
1195 return 0;
1196}
1197
1198static struct fb_ops matroxfb_ops = {
1199 .owner = THIS_MODULE,
1200 .fb_open = matroxfb_open,
1201 .fb_release = matroxfb_release,
1202 .fb_check_var = matroxfb_check_var,
1203 .fb_set_par = matroxfb_set_par,
1204 .fb_setcolreg = matroxfb_setcolreg,
1205 .fb_pan_display =matroxfb_pan_display,
1206 .fb_blank = matroxfb_blank,
1207 .fb_ioctl = matroxfb_ioctl,
1208/* .fb_fillrect = <set by matrox_cfbX_init>, */
1209/* .fb_copyarea = <set by matrox_cfbX_init>, */
1210/* .fb_imageblit = <set by matrox_cfbX_init>, */
1211/* .fb_cursor = <set by matrox_cfbX_init>, */
1212};
1213
1214#define RSDepth(X) (((X) >> 8) & 0x0F)
1215#define RS8bpp 0x1
1216#define RS15bpp 0x2
1217#define RS16bpp 0x3
1218#define RS32bpp 0x4
1219#define RS4bpp 0x5
1220#define RS24bpp 0x6
1221#define RSText 0x7
1222#define RSText8 0x8
1223/* 9-F */
1224static struct { struct fb_bitfield red, green, blue, transp; int bits_per_pixel; } colors[] = {
1225 { { 0, 8, 0}, { 0, 8, 0}, { 0, 8, 0}, { 0, 0, 0}, 8 },
1226 { { 10, 5, 0}, { 5, 5, 0}, { 0, 5, 0}, { 15, 1, 0}, 16 },
1227 { { 11, 5, 0}, { 5, 6, 0}, { 0, 5, 0}, { 0, 0, 0}, 16 },
1228 { { 16, 8, 0}, { 8, 8, 0}, { 0, 8, 0}, { 24, 8, 0}, 32 },
1229 { { 0, 8, 0}, { 0, 8, 0}, { 0, 8, 0}, { 0, 0, 0}, 4 },
1230 { { 16, 8, 0}, { 8, 8, 0}, { 0, 8, 0}, { 0, 0, 0}, 24 },
1231 { { 0, 6, 0}, { 0, 6, 0}, { 0, 6, 0}, { 0, 0, 0}, 0 }, /* textmode with (default) VGA8x16 */
1232 { { 0, 6, 0}, { 0, 6, 0}, { 0, 6, 0}, { 0, 0, 0}, 0 }, /* textmode hardwired to VGA8x8 */
1233};
1234
1235/* initialized by setup, see explanation at end of file (search for MODULE_PARM_DESC) */
1236static unsigned int mem; /* "matrox:mem:xxxxxM" */
1237static int option_precise_width = 1; /* cannot be changed, option_precise_width==0 must imply noaccel */
1238static int inv24; /* "matrox:inv24" */
1239static int cross4MB = -1; /* "matrox:cross4MB" */
1240static int disabled; /* "matrox:disabled" */
1241static int noaccel; /* "matrox:noaccel" */
1242static int nopan; /* "matrox:nopan" */
1243static int no_pci_retry; /* "matrox:nopciretry" */
1244static int novga; /* "matrox:novga" */
1245static int nobios; /* "matrox:nobios" */
1246static int noinit = 1; /* "matrox:init" */
1247static int inverse; /* "matrox:inverse" */
1248static int sgram; /* "matrox:sgram" */
1249#ifdef CONFIG_MTRR
1250static int mtrr = 1; /* "matrox:nomtrr" */
1251#endif
1252static int grayscale; /* "matrox:grayscale" */
1253static int dev = -1; /* "matrox:dev:xxxxx" */
1254static unsigned int vesa = ~0; /* "matrox:vesa:xxxxx" */
1255static int depth = -1; /* "matrox:depth:xxxxx" */
1256static unsigned int xres; /* "matrox:xres:xxxxx" */
1257static unsigned int yres; /* "matrox:yres:xxxxx" */
1258static unsigned int upper = ~0; /* "matrox:upper:xxxxx" */
1259static unsigned int lower = ~0; /* "matrox:lower:xxxxx" */
1260static unsigned int vslen; /* "matrox:vslen:xxxxx" */
1261static unsigned int left = ~0; /* "matrox:left:xxxxx" */
1262static unsigned int right = ~0; /* "matrox:right:xxxxx" */
1263static unsigned int hslen; /* "matrox:hslen:xxxxx" */
1264static unsigned int pixclock; /* "matrox:pixclock:xxxxx" */
1265static int sync = -1; /* "matrox:sync:xxxxx" */
1266static unsigned int fv; /* "matrox:fv:xxxxx" */
1267static unsigned int fh; /* "matrox:fh:xxxxxk" */
1268static unsigned int maxclk; /* "matrox:maxclk:xxxxM" */
1269static int dfp; /* "matrox:dfp */
1270static int dfp_type = -1; /* "matrox:dfp:xxx */
1271static int memtype = -1; /* "matrox:memtype:xxx" */
1272static char outputs[8]; /* "matrox:outputs:xxx" */
1273
1274#ifndef MODULE
1275static char videomode[64]; /* "matrox:mode:xxxxx" or "matrox:xxxxx" */
1276#endif
1277
1278static int matroxfb_getmemory(WPMINFO unsigned int maxSize, unsigned int *realSize){
1279 vaddr_t vm;
1280 unsigned int offs;
1281 unsigned int offs2;