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

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

嵌入式Linux

开发平台：

Unix_Linux

matroxfb_DAC1064.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.54 2001/09/09
  8.  *
  9.  * See matroxfb_base.c for contributors.
  10.  *
  11.  */
  13. /* make checkconfig does not walk through include tree :-( */
  14. #include <linux/config.h>
  16. #include "matroxfb_DAC1064.h"
  17. #include "matroxfb_misc.h"
  18. #include "matroxfb_accel.h"
  19. #include <linux/matroxfb.h>
  21. #ifdef NEED_DAC1064
  22. #define outDAC1064 matroxfb_DAC_out
  23. #define inDAC1064 matroxfb_DAC_in
  25. #define DAC1064_OPT_SCLK_PCI 0x00
  26. #define DAC1064_OPT_SCLK_PLL 0x01
  27. #define DAC1064_OPT_SCLK_EXT 0x02
  28. #define DAC1064_OPT_SCLK_MASK 0x03
  29. #define DAC1064_OPT_GDIV1 0x04 /* maybe it is GDIV2 on G100 ?! */
  30. #define DAC1064_OPT_GDIV3 0x00
  31. #define DAC1064_OPT_MDIV1 0x08
  32. #define DAC1064_OPT_MDIV2 0x00
  33. #define DAC1064_OPT_RESERVED 0x10
  35. static void matroxfb_DAC1064_flashcursor(unsigned long ptr) {
  36. unsigned long flags;
  38. #define minfo ((struct matrox_fb_info*)ptr)
  39. matroxfb_DAC_lock_irqsave(flags);
  40. outDAC1064(PMINFO M1064_XCURCTRL, inDAC1064(PMINFO M1064_XCURCTRL) ^ M1064_XCURCTRL_DIS ^ M1064_XCURCTRL_XGA);
  41. ACCESS_FBINFO(cursor.timer.expires) = jiffies + HZ/2;
  42. add_timer(&ACCESS_FBINFO(cursor.timer));
  43. matroxfb_DAC_unlock_irqrestore(flags);
  44. #undef minfo
  45. }
  47. static void matroxfb_DAC1064_createcursor(WPMINFO struct display* p) {
  48. vaddr_t cursorbase;
  49. u_int32_t xline;
  50. unsigned int i;
  51. unsigned int h, to;
  52. CRITFLAGS
  54. if (ACCESS_FBINFO(currcon_display) != p)
  55. return;
  57. matroxfb_createcursorshape(PMINFO p, p->var.vmode);
  59. xline = (~0) << (32 - ACCESS_FBINFO(cursor.w));
  60. cursorbase = ACCESS_FBINFO(video.vbase);
  61. h = ACCESS_FBINFO(features.DAC1064.cursorimage);
  63. CRITBEGIN
  65. #ifdef __BIG_ENDIAN
  66. WaitTillIdle();
  67. mga_outl(M_OPMODE, M_OPMODE_32BPP);
  68. #endif
  69. to = ACCESS_FBINFO(cursor.u);
  70. for (i = 0; i < to; i++) {
  71. mga_writel(cursorbase, h, 0);
  72. mga_writel(cursorbase, h+4, 0);
  73. mga_writel(cursorbase, h+8, ~0);
  74. mga_writel(cursorbase, h+12, ~0);
  75. h += 16;
  76. }
  77. to = ACCESS_FBINFO(cursor.d);
  78. for (; i < to; i++) {
  79. mga_writel(cursorbase, h, 0);
  80. mga_writel(cursorbase, h+4, xline);
  81. mga_writel(cursorbase, h+8, ~0);
  82. mga_writel(cursorbase, h+12, ~0);
  83. h += 16;
  84. }
  85. for (; i < 64; i++) {
  86. mga_writel(cursorbase, h, 0);
  87. mga_writel(cursorbase, h+4, 0);
  88. mga_writel(cursorbase, h+8, ~0);
  89. mga_writel(cursorbase, h+12, ~0);
  90. h += 16;
  91. }
  92. #ifdef __BIG_ENDIAN
  93. mga_outl(M_OPMODE, ACCESS_FBINFO(accel.m_opmode));
  94. #endif
  96. CRITEND
  97. }
  99. static void matroxfb_DAC1064_cursor(struct display* p, int mode, int x, int y) {
  100. unsigned long flags;
  101. MINFO_FROM_DISP(p);
  103. if (ACCESS_FBINFO(currcon_display) != p)
  104. return;
  106. if (mode == CM_ERASE) {
  107. if (ACCESS_FBINFO(cursor.state) != CM_ERASE) {
  108. del_timer_sync(&ACCESS_FBINFO(cursor.timer));
  109. matroxfb_DAC_lock_irqsave(flags);
  110. ACCESS_FBINFO(cursor.state) = CM_ERASE;
  111. outDAC1064(PMINFO M1064_XCURCTRL, M1064_XCURCTRL_DIS);
  112. matroxfb_DAC_unlock_irqrestore(flags);
  113. }
  114. return;
  115. }
  116. if ((p->conp->vc_cursor_type & CUR_HWMASK) != ACCESS_FBINFO(cursor.type))
  117. matroxfb_DAC1064_createcursor(PMINFO p);
  118. x *= fontwidth(p);
  119. y *= fontheight(p);
  120. y -= p->var.yoffset;
  121. if (p->var.vmode & FB_VMODE_DOUBLE)
  122. y *= 2;
  123. del_timer_sync(&ACCESS_FBINFO(cursor.timer));
  124. matroxfb_DAC_lock_irqsave(flags);
  125. if ((x != ACCESS_FBINFO(cursor.x)) || (y != ACCESS_FBINFO(cursor.y)) || ACCESS_FBINFO(cursor.redraw)) {
  126. ACCESS_FBINFO(cursor.redraw) = 0;
  127. ACCESS_FBINFO(cursor.x) = x;
  128. ACCESS_FBINFO(cursor.y) = y;
  129. x += 64;
  130. y += 64;
  131. outDAC1064(PMINFO M1064_XCURCTRL, M1064_XCURCTRL_DIS);
  132. mga_outb(M_RAMDAC_BASE+M1064_CURPOSXL, x);
  133. mga_outb(M_RAMDAC_BASE+M1064_CURPOSXH, x >> 8);
  134. mga_outb(M_RAMDAC_BASE+M1064_CURPOSYL, y);
  135. mga_outb(M_RAMDAC_BASE+M1064_CURPOSYH, y >> 8);
  136. }
  137. ACCESS_FBINFO(cursor.state) = CM_DRAW;
  138. if (ACCESS_FBINFO(devflags.blink))
  139. mod_timer(&ACCESS_FBINFO(cursor.timer), jiffies + HZ/2);
  140. outDAC1064(PMINFO M1064_XCURCTRL, M1064_XCURCTRL_XGA);
  141. matroxfb_DAC_unlock_irqrestore(flags);
  142. }
  144. static int matroxfb_DAC1064_setfont(struct display* p, int width, int height) {
  145. if (p && p->conp)
  146. matroxfb_DAC1064_createcursor(PMXINFO(p) p);
  147. return 0;
  148. }
  150. static int DAC1064_selhwcursor(WPMINFO struct display* p) {
  151. ACCESS_FBINFO(dispsw.cursor) = matroxfb_DAC1064_cursor;
  152. ACCESS_FBINFO(dispsw.set_font) = matroxfb_DAC1064_setfont;
  153. return 0;
  154. }
  156. static void DAC1064_calcclock(CPMINFO unsigned int freq, unsigned int fmax, unsigned int* in, unsigned int* feed, unsigned int* post) {
  157. unsigned int fvco;
  158. unsigned int p;
  160. DBG("DAC1064_calcclock")
  162. fvco = PLL_calcclock(PMINFO freq, fmax, in, feed, &p);
  164. if (ACCESS_FBINFO(devflags.g450dac)) {
  165. if (fvco <= 300000) /* 276-324 */
  166. ;
  167. else if (fvco <= 400000) /* 378-438 */
  168. p |= 0x08;
  169. else if (fvco <= 550000) /* 540-567 */
  170. p |= 0x10;
  171. else if (fvco <= 690000) /* 675-695 */
  172. p |= 0x18;
  173. else if (fvco <= 800000) /* 776-803 */
  174. p |= 0x20;
  175. else if (fvco <= 891000) /* 891-891 */
  176. p |= 0x28;
  177. else if (fvco <= 940000) /* 931-945 */
  178. p |= 0x30;
  179. else /* <959 */
  180. p |= 0x38;
  181. } else {
  182. p = (1 << p) - 1;
  183. if (fvco <= 100000)
  184. ;
  185. else if (fvco <= 140000)
  186. p |= 0x08;
  187. else if (fvco <= 180000)
  188. p |= 0x10;
  189. else
  190. p |= 0x18;
  191. }
  192. *post = p;
  193. }
  195. /* they must be in POS order */
  196. static const unsigned char MGA1064_DAC_regs[] = {
  197. M1064_XCURADDL, M1064_XCURADDH, M1064_XCURCTRL,
  198. M1064_XCURCOL0RED, M1064_XCURCOL0GREEN, M1064_XCURCOL0BLUE,
  199. M1064_XCURCOL1RED, M1064_XCURCOL1GREEN, M1064_XCURCOL1BLUE,
  200. M1064_XCURCOL2RED, M1064_XCURCOL2GREEN, M1064_XCURCOL2BLUE,
  201. DAC1064_XVREFCTRL, M1064_XMULCTRL, M1064_XPIXCLKCTRL, M1064_XGENCTRL,
  202. M1064_XMISCCTRL,
  203. M1064_XGENIOCTRL, M1064_XGENIODATA, M1064_XZOOMCTRL, M1064_XSENSETEST,
  204. M1064_XCRCBITSEL,
  205. M1064_XCOLKEYMASKL, M1064_XCOLKEYMASKH, M1064_XCOLKEYL, M1064_XCOLKEYH };
  207. static const unsigned char MGA1064_DAC[] = {
  208. 0x00, 0x00, M1064_XCURCTRL_DIS,
  209. 0x00, 0x00, 0x00,  /* black */
  210. 0xFF, 0xFF, 0xFF, /* white */
  211. 0xFF, 0x00, 0x00, /* red */
  212. 0x00, 0,
  213. M1064_XPIXCLKCTRL_PLL_UP | M1064_XPIXCLKCTRL_EN | M1064_XPIXCLKCTRL_SRC_PLL,
  214. M1064_XGENCTRL_VS_0 | M1064_XGENCTRL_ALPHA_DIS | M1064_XGENCTRL_BLACK_0IRE | M1064_XGENCTRL_NO_SYNC_ON_GREEN,
  215. M1064_XMISCCTRL_DAC_8BIT,
  216. 0x00, 0x00, M1064_XZOOMCTRL_1, M1064_XSENSETEST_BCOMP | M1064_XSENSETEST_GCOMP | M1064_XSENSETEST_RCOMP | M1064_XSENSETEST_PDOWN,
  217. 0x00,
  218. 0x00, 0x00, 0xFF, 0xFF};
  220. static void DAC1064_setpclk(CPMINFO struct matrox_hw_state* hw, unsigned long fout) {
  221. unsigned int m, n, p;
  223. DBG("DAC1064_setpclk")
  225. DAC1064_calcclock(PMINFO fout, ACCESS_FBINFO(max_pixel_clock), &m, &n, &p);
  226. hw->DACclk[0] = m;
  227. hw->DACclk[1] = n;
  228. hw->DACclk[2] = p;
  229. }
  231. static void DAC1064_setmclk(CPMINFO struct matrox_hw_state* hw, int oscinfo, unsigned long fmem){
  232. u_int32_t mx;
  234. DBG("DAC1064_setmclk")
  236. if (ACCESS_FBINFO(devflags.noinit)) {
  237. /* read MCLK and give up... */
  238. hw->DACclk[3] = inDAC1064(PMINFO DAC1064_XSYSPLLM);
  239. hw->DACclk[4] = inDAC1064(PMINFO DAC1064_XSYSPLLN);
  240. hw->DACclk[5] = inDAC1064(PMINFO DAC1064_XSYSPLLP);
  241. return;
  242. }
  243. mx = hw->MXoptionReg | 0x00000004;
  244. pci_write_config_dword(ACCESS_FBINFO(pcidev), PCI_OPTION_REG, mx);
  245. mx &= ~0x000000BB;
  246. if (oscinfo & DAC1064_OPT_GDIV1)
  247. mx |= 0x00000008;
  248. if (oscinfo & DAC1064_OPT_MDIV1)
  249. mx |= 0x00000010;
  250. if (oscinfo & DAC1064_OPT_RESERVED)
  251. mx |= 0x00000080;
  252. if ((oscinfo & DAC1064_OPT_SCLK_MASK) == DAC1064_OPT_SCLK_PLL) {
  253. /* select PCI clock until we have setup oscilator... */
  254. int clk;
  255. unsigned int m, n, p;
  257. /* powerup system PLL, select PCI clock */
  258. mx |= 0x00000020;
  259. pci_write_config_dword(ACCESS_FBINFO(pcidev), PCI_OPTION_REG, mx);
  260. mx &= ~0x00000004;
  261. pci_write_config_dword(ACCESS_FBINFO(pcidev), PCI_OPTION_REG, mx);
  263. /* !!! you must not access device if MCLK is not running !!!
  264.    Doing so cause immediate PCI lockup :-( Maybe they should
  265.    generate ABORT or I/O (parity...) error and Linux should
  266.    recover from this... (kill driver/process). But world is not
  267.    perfect... */
  268. /* (bit 2 of PCI_OPTION_REG must be 0... and bits 0,1 must not
  269.    select PLL... because of PLL can be stopped at this time) */
  270. DAC1064_calcclock(PMINFO fmem, ACCESS_FBINFO(max_pixel_clock), &m, &n, &p);
  271. outDAC1064(PMINFO DAC1064_XSYSPLLM, hw->DACclk[3] = m);
  272. outDAC1064(PMINFO DAC1064_XSYSPLLN, hw->DACclk[4] = n);
  273. outDAC1064(PMINFO DAC1064_XSYSPLLP, hw->DACclk[5] = p);
  274. for (clk = 65536; clk; --clk) {
  275. if (inDAC1064(PMINFO DAC1064_XSYSPLLSTAT) & 0x40)
  276. break;
  277. }
  278. if (!clk)
  279. printk(KERN_ERR "matroxfb: aiee, SYSPLL not lockedn");
  280. /* select PLL */
  281. mx |= 0x00000005;
  282. } else {
  283. /* select specified system clock source */
  284. mx |= oscinfo & DAC1064_OPT_SCLK_MASK;
  285. }
  286. pci_write_config_dword(ACCESS_FBINFO(pcidev), PCI_OPTION_REG, mx);
  287. mx &= ~0x00000004;
  288. pci_write_config_dword(ACCESS_FBINFO(pcidev), PCI_OPTION_REG, mx);
  289. hw->MXoptionReg = mx;
  290. }
  292. void DAC1064_global_init(CPMINFO struct matrox_hw_state* hw) {
  293. hw->DACreg[POS1064_XMISCCTRL] &= M1064_XMISCCTRL_DAC_WIDTHMASK;
  294. hw->DACreg[POS1064_XMISCCTRL] |= M1064_XMISCCTRL_LUT_EN;
  295. hw->DACreg[POS1064_XPIXCLKCTRL] = M1064_XPIXCLKCTRL_PLL_UP | M1064_XPIXCLKCTRL_EN | M1064_XPIXCLKCTRL_SRC_PLL;
  296. hw->DACreg[POS1064_XOUTPUTCONN] = 0x01; /* output #1 enabled */
  297. if (ACCESS_FBINFO(output.ph) & MATROXFB_OUTPUT_CONN_SECONDARY) {
  298. if (ACCESS_FBINFO(devflags.g450dac)) {
  299. hw->DACreg[POS1064_XPIXCLKCTRL] = M1064_XPIXCLKCTRL_PLL_UP | M1064_XPIXCLKCTRL_EN | M1064_XPIXCLKCTRL_SRC_PLL2;
  300. hw->DACreg[POS1064_XOUTPUTCONN] = 0x05; /* output #1 enabled; CRTC1 connected to output #2 */
  301. } else {
  302. hw->DACreg[POS1064_XPIXCLKCTRL] = M1064_XPIXCLKCTRL_PLL_UP | M1064_XPIXCLKCTRL_EN | M1064_XPIXCLKCTRL_SRC_EXT;
  303. hw->DACreg[POS1064_XMISCCTRL] |= GX00_XMISCCTRL_MFC_MAFC | G400_XMISCCTRL_VDO_MAFC12;
  304. }
  305. } else if (ACCESS_FBINFO(output.sh) & MATROXFB_OUTPUT_CONN_SECONDARY) {
  306. hw->DACreg[POS1064_XMISCCTRL] |= GX00_XMISCCTRL_MFC_MAFC | G400_XMISCCTRL_VDO_C2_MAFC12;
  307. hw->DACreg[POS1064_XOUTPUTCONN] = 0x09; /* output #1 enabled; CRTC2 connected to output #2 */
  308. } else if (ACCESS_FBINFO(output.ph) & MATROXFB_OUTPUT_CONN_DFP)
  309. hw->DACreg[POS1064_XMISCCTRL] |= GX00_XMISCCTRL_MFC_PANELLINK | G400_XMISCCTRL_VDO_MAFC12;
  310. else
  311. hw->DACreg[POS1064_XMISCCTRL] |= GX00_XMISCCTRL_MFC_DIS;
  313. if ((ACCESS_FBINFO(output.ph) | ACCESS_FBINFO(output.sh)) & MATROXFB_OUTPUT_CONN_PRIMARY)
  314. hw->DACreg[POS1064_XMISCCTRL] |= M1064_XMISCCTRL_DAC_EN;
  315. }
  317. void DAC1064_global_restore(CPMINFO const struct matrox_hw_state* hw) {
  318. outDAC1064(PMINFO M1064_XPIXCLKCTRL, hw->DACreg[POS1064_XPIXCLKCTRL]);
  319. outDAC1064(PMINFO M1064_XMISCCTRL, hw->DACreg[POS1064_XMISCCTRL]);
  320. if (ACCESS_FBINFO(devflags.accelerator) == FB_ACCEL_MATROX_MGAG400) {
  321. outDAC1064(PMINFO 0x20, 0x04);
  322. outDAC1064(PMINFO 0x1F, ACCESS_FBINFO(devflags.dfp_type));
  323. if (ACCESS_FBINFO(devflags.g450dac)) {
  324. outDAC1064(PMINFO M1064_XSYNCCTRL, 0xCC); /* only matrox know... */
  325. outDAC1064(PMINFO M1064_XPWRCTRL, 0x1F); /* powerup everything */
  326. outDAC1064(PMINFO M1064_XOUTPUTCONN, hw->DACreg[POS1064_XOUTPUTCONN]);
  327. }
  328. }
  329. }
  331. static int DAC1064_init_1(CPMINFO struct matrox_hw_state* hw, struct my_timming* m, struct display *p) {
  332. DBG("DAC1064_init_1")
  334. memcpy(hw->DACreg, MGA1064_DAC, sizeof(MGA1064_DAC_regs));
  335. if (p->type == FB_TYPE_TEXT) {
  336. hw->DACreg[POS1064_XMISCCTRL] = M1064_XMISCCTRL_DAC_6BIT;
  337. hw->DACreg[POS1064_XMULCTRL] = M1064_XMULCTRL_DEPTH_8BPP
  338.      | M1064_XMULCTRL_GRAPHICS_PALETIZED;
  339. } else {
  340. switch (p->var.bits_per_pixel) {
  341. /* case 4: not supported by MGA1064 DAC */
  342. case 8:
  343. hw->DACreg[POS1064_XMULCTRL] = M1064_XMULCTRL_DEPTH_8BPP | M1064_XMULCTRL_GRAPHICS_PALETIZED;
  344. break;
  345. case 16:
  346. if (p->var.green.length == 5)
  347. hw->DACreg[POS1064_XMULCTRL] = M1064_XMULCTRL_DEPTH_15BPP_1BPP | M1064_XMULCTRL_GRAPHICS_PALETIZED;
  348. else
  349. hw->DACreg[POS1064_XMULCTRL] = M1064_XMULCTRL_DEPTH_16BPP | M1064_XMULCTRL_GRAPHICS_PALETIZED;
  350. break;
  351. case 24:
  352. hw->DACreg[POS1064_XMULCTRL] = M1064_XMULCTRL_DEPTH_24BPP | M1064_XMULCTRL_GRAPHICS_PALETIZED;
  353. break;
  354. case 32:
  355. hw->DACreg[POS1064_XMULCTRL] = M1064_XMULCTRL_DEPTH_32BPP | M1064_XMULCTRL_GRAPHICS_PALETIZED;
  356. break;
  357. default:
  358. return 1; /* unsupported depth */
  359. }
  360. }
  362. DAC1064_global_init(PMINFO hw);
  363. hw->DACreg[POS1064_XVREFCTRL] = ACCESS_FBINFO(features.DAC1064.xvrefctrl);
  364. hw->DACreg[POS1064_XGENCTRL] &= ~M1064_XGENCTRL_SYNC_ON_GREEN_MASK;
  365. hw->DACreg[POS1064_XGENCTRL] |= (m->sync & FB_SYNC_ON_GREEN)?M1064_XGENCTRL_SYNC_ON_GREEN:M1064_XGENCTRL_NO_SYNC_ON_GREEN;
  366. hw->DACreg[POS1064_XCURADDL] = ACCESS_FBINFO(features.DAC1064.cursorimage) >> 10;
  367. hw->DACreg[POS1064_XCURADDH] = ACCESS_FBINFO(features.DAC1064.cursorimage) >> 18;
  368. return 0;
  369. }
  371. static int DAC1064_init_2(CPMINFO struct matrox_hw_state* hw, struct my_timming* m, struct display* p) {
  373. DBG("DAC1064_init_2")
  375. if (p->var.bits_per_pixel > 16) { /* 256 entries */
  376. int i;
  378. for (i = 0; i < 256; i++) {
  379. hw->DACpal[i * 3 + 0] = i;
  380. hw->DACpal[i * 3 + 1] = i;
  381. hw->DACpal[i * 3 + 2] = i;
  382. }
  383. } else if (p->var.bits_per_pixel > 8) {
  384. if (p->var.green.length == 5) { /* 0..31, 128..159 */
  385. int i;
  387. for (i = 0; i < 32; i++) {
  388. /* with p15 == 0 */
  389. hw->DACpal[i * 3 + 0] = i << 3;
  390. hw->DACpal[i * 3 + 1] = i << 3;
  391. hw->DACpal[i * 3 + 2] = i << 3;
  392. /* with p15 == 1 */
  393. hw->DACpal[(i + 128) * 3 + 0] = i << 3;
  394. hw->DACpal[(i + 128) * 3 + 1] = i << 3;
  395. hw->DACpal[(i + 128) * 3 + 2] = i << 3;
  396. }
  397. } else {
  398. int i;
  400. for (i = 0; i < 64; i++) { /* 0..63 */
  401. hw->DACpal[i * 3 + 0] = i << 3;
  402. hw->DACpal[i * 3 + 1] = i << 2;
  403. hw->DACpal[i * 3 + 2] = i << 3;
  404. }
  405. }
  406. } else {
  407. memset(hw->DACpal, 0, 768);
  408. }
  409. return 0;
  410. }
  412. static void DAC1064_restore_1(WPMINFO const struct matrox_hw_state* hw, const struct matrox_hw_state* oldhw) {
  413. CRITFLAGS
  415. DBG("DAC1064_restore_1")
  417. CRITBEGIN
  419. outDAC1064(PMINFO DAC1064_XSYSPLLM, hw->DACclk[3]);
  420. outDAC1064(PMINFO DAC1064_XSYSPLLN, hw->DACclk[4]);
  421. outDAC1064(PMINFO DAC1064_XSYSPLLP, hw->DACclk[5]);
  422. /*
  423.  * We must ALWAYS reprogram hardware due to broken XF4 matrox drivers...
  424.  *
  425.  * if (!oldhw || memcmp(hw->DACreg, oldhw->DACreg, sizeof(MGA1064_DAC_regs))) 
  426.  */
  427. {
  428. unsigned int i;
  430. for (i = 0; i < sizeof(MGA1064_DAC_regs); i++) {
  431. if ((i != POS1064_XPIXCLKCTRL) && (i != POS1064_XMISCCTRL))
  432. outDAC1064(PMINFO MGA1064_DAC_regs[i], hw->DACreg[i]);
  433. }
  434. }
  436. DAC1064_global_restore(PMINFO hw);
  438. CRITEND
  439. };
  441. static void DAC1064_restore_2(WPMINFO const struct matrox_hw_state* hw, const struct matrox_hw_state* oldhw, struct display* p) {
  442. #ifdef DEBUG
  443. unsigned int i;
  444. #endif
  446. DBG("DAC1064_restore_2")
  448. matrox_init_putc(PMINFO p, matroxfb_DAC1064_createcursor);
  449. #ifdef DEBUG
  450. dprintk(KERN_DEBUG "DAC1064regs ");
  451. for (i = 0; i < sizeof(MGA1064_DAC_regs); i++) {
  452. dprintk("R%02X=%02X ", MGA1064_DAC_regs[i], hw->DACreg[i]);
  453. if ((i & 0x7) == 0x7) dprintk("n" KERN_DEBUG "continuing... ");
  454. }
  455. dprintk("n" KERN_DEBUG "DAC1064clk ");
  456. for (i = 0; i < 6; i++)
  457. dprintk("C%02X=%02X ", i, hw->DACclk[i]);
  458. dprintk("n");
  459. #endif
  460. }
  462. static int m1064_compute(void* outdev, struct my_timming* m, struct matrox_hw_state* hw) {
  463. #define minfo ((struct matrox_fb_info*)outdev)
  464. DAC1064_setpclk(PMINFO hw, m->pixclock);
  465. #undef minfo
  466. return 0;
  467. }
  469. static int m1064_program(void* outdev, const struct matrox_hw_state* hw) {
  470. #define minfo ((struct matrox_fb_info*)outdev)
  471. int i;
  472. int tmout;
  473. CRITFLAGS
  475. CRITBEGIN
  477. for (i = 0; i < 3; i++)
  478. outDAC1064(PMINFO M1064_XPIXPLLCM + i, hw->DACclk[i]);
  479. for (tmout = 500000; tmout; tmout--) {
  480. if (inDAC1064(PMINFO M1064_XPIXPLLSTAT) & 0x40)
  481. break;
  482. udelay(10);
  483. };
  485. CRITEND
  487. if (!tmout)
  488. printk(KERN_ERR "matroxfb: Pixel PLL not locked after 5 secsn");
  490. #undef minfo
  491. return 0;
  492. }
  494. static int m1064_start(void* outdev) {
  495. /* nothing */
  496. return 0;
  497. }
  499. static void m1064_incuse(void* outdev) {
  500. /* nothing yet; MODULE_INC_USE in future... */
  501. }
  503. static void m1064_decuse(void* outdev) {
  504. /* nothing yet; MODULE_DEC_USE in future... */
  505. }
  507. static int m1064_setmode(void* outdev, u_int32_t mode) {
  508. if (mode != MATROXFB_OUTPUT_MODE_MONITOR)
  509. return -EINVAL;
  510. return 0;
  511. }
  513. static struct matrox_altout m1064 = {
  514. m1064_compute,
  515. m1064_program,
  516. m1064_start,
  517. m1064_incuse,
  518. m1064_decuse,
  519. m1064_setmode
  520. };
  522. #endif /* NEED_DAC1064 */
  524. #ifdef CONFIG_FB_MATROX_MYSTIQUE
  525. static int MGA1064_init(CPMINFO struct matrox_hw_state* hw, struct my_timming* m, struct display* p) {
  527. DBG("MGA1064_init")
  529. if (DAC1064_init_1(PMINFO hw, m, p)) return 1;
  530. if (matroxfb_vgaHWinit(PMINFO hw, m, p)) return 1;
  532. hw->MiscOutReg = 0xCB;
  533. if (m->sync & FB_SYNC_HOR_HIGH_ACT)
  534. hw->MiscOutReg &= ~0x40;
  535. if (m->sync & FB_SYNC_VERT_HIGH_ACT)
  536. hw->MiscOutReg &= ~0x80;
  537. if (m->sync & FB_SYNC_COMP_HIGH_ACT) /* should be only FB_SYNC_COMP */
  538. hw->CRTCEXT[3] |= 0x40;
  540. if (DAC1064_init_2(PMINFO hw, m, p)) return 1;
  541. return 0;
  542. }
  543. #endif
  545. #ifdef CONFIG_FB_MATROX_G100
  546. static int MGAG100_init(CPMINFO struct matrox_hw_state* hw, struct my_timming* m, struct display* p) {
  548. DBG("MGAG100_init")
  550. if (DAC1064_init_1(PMINFO hw, m, p)) return 1;
  551. hw->MXoptionReg &= ~0x2000;
  552. if (matroxfb_vgaHWinit(PMINFO hw, m, p)) return 1;
  554. hw->MiscOutReg = 0xEF;
  555. if (m->sync & FB_SYNC_HOR_HIGH_ACT)
  556. hw->MiscOutReg &= ~0x40;
  557. if (m->sync & FB_SYNC_VERT_HIGH_ACT)
  558. hw->MiscOutReg &= ~0x80;
  559. if (m->sync & FB_SYNC_COMP_HIGH_ACT) /* should be only FB_SYNC_COMP */
  560. hw->CRTCEXT[3] |= 0x40;
  562. if (DAC1064_init_2(PMINFO hw, m, p)) return 1;
  563. return 0;
  564. }
  565. #endif /* G100 */
  567. #ifdef CONFIG_FB_MATROX_MYSTIQUE
  568. static void MGA1064_ramdac_init(WPMINFO struct matrox_hw_state* hw){
  570. DBG("MGA1064_ramdac_init");
  572. /* ACCESS_FBINFO(features.DAC1064.vco_freq_min) = 120000; */
  573. ACCESS_FBINFO(features.pll.vco_freq_min) = 62000;
  574. ACCESS_FBINFO(features.pll.ref_freq)  = 14318;
  575. ACCESS_FBINFO(features.pll.feed_div_min) = 100;
  576. ACCESS_FBINFO(features.pll.feed_div_max) = 127;
  577. ACCESS_FBINFO(features.pll.in_div_min)  = 1;
  578. ACCESS_FBINFO(features.pll.in_div_max)  = 31;
  579. ACCESS_FBINFO(features.pll.post_shift_max) = 3;
  580. ACCESS_FBINFO(features.DAC1064.xvrefctrl) = DAC1064_XVREFCTRL_EXTERNAL;
  581. /* maybe cmdline MCLK= ?, doc says gclk=44MHz, mclk=66MHz... it was 55/83 with old values */
  582. DAC1064_setmclk(PMINFO hw, DAC1064_OPT_MDIV2 | DAC1064_OPT_GDIV3 | DAC1064_OPT_SCLK_PLL, 133333);
  583. }
  584. #endif
  586. #ifdef CONFIG_FB_MATROX_G100
  587. /* BIOS environ */
  588. static int x7AF4 = 0x10; /* flags, maybe 0x10 = SDRAM, 0x00 = SGRAM??? */
  589. /* G100 wants 0x10, G200 SGRAM does not care... */
  590. #if 0
  591. static int def50 = 0; /* reg50, & 0x0F, & 0x3000 (only 0x0000, 0x1000, 0x2000 (0x3000 disallowed and treated as 0) */
  592. #endif
  594. static void MGAG100_progPixClock(CPMINFO int flags, int m, int n, int p){
  595. int reg;
  596. int selClk;
  597. int clk;
  599. DBG("MGAG100_progPixClock")
  601. outDAC1064(PMINFO M1064_XPIXCLKCTRL, inDAC1064(PMINFO M1064_XPIXCLKCTRL) | M1064_XPIXCLKCTRL_DIS |
  602.    M1064_XPIXCLKCTRL_PLL_UP);
  603. switch (flags & 3) {
  604. case 0: reg = M1064_XPIXPLLAM; break;
  605. case 1: reg = M1064_XPIXPLLBM; break;
  606. default: reg = M1064_XPIXPLLCM; break;
  607. }
  608. outDAC1064(PMINFO reg++, m);
  609. outDAC1064(PMINFO reg++, n);
  610. outDAC1064(PMINFO reg, p);
  611. selClk = mga_inb(M_MISC_REG_READ) & ~0xC;
  612. /* there should be flags & 0x03 & case 0/1/else */
  613. /* and we should first select source and after that we should wait for PLL */
  614. /* and we are waiting for PLL with oscilator disabled... Is it right? */
  615. switch (flags & 0x03) {
  616. case 0x00: break;
  617. case 0x01: selClk |= 4; break;
  618. default: selClk |= 0x0C; break;
  619. }
  620. mga_outb(M_MISC_REG, selClk);
  621. for (clk = 500000; clk; clk--) {
  622. if (inDAC1064(PMINFO M1064_XPIXPLLSTAT) & 0x40)
  623. break;
  624. udelay(10);
  625. };
  626. if (!clk)
  627. printk(KERN_ERR "matroxfb: Pixel PLL%c not locked after usual timen", (reg-M1064_XPIXPLLAM-2)/4 + 'A');
  628. selClk = inDAC1064(PMINFO M1064_XPIXCLKCTRL) & ~M1064_XPIXCLKCTRL_SRC_MASK;
  629. switch (flags & 0x0C) {
  630. case 0x00: selClk |= M1064_XPIXCLKCTRL_SRC_PCI; break;
  631. case 0x04: selClk |= M1064_XPIXCLKCTRL_SRC_PLL; break;
  632. default: selClk |= M1064_XPIXCLKCTRL_SRC_EXT; break;
  633. }
  634. outDAC1064(PMINFO M1064_XPIXCLKCTRL, selClk);
  635. outDAC1064(PMINFO M1064_XPIXCLKCTRL, inDAC1064(PMINFO M1064_XPIXCLKCTRL) & ~M1064_XPIXCLKCTRL_DIS);
  636. }
  638. static void MGAG100_setPixClock(CPMINFO int flags, int freq){
  639. unsigned int m, n, p;
  641. DBG("MGAG100_setPixClock")
  643. DAC1064_calcclock(PMINFO freq, ACCESS_FBINFO(max_pixel_clock), &m, &n, &p);
  644. MGAG100_progPixClock(PMINFO flags, m, n, p);
  645. }
  646. #endif
  648. #ifdef CONFIG_FB_MATROX_MYSTIQUE
  649. static int MGA1064_preinit(WPMINFO struct matrox_hw_state* hw){
  650. static const int vxres_mystique[] = { 512,        640, 768,  800,  832,  960,
  651.      1024, 1152, 1280,      1600, 1664, 1920,
  652.      2048,    0};
  653. DBG("MGA1064_preinit")
  655. /* ACCESS_FBINFO(capable.cfb4) = 0; ... preinitialized by 0 */
  656. ACCESS_FBINFO(capable.text) = 1;
  657. ACCESS_FBINFO(capable.vxres) = vxres_mystique;
  658. ACCESS_FBINFO(features.accel.has_cacheflush) = 1;
  659. ACCESS_FBINFO(cursor.timer.function) = matroxfb_DAC1064_flashcursor;
  661. ACCESS_FBINFO(primout) = &m1064;
  663. if (ACCESS_FBINFO(devflags.noinit))
  664. return 0; /* do not modify settings */
  665. hw->MXoptionReg &= 0xC0000100;
  666. hw->MXoptionReg |= 0x00094E20;
  667. if (ACCESS_FBINFO(devflags.novga))
  668. hw->MXoptionReg &= ~0x00000100;
  669. if (ACCESS_FBINFO(devflags.nobios))
  670. hw->MXoptionReg &= ~0x40000000;
  671. if (ACCESS_FBINFO(devflags.nopciretry))
  672. hw->MXoptionReg |=  0x20000000;
  673. pci_write_config_dword(ACCESS_FBINFO(pcidev), PCI_OPTION_REG, hw->MXoptionReg);
  674. mga_setr(M_SEQ_INDEX, 0x01, 0x20);
  675. mga_outl(M_CTLWTST, 0x00000000);
  676. udelay(200);
  677. mga_outl(M_MACCESS, 0x00008000);
  678. udelay(100);
  679. mga_outl(M_MACCESS, 0x0000C000);
  680. return 0;
  681. }
  683. static void MGA1064_reset(WPMINFO struct matrox_hw_state* hw){
  685. DBG("MGA1064_reset");
  687. ACCESS_FBINFO(features.DAC1064.cursorimage) = ACCESS_FBINFO(video.len_usable) - 1024;
  688. if (ACCESS_FBINFO(devflags.hwcursor))
  689. ACCESS_FBINFO(video.len_usable) -= 1024;
  690. matroxfb_fastfont_init(MINFO);
  691. MGA1064_ramdac_init(PMINFO hw);
  692. }
  693. #endif
  695. #ifdef CONFIG_FB_MATROX_G100
  696. static int MGAG100_preinit(WPMINFO struct matrox_hw_state* hw){
  697. static const int vxres_g100[] = {  512,        640, 768,  800,  832,  960,
  698.                                           1024, 1152, 1280,      1600, 1664, 1920,
  699.                                           2048, 0};
  700.         u_int32_t reg50;
  701. #if 0
  702. u_int32_t q;
  703. #endif
  705. DBG("MGAG100_preinit")
  707. /* there are some instabilities if in_div > 19 && vco < 61000 */
  708. if (ACCESS_FBINFO(devflags.g450dac)) {
  709. ACCESS_FBINFO(features.pll.vco_freq_min) = 130000; /* my sample: >118 */
  710. } else {
  711. ACCESS_FBINFO(features.pll.vco_freq_min) = 62000;
  712. }
  713. ACCESS_FBINFO(features.pll.ref_freq)  = 27000;
  714. ACCESS_FBINFO(features.pll.feed_div_min) = 7;
  715. ACCESS_FBINFO(features.pll.feed_div_max) = 127;
  716. ACCESS_FBINFO(features.pll.in_div_min)  = 1;
  717. ACCESS_FBINFO(features.pll.in_div_max)  = 31;
  718. ACCESS_FBINFO(features.pll.post_shift_max) = 3;
  719. ACCESS_FBINFO(features.DAC1064.xvrefctrl) = DAC1064_XVREFCTRL_G100_DEFAULT;
  720. /* ACCESS_FBINFO(capable.cfb4) = 0; ... preinitialized by 0 */
  721. ACCESS_FBINFO(capable.text) = 1;
  722. ACCESS_FBINFO(capable.vxres) = vxres_g100;
  723. ACCESS_FBINFO(features.accel.has_cacheflush) = 1;
  724. ACCESS_FBINFO(cursor.timer.function) = matroxfb_DAC1064_flashcursor;
  725. ACCESS_FBINFO(capable.plnwt) = ACCESS_FBINFO(devflags.accelerator) == FB_ACCEL_MATROX_MGAG100
  726. ? ACCESS_FBINFO(devflags.sgram) : 1;
  728. ACCESS_FBINFO(primout) = &m1064;
  730. if (ACCESS_FBINFO(devflags.g450dac)) {
  731. /* we must do this always, BIOS does not do it for us
  732.    and accelerator dies without it */
  733. mga_outl(0x1C0C, 0);
  734. }
  735. if (ACCESS_FBINFO(devflags.noinit))
  736. return 0;
  737. hw->MXoptionReg &= 0xC0000100;
  738. hw->MXoptionReg |= 0x00000020;
  739. if (ACCESS_FBINFO(devflags.novga))
  740. hw->MXoptionReg &= ~0x00000100;
  741. if (ACCESS_FBINFO(devflags.nobios))
  742. hw->MXoptionReg &= ~0x40000000;
  743. if (ACCESS_FBINFO(devflags.nopciretry))
  744. hw->MXoptionReg |=  0x20000000;
  745. pci_write_config_dword(ACCESS_FBINFO(pcidev), PCI_OPTION_REG, hw->MXoptionReg);
  746. DAC1064_setmclk(PMINFO hw, DAC1064_OPT_MDIV2 | DAC1064_OPT_GDIV3 | DAC1064_OPT_SCLK_PCI, 133333);
  748. if (ACCESS_FBINFO(devflags.accelerator) == FB_ACCEL_MATROX_MGAG100) {
  749. pci_read_config_dword(ACCESS_FBINFO(pcidev), 0x50, &reg50);
  750. reg50 &= ~0x3000;
  751. pci_write_config_dword(ACCESS_FBINFO(pcidev), 0x50, reg50);
  753. hw->MXoptionReg |= 0x1080;
  754. pci_write_config_dword(ACCESS_FBINFO(pcidev), PCI_OPTION_REG, hw->MXoptionReg);
  755. mga_outl(M_CTLWTST, 0x00000300);
  756. /* mga_outl(M_CTLWTST, 0x03258A31); */
  757. udelay(100);
  758. mga_outb(0x1C05, 0x00);
  759. mga_outb(0x1C05, 0x80);
  760. udelay(100);
  761. mga_outb(0x1C05, 0x40);
  762. mga_outb(0x1C05, 0xC0);
  763. udelay(100);
  764. reg50 &= ~0xFF;
  765. reg50 |=  0x07;
  766. pci_write_config_dword(ACCESS_FBINFO(pcidev), 0x50, reg50);
  767. /* it should help with G100 */
  768. mga_outb(M_GRAPHICS_INDEX, 6);
  769. mga_outb(M_GRAPHICS_DATA, (mga_inb(M_GRAPHICS_DATA) & 3) | 4);
  770. mga_setr(M_EXTVGA_INDEX, 0x03, 0x81);
  771. mga_setr(M_EXTVGA_INDEX, 0x04, 0x00);
  772. mga_writeb(ACCESS_FBINFO(video.vbase), 0x0000, 0xAA);
  773. mga_writeb(ACCESS_FBINFO(video.vbase), 0x0800, 0x55);
  774. mga_writeb(ACCESS_FBINFO(video.vbase), 0x4000, 0x55);
  775. #if 0
  776. if (mga_readb(ACCESS_FBINFO(video.vbase), 0x0000) != 0xAA) {
  777. hw->MXoptionReg &= ~0x1000;
  778. }
  779. #endif
  780. hw->MXoptionReg |= 0x00078020;
  781. } else  if (ACCESS_FBINFO(devflags.accelerator) == FB_ACCEL_MATROX_MGAG200) {
  782. pci_read_config_dword(ACCESS_FBINFO(pcidev), 0x50, &reg50);
  783. reg50 &= ~0x3000;
  784. pci_write_config_dword(ACCESS_FBINFO(pcidev), 0x50, reg50);
  786. if (ACCESS_FBINFO(devflags.memtype) == -1)
  787. ACCESS_FBINFO(devflags.memtype) = 3;
  788. hw->MXoptionReg |= (ACCESS_FBINFO(devflags.memtype) & 7) << 10;
  789. if (ACCESS_FBINFO(devflags.sgram))
  790. hw->MXoptionReg |= 0x4000;
  791. mga_outl(M_CTLWTST, 0x042450A1);
  792. mga_outl(M_MEMRDBK, 0x00000108);
  793. udelay(200);
  794. mga_outl(M_MACCESS, 0x00000000);
  795. mga_outl(M_MACCESS, 0x00008000);
  796. udelay(100);
  797. mga_outw(M_MEMRDBK, 0x00000108);
  798. hw->MXoptionReg |= 0x00078020;
  799. } else {
  800. pci_read_config_dword(ACCESS_FBINFO(pcidev), 0x50, &reg50);
  801. reg50 &= ~0x00000100;
  802. reg50 |=  0x00000000;
  803. pci_write_config_dword(ACCESS_FBINFO(pcidev), 0x50, reg50);
  805. if (ACCESS_FBINFO(devflags.memtype) == -1)
  806. ACCESS_FBINFO(devflags.memtype) = 0;
  807. hw->MXoptionReg |= (ACCESS_FBINFO(devflags.memtype) & 7) << 10;
  808. if (ACCESS_FBINFO(devflags.sgram))
  809. hw->MXoptionReg |= 0x4000;
  810. mga_outl(M_CTLWTST, 0x042450A1);
  811. mga_outl(M_MEMRDBK, 0x00000108);
  812. udelay(200);
  813. mga_outl(M_MACCESS, 0x00000000);
  814. mga_outl(M_MACCESS, 0x00008000);
  815. udelay(100);
  816. mga_outl(M_MEMRDBK, 0x00000108);
  817. hw->MXoptionReg |= 0x00040020;
  818. }
  819. pci_write_config_dword(ACCESS_FBINFO(pcidev), PCI_OPTION_REG, hw->MXoptionReg);
  820. return 0;
  821. }
  823. static void MGAG100_reset(WPMINFO struct matrox_hw_state* hw){
  824. u_int8_t b;
  826. DBG("MGAG100_reset")
  828. ACCESS_FBINFO(features.DAC1064.cursorimage) = ACCESS_FBINFO(video.len_usable) - 1024;
  829. if (ACCESS_FBINFO(devflags.hwcursor))
  830. ACCESS_FBINFO(video.len_usable) -= 1024;
  831. matroxfb_fastfont_init(MINFO);
  833. {
  834. #ifdef G100_BROKEN_IBM_82351
  835. u_int32_t d;
  837. find 1014/22 (IBM/82351); /* if found and bridging Matrox, do some strange stuff */
  838. pci_read_config_byte(ibm, PCI_SECONDARY_BUS, &b);
  839. if (b == ACCESS_FBINFO(pcidev)->bus->number) {
  840. pci_write_config_byte(ibm, PCI_COMMAND+1, 0); /* disable back-to-back & SERR */
  841. pci_write_config_byte(ibm, 0x41, 0xF4); /* ??? */
  842. pci_write_config_byte(ibm, PCI_IO_BASE, 0xF0); /* ??? */
  843. pci_write_config_byte(ibm, PCI_IO_LIMIT, 0x00); /* ??? */
  844. }
  845. #endif
  846. if (!ACCESS_FBINFO(devflags.noinit)) {
  847. if (x7AF4 & 8) {
  848. hw->MXoptionReg |= 0x40;
  849. pci_write_config_dword(ACCESS_FBINFO(pcidev), PCI_OPTION_REG, hw->MXoptionReg);
  850. }
  851. mga_setr(M_EXTVGA_INDEX, 0x06, 0x50);
  852. }
  853. }
  854. DAC1064_setmclk(PMINFO hw, DAC1064_OPT_RESERVED | DAC1064_OPT_MDIV2 | DAC1064_OPT_GDIV1 | DAC1064_OPT_SCLK_PLL, 133333);
  855. if (ACCESS_FBINFO(devflags.accelerator) == FB_ACCEL_MATROX_MGAG400) {
  856. if (ACCESS_FBINFO(devflags.dfp_type) == -1) {
  857. ACCESS_FBINFO(devflags.dfp_type) = inDAC1064(PMINFO 0x1F);
  858. }
  859. }
  860. if (ACCESS_FBINFO(devflags.noinit))
  861. return;
  862. MGAG100_setPixClock(PMINFO 4, 25175);
  863. MGAG100_setPixClock(PMINFO 5, 28322);
  864. if (x7AF4 & 0x10) {
  865. b = inDAC1064(PMINFO M1064_XGENIODATA) & ~1;
  866. outDAC1064(PMINFO M1064_XGENIODATA, b);
  867. b = inDAC1064(PMINFO M1064_XGENIOCTRL) | 1;
  868. outDAC1064(PMINFO M1064_XGENIOCTRL, b);
  869. }
  870. }
  871. #endif
  873. #ifdef CONFIG_FB_MATROX_MYSTIQUE
  874. static void MGA1064_restore(WPMINFO struct matrox_hw_state* hw, struct matrox_hw_state* oldhw, struct display* p) {
  875. int i;
  876. CRITFLAGS
  878. DBG("MGA1064_restore")
  880. CRITBEGIN
  882. pci_write_config_dword(ACCESS_FBINFO(pcidev), PCI_OPTION_REG, hw->MXoptionReg);
  883. mga_outb(M_IEN, 0x00);
  884. mga_outb(M_CACHEFLUSH, 0x00);
  886. CRITEND
  888. DAC1064_restore_1(PMINFO hw, oldhw);
  889. matroxfb_vgaHWrestore(PMINFO hw, oldhw);
  890. for (i = 0; i < 6; i++)
  891. mga_setr(M_EXTVGA_INDEX, i, hw->CRTCEXT[i]);
  892. DAC1064_restore_2(PMINFO hw, oldhw, p);
  893. }
  894. #endif
  896. #ifdef CONFIG_FB_MATROX_G100
  897. static void MGAG100_restore(WPMINFO struct matrox_hw_state* hw, struct matrox_hw_state* oldhw, struct display* p) {
  898. int i;
  899. CRITFLAGS
  901. DBG("MGAG100_restore")
  903. CRITBEGIN
  905. pci_write_config_dword(ACCESS_FBINFO(pcidev), PCI_OPTION_REG, hw->MXoptionReg);
  906. CRITEND
  908. DAC1064_restore_1(PMINFO hw, oldhw);
  909. matroxfb_vgaHWrestore(PMINFO hw, oldhw);
  910. #ifdef CONFIG_FB_MATROX_32MB
  911. if (ACCESS_FBINFO(devflags.support32MB))
  912. mga_setr(M_EXTVGA_INDEX, 8, hw->CRTCEXT[8]);
  913. #endif
  914. for (i = 0; i < 6; i++)
  915. mga_setr(M_EXTVGA_INDEX, i, hw->CRTCEXT[i]);
  916. DAC1064_restore_2(PMINFO hw, oldhw, p);
  917. }
  918. #endif
  920. #ifdef CONFIG_FB_MATROX_MYSTIQUE
  921. struct matrox_switch matrox_mystique = {
  922. MGA1064_preinit, MGA1064_reset, MGA1064_init, MGA1064_restore, DAC1064_selhwcursor
  923. };
  924. EXPORT_SYMBOL(matrox_mystique);
  925. #endif
  927. #ifdef CONFIG_FB_MATROX_G100
  928. struct matrox_switch matrox_G100 = {
  929. MGAG100_preinit, MGAG100_reset, MGAG100_init, MGAG100_restore, DAC1064_selhwcursor
  930. };
  931. EXPORT_SYMBOL(matrox_G100);
  932. #endif
  934. #ifdef NEED_DAC1064
  935. EXPORT_SYMBOL(DAC1064_global_init);
  936. EXPORT_SYMBOL(DAC1064_global_restore);
  937. #endif
  938. MODULE_LICENSE("GPL");