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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
matroxfb_crtc2.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：23k
源码类别：

嵌入式Linux

开发平台：

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