?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
- pre2
[davej-history.git] / drivers / video / matrox / matroxfb_crtc2.c
blob515eb1e78a6a2ccb0cfaed8652cf48e9fc991cbd
1 #include "matroxfb_maven.h"
2 #include "matroxfb_crtc2.h"
3 #include "matroxfb_misc.h"
4 #include "matroxfb_DAC1064.h"
5 #include <linux/matroxfb.h>
6 #include <asm/uaccess.h>
7
8 /* **************************************************** */
9
10 static int mem = 8192;
11
12 MODULE_PARM(mem, "i");
13 MODULE_PARM_DESC(mem, "Memory size reserved for dualhead (default=8MB)");
14
15 /* **************************************************** */
16
17 static int matroxfb_dh_getcolreg(unsigned regno, unsigned *red, unsigned *green,
18 unsigned *blue, unsigned *transp, struct fb_info* info) {
19 #define m2info ((struct matroxfb_dh_fb_info*)info)
20 if (regno > 16)
21 return 1;
22 *red = m2info->palette[regno].red;
23 *blue = m2info->palette[regno].blue;
24 *green = m2info->palette[regno].green;
25 *transp = m2info->palette[regno].transp;
26 return 0;
27 #undef m2info
28 }
29
30 static int matroxfb_dh_setcolreg(unsigned regno, unsigned red, unsigned green,
31 unsigned blue, unsigned transp, struct fb_info* info) {
32 #define m2info ((struct matroxfb_dh_fb_info*)info)
33 struct display* p;
34
35 if (regno > 16)
36 return 1;
37 m2info->palette[regno].red = red;
38 m2info->palette[regno].blue = blue;
39 m2info->palette[regno].green = green;
40 m2info->palette[regno].transp = transp;
41 p = m2info->currcon_display;
42 if (p->var.grayscale) {
43 /* gray = 0.30*R + 0.59*G + 0.11*B */
44 red = green = blue = (red * 77 + green * 151 + blue * 28) >> 8;
45 }
46 red = CNVT_TOHW(red, p->var.red.length);
47 green = CNVT_TOHW(green, p->var.green.length);
48 blue = CNVT_TOHW(blue, p->var.blue.length);
49 transp = CNVT_TOHW(transp, p->var.transp.length);
50
51 switch (p->var.bits_per_pixel) {
52 #ifdef FBCON_HAS_CFB16
53 case 16:
54 m2info->cmap.cfb16[regno] =
55 (red << p->var.red.offset) |
56 (green << p->var.green.offset) |
57 (blue << p->var.blue.offset) |
58 (transp << p->var.transp.offset);
59 break;
60 #endif
61 #ifdef FBCON_HAS_CFB32
62 case 32:
63 m2info->cmap.cfb32[regno] =
64 (red << p->var.red.offset) |
65 (green << p->var.green.offset) |
66 (blue << p->var.blue.offset) |
67 (transp << p->var.transp.offset);
68 break;
69 #endif
70 }
71 return 0;
72 #undef m2info
73 }
74
75 static void do_install_cmap(struct matroxfb_dh_fb_info* m2info, struct display* p) {
76 if (p->cmap.len)
77 fb_set_cmap(&p->cmap, 1, matroxfb_dh_setcolreg, &m2info->fbcon);
78 else
79 fb_set_cmap(fb_default_cmap(16), 1, matroxfb_dh_setcolreg, &m2info->fbcon);
80 }
81
82 static void matroxfb_dh_restore(struct matroxfb_dh_fb_info* m2info,
83 struct my_timming* mt,
84 struct display* p,
85 int mode,
86 unsigned int pos) {
87 u_int32_t tmp;
88 MINFO_FROM(m2info->primary_dev);
89
90 switch (mode) {
91 case 15:
92 tmp = 0x00200000;
93 break;
94 case 16:
95 tmp = 0x00400000;
96 break;
97 /* case 32: */
98 default:
99 tmp = 0x00800000;
100 break;
101 }
102
103 if (ACCESS_FBINFO(output.sh)) {
104 tmp |= 0x00000001; /* enable CRTC2 */
105
106 if (ACCESS_FBINFO(output.sh) & MATROXFB_OUTPUT_CONN_SECONDARY) {
107 tmp |= 0x00000002; /* source from VDOCLK */
108 tmp |= 0xC0000000; /* enable vvidrst & hvidrst */
109 /* MGA TVO is our clock source */
110 } else if (ACCESS_FBINFO(output.sh) & MATROXFB_OUTPUT_CONN_PRIMARY) {
111 tmp |= 0x00000004; /* source from pixclock */
112 /* PIXPLL is our clock source */
113 }
114
115 if (ACCESS_FBINFO(output.sh) & MATROXFB_OUTPUT_CONN_PRIMARY)
116 tmp |= 0x00100000; /* connect CRTC2 to DAC */
117 }
118 mga_outl(0x3C10, tmp | 0x10000000); /* depth and so on... 0x10000000 is VIDRST polarity */
119 mga_outl(0x3C14, ((mt->HDisplay - 8) << 16) | (mt->HTotal - 8));
120 mga_outl(0x3C18, ((mt->HSyncEnd - 8) << 16) | (mt->HSyncStart - 8));
121 mga_outl(0x3C1C, ((mt->VDisplay - 1) << 16) | (mt->VTotal - 1));
122 mga_outl(0x3C20, ((mt->VSyncEnd - 1) << 16) | (mt->VSyncStart - 1));
123 mga_outl(0x3C24, ((mt->VSyncStart) << 16) | (mt->HSyncStart)); /* preload */
124 mga_outl(0x3C28, pos); /* vmemory start */
125 mga_outl(0x3C40, p->var.xres_virtual * (p->var.bits_per_pixel >> 3));
126 tmp = 0x0FFF0000; /* line compare */
127 if (mt->sync & FB_SYNC_HOR_HIGH_ACT)
128 tmp |= 0x00000100;
129 if (mt->sync & FB_SYNC_VERT_HIGH_ACT)
130 tmp |= 0x00000200;
131 mga_outl(0x3C44, tmp);
132 mga_outl(0x3C4C, 0); /* data control */
133 }
134
135 static void matroxfb_dh_cfbX_init(struct matroxfb_dh_fb_info* m2info,
136 struct display* p) {
137 /* no acceleration for secondary head... */
138 }
139
140 static void matroxfb_dh_pan_var(struct matroxfb_dh_fb_info* m2info,
141 struct fb_var_screeninfo* var) {
142 unsigned int pos;
143
144 #define minfo (m2info->primary_dev)
145 pos = (var->yoffset * var->xres_virtual + var->xoffset) * var->bits_per_pixel >> 3;
146 pos += m2info->video.offbase;
147 mga_outl(0x3C28, pos);
148 #undef minfo
149 }
150
151 static int matroxfb_dh_decode_var(struct matroxfb_dh_fb_info* m2info,
152 struct display* p,
153 struct fb_var_screeninfo* var,
154 int *visual,
155 int *video_cmap_len,
156 int *mode) {
157 unsigned int mask;
158 unsigned int memlen;
159 unsigned int vramlen;
160
161 switch (var->bits_per_pixel) {
162 #ifdef FBCON_HAS_CFB16
163 case 16: mask = 0x1F;
164 break;
165 #endif
166 #ifdef FBCON_HAS_CFB32
167 case 32: mask = 0x0F;
168 break;
169 #endif
170 default: return -EINVAL;
171 }
172 vramlen = m2info->video.len_usable;
173 if (var->yres_virtual < var->yres)
174 var->yres_virtual = var->yres;
175 if (var->xres_virtual < var->xres)
176 var->xres_virtual = var->xres;
177 var->xres_virtual = (var->xres_virtual + mask) & ~mask;
178 if (var->yres_virtual > 32767)
179 return -EINVAL;
180 memlen = var->xres_virtual * var->yres_virtual * (var->bits_per_pixel >> 3);
181 if (memlen > vramlen)
182 return -EINVAL;
183 if (var->xoffset + var->xres > var->xres_virtual)
184 var->xoffset = var->xres_virtual - var->xres;
185 if (var->yoffset + var->yres > var->yres_virtual)
186 var->yoffset = var->yres_virtual - var->yres;
187
188 var->xres &= ~7;
189 var->left_margin &= ~7;
190 var->right_margin &= ~7;
191 var->hsync_len &= ~7;
192
193 *mode = var->bits_per_pixel;
194 if (var->bits_per_pixel == 16) {
195 if (var->green.length == 5) {
196 var->red.offset = 10;
197 var->red.length = 5;
198 var->green.offset = 5;
199 var->green.length = 5;
200 var->blue.offset = 0;
201 var->blue.length = 5;
202 var->transp.offset = 15;
203 var->transp.length = 1;
204 *mode = 15;
205 } else {
206 var->red.offset = 11;
207 var->red.length = 5;
208 var->green.offset = 5;
209 var->green.length = 6;
210 var->blue.offset = 0;
211 var->blue.length = 5;
212 var->transp.offset = 0;
213 var->transp.length = 0;
214 }
215 } else {
216 var->red.offset = 16;
217 var->red.length = 8;
218 var->green.offset = 8;
219 var->green.length = 8;
220 var->blue.offset = 0;
221 var->blue.length = 8;
222 var->transp.offset = 24;
223 var->transp.length = 8;
224 }
225 *visual = FB_VISUAL_TRUECOLOR;
226 *video_cmap_len = 16;
227 return 0;
228 }
229
230 static void initMatroxDH(struct matroxfb_dh_fb_info* m2info, struct display* p) {
231 switch (p->var.bits_per_pixel) {
232 #ifdef FBCON_HAS_CFB16
233 case 16:
234 p->dispsw_data = m2info->cmap.cfb16;
235 p->dispsw = &fbcon_cfb16;
236 break;
237 #endif
238 #ifdef FBCON_HAS_CFB32
239 case 32:
240 p->dispsw_data = m2info->cmap.cfb32;
241 p->dispsw = &fbcon_cfb32;
242 break;
243 #endif
244 default:
245 p->dispsw_data = NULL;
246 p->dispsw = &fbcon_dummy;
247 break;
248 }
249 }
250
251 static int matroxfb_dh_open(struct fb_info* info, int user) {
252 #define m2info ((struct matroxfb_dh_fb_info*)info)
253 MINFO_FROM(m2info->primary_dev);
254
255 if (MINFO) {
256 if (ACCESS_FBINFO(dead)) {
257 return -ENXIO;
258 }
259 }
260 return 0;
261 #undef m2info
262 }
263
264 static int matroxfb_dh_release(struct fb_info* info, int user) {
265 #define m2info ((struct matroxfb_dh_fb_info*)info)
266 MINFO_FROM(m2info->primary_dev);
267
268 if (MINFO) {
269 }
270 return 0;
271 #undef m2info
272 }
273
274 static int matroxfb_dh_get_fix(struct fb_fix_screeninfo* fix, int con,
275 struct fb_info* info) {
276 #define m2info ((struct matroxfb_dh_fb_info*)info)
277 struct display* p;
278
279 if (con >= 0)
280 p = fb_display + con;
281 else
282 p = m2info->fbcon.disp;
283
284 memset(fix, 0, sizeof(*fix));
285 strcpy(fix->id, "MATROX DH");
286
287 fix->smem_start = m2info->video.base;
288 fix->smem_len = m2info->video.len_usable;
289 fix->type = p->type;
290 fix->type_aux = p->type_aux;
291 fix->visual = p->visual;
292 fix->xpanstep = 8; /* TBD */
293 fix->ypanstep = 1;
294 fix->ywrapstep = 0;
295 fix->line_length = p->line_length;
296 fix->mmio_start = m2info->mmio.base;
297 fix->mmio_len = m2info->mmio.len;
298 fix->accel = 0; /* no accel... */
299 return 0;
300 #undef m2info
301 }
302
303 static int matroxfb_dh_get_var(struct fb_var_screeninfo* var, int con,
304 struct fb_info* info) {
305 #define m2info ((struct matroxfb_dh_fb_info*)info)
306 if (con < 0)
307 *var = m2info->fbcon.disp->var;
308 else
309 *var = fb_display[con].var;
310 return 0;
311 #undef m2info
312 }
313
314 static int matroxfb_dh_set_var(struct fb_var_screeninfo* var, int con,
315 struct fb_info* info) {
316 #define m2info ((struct matroxfb_dh_fb_info*)info)
317 struct display* p;
318 int chgvar;
319 int visual;
320 int cmap_len;
321 int mode;
322 int err;
323 MINFO_FROM(m2info->primary_dev);
324
325 if (con < 0)
326 p = m2info->fbcon.disp;
327 else
328 p = fb_display + con;
329 if ((err = matroxfb_dh_decode_var(m2info, p, var, &visual, &cmap_len, &mode)) != 0)
330 return err;
331 switch (var->activate & FB_ACTIVATE_MASK) {
332 case FB_ACTIVATE_TEST: return 0;
333 case FB_ACTIVATE_NXTOPEN:
334 case FB_ACTIVATE_NOW: break;
335 default: return -EINVAL;
336 }
337 if (con >= 0) {
338 chgvar = (p->var.xres != var->xres) ||
339 (p->var.yres != var->yres) ||
340 (p->var.xres_virtual != var->xres_virtual) ||
341 (p->var.yres_virtual != var->yres_virtual) ||
342 (p->var.bits_per_pixel != var->bits_per_pixel) ||
343 memcmp(&p->var.red, &var->red, sizeof(var->red)) ||
344 memcmp(&p->var.green, &var->green, sizeof(var->green)) ||
345 memcmp(&p->var.blue, &var->blue, sizeof(var->blue));
346 } else
347 chgvar = 0;
348 p->var = *var;
349 /* cmap */
350 p->screen_base = vaddr_va(m2info->video.vbase);
351 p->visual = visual;
352 p->ypanstep = 1;
353 p->ywrapstep = 0;
354 p->type = FB_TYPE_PACKED_PIXELS;
355 p->type_aux = 0;
356 p->next_line = p->line_length = (var->xres_virtual * var->bits_per_pixel) >> 3;
357 p->can_soft_blank = 0;
358 p->inverse = 0; /* TBD */
359 initMatroxDH(m2info, p);
360 if (chgvar && info && info->changevar)
361 info->changevar(con);
362 if (con == m2info->currcon) {
363 struct my_timming mt;
364 struct matrox_hw_state* hw;
365 struct matrox_hw_state* ohw;
366 unsigned int pos;
367
368 matroxfb_var2my(var, &mt);
369 /* CRTC2 delay */
370 mt.delay = 34;
371
372 hw = ACCESS_FBINFO(newhw);
373 ohw = ACCESS_FBINFO(currenthw);
374
375 /* copy last setting... */
376 memcpy(hw, ohw, sizeof(*hw));
377
378 pos = (var->yoffset * var->xres_virtual + var->xoffset) * var->bits_per_pixel >> 3;
379 pos += m2info->video.offbase;
380 DAC1064_global_init(PMINFO hw);
381 if (ACCESS_FBINFO(output.sh) & MATROXFB_OUTPUT_CONN_PRIMARY) {
382 if (ACCESS_FBINFO(primout))
383 ACCESS_FBINFO(primout)->compute(MINFO, &mt, hw);
384 }
385 if (ACCESS_FBINFO(output.sh) & MATROXFB_OUTPUT_CONN_SECONDARY) {
386 down_read(&ACCESS_FBINFO(altout.lock));
387 if (ACCESS_FBINFO(altout.output))
388 ACCESS_FBINFO(altout.output)->compute(ACCESS_FBINFO(altout.device), &mt, hw);
389 up_read(&ACCESS_FBINFO(altout.lock));
390 }
391 matroxfb_dh_restore(m2info, &mt, p, mode, pos);
392 DAC1064_global_restore(PMINFO hw);
393 if (ACCESS_FBINFO(output.sh) & MATROXFB_OUTPUT_CONN_PRIMARY) {
394 if (ACCESS_FBINFO(primout))
395 ACCESS_FBINFO(primout)->program(MINFO, hw);
396 }
397 if (ACCESS_FBINFO(output.sh) & MATROXFB_OUTPUT_CONN_SECONDARY) {
398 down_read(&ACCESS_FBINFO(altout.lock));
399 if (ACCESS_FBINFO(altout.output))
400 ACCESS_FBINFO(altout.output)->program(ACCESS_FBINFO(altout.device), hw);
401 up_read(&ACCESS_FBINFO(altout.lock));
402 }
403 if (ACCESS_FBINFO(output.sh) & MATROXFB_OUTPUT_CONN_PRIMARY) {
404 if (ACCESS_FBINFO(primout))
405 ACCESS_FBINFO(primout)->start(MINFO);
406 }
407 if (ACCESS_FBINFO(output.sh) & MATROXFB_OUTPUT_CONN_SECONDARY) {
408 down_read(&ACCESS_FBINFO(altout.lock));
409 if (ACCESS_FBINFO(altout.output))
410 ACCESS_FBINFO(altout.output)->start(ACCESS_FBINFO(altout.device));
411 up_read(&ACCESS_FBINFO(altout.lock));
412 }
413 matroxfb_dh_cfbX_init(m2info, p);
414 do_install_cmap(m2info, p);
415 }
416 return 0;
417 #undef m2info
418 }
419
420 static int matroxfb_dh_get_cmap(struct fb_cmap* cmap, int kspc, int con,
421 struct fb_info* info) {
422 #define m2info ((struct matroxfb_dh_fb_info*)info)
423 struct display* dsp;
424
425 if (con < 0)
426 dsp = m2info->fbcon.disp;
427 else
428 dsp = fb_display + con;
429 if (con == m2info->currcon)
430 return fb_get_cmap(cmap, kspc, matroxfb_dh_getcolreg, info);
431 else if (dsp->cmap.len)
432 fb_copy_cmap(&dsp->cmap, cmap, kspc ? 0 : 2);
433 else
434 fb_copy_cmap(fb_default_cmap(16), cmap, kspc ? 0 : 2);
435 return 0;
436 #undef m2info
437 }
438
439 static int matroxfb_dh_set_cmap(struct fb_cmap* cmap, int kspc, int con,
440 struct fb_info* info) {
441 #define m2info ((struct matroxfb_dh_fb_info*)info)
442 struct display* dsp;
443
444 if (con < 0)
445 dsp = m2info->fbcon.disp;
446 else
447 dsp = fb_display + con;
448 if (dsp->cmap.len != 16) {
449 int err;
450
451 err = fb_alloc_cmap(&dsp->cmap, 16, 0);
452 if (err)
453 return err;
454 }
455 if (con == m2info->currcon)
456 return fb_set_cmap(cmap, kspc, matroxfb_dh_setcolreg, info);
457 else
458 fb_copy_cmap(cmap, &dsp->cmap, kspc ? 0 : 1);
459 return 0;
460 #undef m2info
461 }
462
463 static int matroxfb_dh_pan_display(struct fb_var_screeninfo* var, int con,
464 struct fb_info* info) {
465 #define m2info ((struct matroxfb_dh_fb_info*)info)
466 if (var->xoffset + fb_display[con].var.xres > fb_display[con].var.xres_virtual ||
467 var->yoffset + fb_display[con].var.yres > fb_display[con].var.yres_virtual)
468 return -EINVAL;
469 if (con == m2info->currcon)
470 matroxfb_dh_pan_var(m2info, var);
471 fb_display[con].var.xoffset = var->xoffset;
472 fb_display[con].var.yoffset = var->yoffset;
473 return 0;
474 #undef m2info
475 }
476
477 static int matroxfb_dh_switch(int con, struct fb_info* info);
478
479 static int matroxfb_dh_get_vblank(const struct matroxfb_dh_fb_info* m2info, struct fb_vblank* vblank) {
480 MINFO_FROM(m2info->primary_dev);
481
482 memset(vblank, 0, sizeof(*vblank));
483 vblank->flags = FB_VBLANK_HAVE_VCOUNT | FB_VBLANK_HAVE_VBLANK;
484 /* mask out reserved bits + field number (odd/even) */
485 vblank->vcount = mga_inl(0x3C48) & 0x000007FF;
486 /* compatibility stuff */
487 if (vblank->vcount >= m2info->currcon_display->var.yres)
488 vblank->flags |= FB_VBLANK_VBLANKING;
489 return 0;
490 }
491
492 static int matroxfb_dh_ioctl(struct inode* inode,
493 struct file* file,
494 unsigned int cmd,
495 unsigned long arg,
496 int con,
497 struct fb_info* info) {
498 #define m2info ((struct matroxfb_dh_fb_info*)info)
499 MINFO_FROM(m2info->primary_dev);
500
501 DBG("matroxfb_crtc2_ioctl")
502
503 switch (cmd) {
504 case FBIOGET_VBLANK:
505 {
506 struct fb_vblank vblank;
507 int err;
508
509 err = matroxfb_dh_get_vblank(m2info, &vblank);
510 if (err)
511 return err;
512 if (copy_to_user((struct fb_vblank*)arg, &vblank, sizeof(vblank)))
513 return -EFAULT;
514 return 0;
515 }
516 case MATROXFB_SET_OUTPUT_MODE:
517 case MATROXFB_GET_OUTPUT_MODE:
518 case MATROXFB_GET_ALL_OUTPUTS:
519 {
520 return ACCESS_FBINFO(fbcon.fbops)->fb_ioctl(inode, file, cmd, arg, con, &ACCESS_FBINFO(fbcon));
521 }
522 case MATROXFB_SET_OUTPUT_CONNECTION:
523 {
524 u_int32_t tmp;
525
526 if (get_user(tmp, (u_int32_t*)arg))
527 return -EFAULT;
528 if (tmp & ~ACCESS_FBINFO(output.all))
529 return -EINVAL;
530 if (tmp & ACCESS_FBINFO(output.ph))
531 return -EINVAL;
532 if (tmp & MATROXFB_OUTPUT_CONN_DFP)
533 return -EINVAL;
534 if ((ACCESS_FBINFO(output.ph) & MATROXFB_OUTPUT_CONN_DFP) && tmp)
535 return -EINVAL;
536 if (tmp == ACCESS_FBINFO(output.sh))
537 return 0;
538 ACCESS_FBINFO(output.sh) = tmp;
539 matroxfb_dh_switch(m2info->currcon, info);
540 return 0;
541 }
542 case MATROXFB_GET_OUTPUT_CONNECTION:
543 {
544 if (put_user(ACCESS_FBINFO(output.sh), (u_int32_t*)arg))
545 return -EFAULT;
546 return 0;
547 }
548 case MATROXFB_GET_AVAILABLE_OUTPUTS:
549 {
550 u_int32_t tmp;
551
552 /* we do not support DFP from CRTC2 */
553 tmp = ACCESS_FBINFO(output.all) & ~ACCESS_FBINFO(output.ph) & ~MATROXFB_OUTPUT_CONN_DFP;
554 /* CRTC1 in DFP mode disables CRTC2 at all (I know, I'm lazy) */
555 if (ACCESS_FBINFO(output.ph) & MATROXFB_OUTPUT_CONN_DFP)
556 tmp = 0;
557 if (put_user(tmp, (u_int32_t*)arg))
558 return -EFAULT;
559 return 0;
560 }
561 }
562 return -EINVAL;
563 #undef m2info
564 }
565
566 static struct fb_ops matroxfb_dh_ops = {
567 owner: THIS_MODULE,
568 fb_open: matroxfb_dh_open,
569 fb_release: matroxfb_dh_release,
570 fb_get_fix: matroxfb_dh_get_fix,
571 fb_get_var: matroxfb_dh_get_var,
572 fb_set_var: matroxfb_dh_set_var,
573 fb_get_cmap: matroxfb_dh_get_cmap,
574 fb_set_cmap: matroxfb_dh_set_cmap,
575 fb_pan_display: matroxfb_dh_pan_display,
576 fb_ioctl: matroxfb_dh_ioctl,
577 };
578
579 static int matroxfb_dh_switch(int con, struct fb_info* info) {
580 #define m2info ((struct matroxfb_dh_fb_info*)info)
581 struct fb_cmap* cmap;
582 struct display* p;
583
584 if (m2info->currcon >= 0) {
585 cmap = &m2info->currcon_display->cmap;
586 if (cmap->len) {
587 fb_get_cmap(cmap, 1, matroxfb_dh_getcolreg, info);
588 }
589 }
590 m2info->currcon = con;
591 if (con < 0)
592 p = m2info->fbcon.disp;
593 else
594 p = fb_display + con;
595 m2info->currcon_display = p;
596 p->var.activate = FB_ACTIVATE_NOW;
597 matroxfb_dh_set_var(&p->var, con, info);
598 return 0;
599 #undef m2info
600 }
601
602 static int matroxfb_dh_updatevar(int con, struct fb_info* info) {
603 #define m2info ((struct matroxfb_dh_fb_info*)info)
604 matroxfb_dh_pan_var(m2info, &fb_display[con].var);
605 return 0;
606 #undef m2info
607 }
608
609 static void matroxfb_dh_blank(int blank, struct fb_info* info) {
610 #define m2info ((struct matroxfb_dh_fb_info*)info)
611 switch (blank) {
612 case 1:
613 case 2:
614 case 3:
615 case 4:
616 default:;
617 }
618 /* do something... */
619 #undef m2info
620 }
621
622 static struct fb_var_screeninfo matroxfb_dh_defined = {
623 640,480,640,480,/* W,H, virtual W,H */
624 0,0, /* offset */
625 32, /* depth */
626 0, /* gray */
627 {0,0,0}, /* R */
628 {0,0,0}, /* G */
629 {0,0,0}, /* B */
630 {0,0,0}, /* alpha */
631 0, /* nonstd */
632 FB_ACTIVATE_NOW,
633 -1,-1, /* display size */
634 0, /* accel flags */
635 39721L,48L,16L,33L,10L,
636 96L,2,0, /* no sync info */
637 FB_VMODE_NONINTERLACED,
638 {0,0,0,0,0,0}
639 };
640
641 static int matroxfb_dh_regit(CPMINFO struct matroxfb_dh_fb_info* m2info) {
642 #define minfo (m2info->primary_dev)
643 struct display* d;
644 void* oldcrtc2;
645
646 d = kmalloc(sizeof(*d), GFP_KERNEL);
647
648 memset(d, 0, sizeof(*d));
649
650 strcpy(m2info->fbcon.modename, "MATROX CRTC2");
651 m2info->fbcon.changevar = NULL;
652 m2info->fbcon.node = -1;
653 m2info->fbcon.fbops = &matroxfb_dh_ops;
654 m2info->fbcon.disp = d;
655 m2info->fbcon.switch_con = &matroxfb_dh_switch;
656 m2info->fbcon.updatevar = &matroxfb_dh_updatevar;
657 m2info->fbcon.blank = &matroxfb_dh_blank;
658 m2info->fbcon.flags = FBINFO_FLAG_DEFAULT;
659 m2info->currcon = -1;
660 m2info->currcon_display = d;
661
662 if (mem < 64)
663 mem *= 1024;
664 if (mem < 64*1024)
665 mem *= 1024;
666 mem &= ~0x00000FFF; /* PAGE_MASK? */
667 if (ACCESS_FBINFO(video.len_usable) + mem <= ACCESS_FBINFO(video.len))
668 m2info->video.offbase = ACCESS_FBINFO(video.len) - mem;
669 else if (ACCESS_FBINFO(video.len) < mem) {
670 kfree(d);
671 return -ENOMEM;
672 } else { /* check yres on first head... */
673 m2info->video.borrowed = mem;
674 ACCESS_FBINFO(video.len_usable) -= mem;
675 m2info->video.offbase = ACCESS_FBINFO(video.len_usable);
676 }
677 m2info->video.base = ACCESS_FBINFO(video.base) + m2info->video.offbase;
678 m2info->video.len = m2info->video.len_usable = m2info->video.len_maximum = mem;
679 m2info->video.vbase.vaddr = vaddr_va(ACCESS_FBINFO(video.vbase)) + m2info->video.offbase;
680 m2info->mmio.base = ACCESS_FBINFO(mmio.base);
681 m2info->mmio.vbase = ACCESS_FBINFO(mmio.vbase);
682 m2info->mmio.len = ACCESS_FBINFO(mmio.len);
683
684 /*
685 * If we have two outputs, connect CRTC2 to it...
686 */
687 if (ACCESS_FBINFO(output.all) & MATROXFB_OUTPUT_CONN_SECONDARY) {
688 ACCESS_FBINFO(output.sh) |= MATROXFB_OUTPUT_CONN_SECONDARY;
689 ACCESS_FBINFO(output.ph) &= ~MATROXFB_OUTPUT_CONN_SECONDARY;
690 if (ACCESS_FBINFO(output.all) & MATROXFB_OUTPUT_CONN_DFP) {
691 ACCESS_FBINFO(output.sh) &= ~MATROXFB_OUTPUT_CONN_DFP;
692 ACCESS_FBINFO(output.ph) &= ~MATROXFB_OUTPUT_CONN_DFP;
693 }
694 }
695
696 matroxfb_dh_set_var(&matroxfb_dh_defined, -2, &m2info->fbcon);
697 if (register_framebuffer(&m2info->fbcon)) {
698 kfree(d);
699 return -ENXIO;
700 }
701 if (m2info->currcon < 0) {
702 matroxfb_dh_set_var(&matroxfb_dh_defined, -1, &m2info->fbcon);
703 }
704 down_write(&ACCESS_FBINFO(crtc2.lock));
705 oldcrtc2 = ACCESS_FBINFO(crtc2.info);
706 ACCESS_FBINFO(crtc2.info) = &m2info->fbcon;
707 up_write(&ACCESS_FBINFO(crtc2.lock));
708 if (oldcrtc2) {
709 printk(KERN_ERR "matroxfb_crtc2: Internal consistency check failed: crtc2 already present: %p\n",
710 oldcrtc2);
711 }
712 return 0;
713 #undef minfo
714 }
715
716 /* ************************** */
717
718 static int matroxfb_dh_registerfb(struct matroxfb_dh_fb_info* m2info) {
719 #define minfo (m2info->primary_dev)
720 if (matroxfb_dh_regit(PMINFO m2info)) {
721 printk(KERN_ERR "matroxfb_crtc2: secondary head failed to register\n");
722 return -1;
723 }
724 printk(KERN_INFO "matroxfb_crtc2: secondary head of fb%u was registered as fb%u\n",
725 GET_FB_IDX(ACCESS_FBINFO(fbcon.node)), GET_FB_IDX(m2info->fbcon.node));
726 m2info->fbcon_registered = 1;
727 return 0;
728 #undef minfo
729 }
730
731 static void matroxfb_dh_deregisterfb(struct matroxfb_dh_fb_info* m2info) {
732 #define minfo (m2info->primary_dev)
733 if (m2info->fbcon_registered) {
734 int id;
735 struct fb_info* crtc2;
736
737 down_write(&ACCESS_FBINFO(crtc2.lock));
738 crtc2 = ACCESS_FBINFO(crtc2.info);
739 if (crtc2 == &m2info->fbcon)
740 ACCESS_FBINFO(crtc2.info) = NULL;
741 up_write(&ACCESS_FBINFO(crtc2.lock));
742 if (crtc2 != &m2info->fbcon) {
743 printk(KERN_ERR "matroxfb_crtc2: Internal consistency check failed: crtc2 mismatch at unload: %p != %p\n",
744 crtc2, &m2info->fbcon);
745 printk(KERN_ERR "matroxfb_crtc2: Expect kernel crash after module unload.\n");
746 return;
747 }
748 id = GET_FB_IDX(m2info->fbcon.node);
749 unregister_framebuffer(&m2info->fbcon);
750 kfree(m2info->fbcon.disp);
751 /* return memory back to primary head */
752 ACCESS_FBINFO(video.len_usable) += m2info->video.borrowed;
753 printk(KERN_INFO "matroxfb_crtc2: fb%u unregistered\n", id);
754 m2info->fbcon_registered = 0;
755 }
756 #undef minfo
757 }
758
759 static void* matroxfb_crtc2_probe(struct matrox_fb_info* minfo) {
760 struct matroxfb_dh_fb_info* m2info;
761
762 /* hardware is CRTC2 incapable... */
763 if (!ACCESS_FBINFO(devflags.crtc2))
764 return NULL;
765 m2info = (struct matroxfb_dh_fb_info*)kmalloc(sizeof(*m2info), GFP_KERNEL);
766 if (!m2info) {
767 printk(KERN_ERR "matroxfb_crtc2: Not enough memory for CRTC2 control structs\n");
768 return NULL;
769 }
770 memset(m2info, 0, sizeof(*m2info));
771 m2info->primary_dev = MINFO;
772 if (matroxfb_dh_registerfb(m2info)) {
773 kfree(m2info);
774 printk(KERN_ERR "matroxfb_crtc2: CRTC2 framebuffer failed to register\n");
775 return NULL;
776 }
777 return m2info;
778 }
779
780 static void matroxfb_crtc2_remove(struct matrox_fb_info* minfo, void* crtc2) {
781 matroxfb_dh_deregisterfb(crtc2);
782 }
783
784 static struct matroxfb_driver crtc2 = {
785 name: "Matrox G400 CRTC2",
786 probe: matroxfb_crtc2_probe,
787 remove: matroxfb_crtc2_remove };
788
789 static int matroxfb_crtc2_init(void) {
790 matroxfb_register_driver(&crtc2);
791 return 0;
792 }
793
794 static void matroxfb_crtc2_exit(void) {
795 matroxfb_unregister_driver(&crtc2);
796 }
797
798 MODULE_AUTHOR("(c) 1999,2000 Petr Vandrovec <vandrove@vc.cvut.cz>");
799 MODULE_DESCRIPTION("Matrox G400 CRTC2 driver");
800 module_init(matroxfb_crtc2_init);
801 module_exit(matroxfb_crtc2_exit);
802 /* we do not have __setup() yet */
Copy of Dave Jones history.git as used by http://archive.org/details/git-history-of-linux