开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
matroxfb_crtc2.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：23k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

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