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

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

Linux/Unix编程

开发平台：

Unix_Linux

matroxfb_accel.c：源码内容
  1. /*
  2.  *
  3.  * Hardware accelerated Matrox Millennium I, II, Mystique, G100, G200 and G400
  4.  *
  5.  * (c) 1998-2001 Petr Vandrovec <vandrove@vc.cvut.cz>
  6.  *
  7.  * Version: 1.51 2001/06/18
  8.  *
  9.  * MTRR stuff: 1998 Tom Rini <trini@kernel.crashing.org>
  10.  *
  11.  * Contributors: "menion?" <menion@mindless.com>
  12.  *                     Betatesting, fixes, ideas
  13.  *
  14.  *               "Kurt Garloff" <garloff@suse.de>
  15.  *                     Betatesting, fixes, ideas, videomodes, videomodes timmings
  16.  *
  17.  *               "Tom Rini" <trini@kernel.crashing.org>
  18.  *                     MTRR stuff, PPC cleanups, betatesting, fixes, ideas
  19.  *
  20.  *               "Bibek Sahu" <scorpio@dodds.net>
  21.  *                     Access device through readb|w|l and write b|w|l
  22.  *                     Extensive debugging stuff
  23.  *
  24.  *               "Daniel Haun" <haund@usa.net>
  25.  *                     Testing, hardware cursor fixes
  26.  *
  27.  *               "Scott Wood" <sawst46+@pitt.edu>
  28.  *                     Fixes
  29.  *
  30.  *               "Gerd Knorr" <kraxel@goldbach.isdn.cs.tu-berlin.de>
  31.  *                     Betatesting
  32.  *
  33.  *               "Kelly French" <targon@hazmat.com>
  34.  *               "Fernando Herrera" <fherrera@eurielec.etsit.upm.es>
  35.  *                     Betatesting, bug reporting
  36.  *
  37.  *               "Pablo Bianucci" <pbian@pccp.com.ar>
  38.  *                     Fixes, ideas, betatesting
  39.  *
  40.  *               "Inaky Perez Gonzalez" <inaky@peloncho.fis.ucm.es>
  41.  *                     Fixes, enhandcements, ideas, betatesting
  42.  *
  43.  *               "Ryuichi Oikawa" <roikawa@rr.iiij4u.or.jp>
  44.  *                     PPC betatesting, PPC support, backward compatibility
  45.  *
  46.  *               "Paul Womar" <Paul@pwomar.demon.co.uk>
  47.  *               "Owen Waller" <O.Waller@ee.qub.ac.uk>
  48.  *                     PPC betatesting
  49.  *
  50.  *               "Thomas Pornin" <pornin@bolet.ens.fr>
  51.  *                     Alpha betatesting
  52.  *
  53.  *               "Pieter van Leuven" <pvl@iae.nl>
  54.  *               "Ulf Jaenicke-Roessler" <ujr@physik.phy.tu-dresden.de>
  55.  *                     G100 testing
  56.  *
  57.  *               "H. Peter Arvin" <hpa@transmeta.com>
  58.  *                     Ideas
  59.  *
  60.  *               "Cort Dougan" <cort@cs.nmt.edu>
  61.  *                     CHRP fixes and PReP cleanup
  62.  *
  63.  *               "Mark Vojkovich" <mvojkovi@ucsd.edu>
  64.  *                     G400 support
  65.  *
  66.  * (following author is not in any relation with this code, but his code
  67.  *  is included in this driver)
  68.  *
  69.  * Based on framebuffer driver for VBE 2.0 compliant graphic boards
  70.  *     (c) 1998 Gerd Knorr <kraxel@cs.tu-berlin.de>
  71.  *
  72.  * (following author is not in any relation with this code, but his ideas
  73.  *  were used when writting this driver)
  74.  *
  75.  *  FreeVBE/AF (Matrox), "Shawn Hargreaves" <shawn@talula.demon.co.uk>
  76.  *
  77.  */
  79. #include "matroxfb_accel.h"
  80. #include "matroxfb_DAC1064.h"
  81. #include "matroxfb_Ti3026.h"
  82. #include "matroxfb_misc.h"
  84. #define curr_ydstorg(x) ACCESS_FBINFO2(x, curr.ydstorg.pixels)
  86. #define mga_ydstlen(y,l) mga_outl(M_YDSTLEN | M_EXEC, ((y) << 16) | (l))
  88. void matrox_cfbX_init(WPMINFO struct display* p) {
  89. u_int32_t maccess;
  90. u_int32_t mpitch;
  91. u_int32_t mopmode;
  93. DBG("matrox_cfbX_init")
  95. mpitch = p->var.xres_virtual;
  97. if (p->type == FB_TYPE_TEXT) {
  98. maccess = 0x00000000;
  99. mpitch = (mpitch >> 4) | 0x8000; /* set something */
  100. mopmode = M_OPMODE_8BPP;
  101. } else {
  102. switch (p->var.bits_per_pixel) {
  103. case 4: maccess = 0x00000000; /* accelerate as 8bpp video */
  104. mpitch = (mpitch >> 1) | 0x8000; /* disable linearization */
  105. mopmode = M_OPMODE_4BPP;
  106. break;
  107. case 8: maccess = 0x00000000;
  108. mopmode = M_OPMODE_8BPP;
  109. break;
  110. case 16: if (p->var.green.length == 5)
  111. maccess = 0xC0000001;
  112. else
  113. maccess = 0x40000001;
  114. mopmode = M_OPMODE_16BPP;
  115. break;
  116. case 24: maccess = 0x00000003;
  117. mopmode = M_OPMODE_24BPP;
  118. break;
  119. case 32: maccess = 0x00000002;
  120. mopmode = M_OPMODE_32BPP;
  121. break;
  122. default: maccess = 0x00000000;
  123. mopmode = 0x00000000;
  124. break; /* turn off acceleration!!! */
  125. }
  126. }
  127. mga_fifo(8);
  128. mga_outl(M_PITCH, mpitch);
  129. mga_outl(M_YDSTORG, curr_ydstorg(MINFO));
  130. if (ACCESS_FBINFO(capable.plnwt))
  131. mga_outl(M_PLNWT, -1);
  132. if (ACCESS_FBINFO(capable.srcorg)) {
  133. mga_outl(M_SRCORG, 0);
  134. mga_outl(M_DSTORG, 0);
  135. }
  136. mga_outl(M_OPMODE, mopmode);
  137. mga_outl(M_CXBNDRY, 0xFFFF0000);
  138. mga_outl(M_YTOP, 0);
  139. mga_outl(M_YBOT, 0x01FFFFFF);
  140. mga_outl(M_MACCESS, maccess);
  141. ACCESS_FBINFO(accel.m_dwg_rect) = M_DWG_TRAP | M_DWG_SOLID | M_DWG_ARZERO | M_DWG_SGNZERO | M_DWG_SHIFTZERO;
  142. if (isMilleniumII(MINFO)) ACCESS_FBINFO(accel.m_dwg_rect) |= M_DWG_TRANSC;
  143. ACCESS_FBINFO(accel.m_opmode) = mopmode;
  144. }
  146. static void matrox_cfbX_bmove(struct display* p, int sy, int sx, int dy, int dx, int height, int width) {
  147. int pixx = p->var.xres_virtual, start, end;
  148. CRITFLAGS
  149. MINFO_FROM_DISP(p);
  151. DBG("matrox_cfbX_bmove")
  153. CRITBEGIN
  155. sx *= fontwidth(p);
  156. dx *= fontwidth(p);
  157. width *= fontwidth(p);
  158. height *= fontheight(p);
  159. sy *= fontheight(p);
  160. dy *= fontheight(p);
  161. if ((dy < sy) || ((dy == sy) && (dx <= sx))) {
  162. mga_fifo(2);
  163. mga_outl(M_DWGCTL, M_DWG_BITBLT | M_DWG_SHIFTZERO | M_DWG_SGNZERO |
  164.  M_DWG_BFCOL | M_DWG_REPLACE);
  165. mga_outl(M_AR5, pixx);
  166. width--;
  167. start = sy*pixx+sx+curr_ydstorg(MINFO);
  168. end = start+width;
  169. } else {
  170. mga_fifo(3);
  171. mga_outl(M_DWGCTL, M_DWG_BITBLT | M_DWG_SHIFTZERO | M_DWG_BFCOL | M_DWG_REPLACE);
  172. mga_outl(M_SGN, 5);
  173. mga_outl(M_AR5, -pixx);
  174. width--;
  175. end = (sy+height-1)*pixx+sx+curr_ydstorg(MINFO);
  176. start = end+width;
  177. dy += height-1;
  178. }
  179. mga_fifo(4);
  180. mga_outl(M_AR0, end);
  181. mga_outl(M_AR3, start);
  182. mga_outl(M_FXBNDRY, ((dx+width)<<16) | dx);
  183. mga_ydstlen(dy, height);
  184. WaitTillIdle();
  186. CRITEND
  187. }
  189. #ifdef FBCON_HAS_CFB4
  190. static void matrox_cfb4_bmove(struct display* p, int sy, int sx, int dy, int dx, int height, int width) {
  191. int pixx, start, end;
  192. CRITFLAGS
  193. MINFO_FROM_DISP(p);
  194. /* both (sx or dx or width) and fontwidth() are odd, so their multiply is
  195.    also odd, that means that we cannot use acceleration */
  197. DBG("matrox_cfb4_bmove")
  199. CRITBEGIN
  201. if ((sx | dx | width) & fontwidth(p) & 1) {
  202. fbcon_cfb4_bmove(p, sy, sx, dy, dx, height, width);
  203. return;
  204. }
  205. sx *= fontwidth(p);
  206. dx *= fontwidth(p);
  207. width *= fontwidth(p);
  208. height *= fontheight(p);
  209. sy *= fontheight(p);
  210. dy *= fontheight(p);
  211. pixx = p->var.xres_virtual >> 1;
  212. sx >>= 1;
  213. dx >>= 1;
  214. width >>= 1;
  215. if ((dy < sy) || ((dy == sy) && (dx <= sx))) {
  216. mga_fifo(2);
  217. mga_outl(M_AR5, pixx);
  218. mga_outl(M_DWGCTL, M_DWG_BITBLT | M_DWG_SHIFTZERO | M_DWG_SGNZERO |
  219. M_DWG_BFCOL | M_DWG_REPLACE);
  220. width--;
  221. start = sy*pixx+sx+curr_ydstorg(MINFO);
  222. end = start+width;
  223. } else {
  224. mga_fifo(3);
  225. mga_outl(M_SGN, 5);
  226. mga_outl(M_AR5, -pixx);
  227. mga_outl(M_DWGCTL, M_DWG_BITBLT | M_DWG_SHIFTZERO | M_DWG_BFCOL | M_DWG_REPLACE);
  228. width--;
  229. end = (sy+height-1)*pixx+sx+curr_ydstorg(MINFO);
  230. start = end+width;
  231. dy += height-1;
  232. }
  233. mga_fifo(5);
  234. mga_outl(M_AR0, end);
  235. mga_outl(M_AR3, start);
  236. mga_outl(M_FXBNDRY, ((dx+width)<<16) | dx);
  237. mga_outl(M_YDST, dy*pixx >> 5);
  238. mga_outl(M_LEN | M_EXEC, height);
  239. WaitTillIdle();
  241. CRITEND
  242. }
  243. #endif
  245. static void matroxfb_accel_clear(WPMINFO u_int32_t color, int sy, int sx, int height,
  246. int width) {
  247. CRITFLAGS
  249. DBG("matroxfb_accel_clear")
  251. CRITBEGIN
  253. mga_fifo(5);
  254. mga_outl(M_DWGCTL, ACCESS_FBINFO(accel.m_dwg_rect) | M_DWG_REPLACE);
  255. mga_outl(M_FCOL, color);
  256. mga_outl(M_FXBNDRY, ((sx + width) << 16) | sx);
  257. mga_ydstlen(sy, height);
  258. WaitTillIdle();
  260. CRITEND
  261. }
  263. static void matrox_cfbX_clear(u_int32_t color, struct display* p, int sy, int sx, int height, int width) {
  265. DBG("matrox_cfbX_clear")
  267. matroxfb_accel_clear(PMXINFO(p) color, sy * fontheight(p), sx * fontwidth(p),
  268.      height * fontheight(p), width * fontwidth(p));
  269. }
  271. #ifdef FBCON_HAS_CFB4
  272. static void matrox_cfb4_clear(struct vc_data* conp, struct display* p, int sy, int sx, int height, int width) {
  273. u_int32_t bgx;
  274. int whattodo;
  275. CRITFLAGS
  276. MINFO_FROM_DISP(p);
  278. DBG("matrox_cfb4_clear")
  280. CRITBEGIN
  282. whattodo = 0;
  283. bgx = attr_bgcol_ec(p, conp);
  284. bgx |= bgx << 4;
  285. bgx |= bgx << 8;
  286. bgx |= bgx << 16;
  287. sy *= fontheight(p);
  288. sx *= fontwidth(p);
  289. height *= fontheight(p);
  290. width *= fontwidth(p);
  291. if (sx & 1) {
  292. sx ++;
  293. if (!width) return;
  294. width --;
  295. whattodo = 1;
  296. }
  297. if (width & 1) {
  298. whattodo |= 2;
  299. }
  300. width >>= 1;
  301. sx >>= 1;
  302. if (width) {
  303. mga_fifo(5);
  304. mga_outl(M_DWGCTL, ACCESS_FBINFO(accel.m_dwg_rect) | M_DWG_REPLACE2);
  305. mga_outl(M_FCOL, bgx);
  306. mga_outl(M_FXBNDRY, ((sx + width) << 16) | sx);
  307. mga_outl(M_YDST, sy * p->var.xres_virtual >> 6);
  308. mga_outl(M_LEN | M_EXEC, height);
  309. WaitTillIdle();
  310. }
  311. if (whattodo) {
  312. u_int32_t step = p->var.xres_virtual >> 1;
  313. vaddr_t vbase = ACCESS_FBINFO(video.vbase);
  314. if (whattodo & 1) {
  315. unsigned int uaddr = sy * step + sx - 1;
  316. u_int32_t loop;
  317. u_int8_t bgx2 = bgx & 0xF0;
  318. for (loop = height; loop > 0; loop --) {
  319. mga_writeb(vbase, uaddr, (mga_readb(vbase, uaddr) & 0x0F) | bgx2);
  320. uaddr += step;
  321. }
  322. }
  323. if (whattodo & 2) {
  324. unsigned int uaddr = sy * step + sx + width;
  325. u_int32_t loop;
  326. u_int8_t bgx2 = bgx & 0x0F;
  327. for (loop = height; loop > 0; loop --) {
  328. mga_writeb(vbase, uaddr, (mga_readb(vbase, uaddr) & 0xF0) | bgx2);
  329. uaddr += step;
  330. }
  331. }
  332. }
  334. CRITEND
  335. }
  336. #endif
  338. #ifdef FBCON_HAS_CFB8
  339. static void matrox_cfb8_clear(struct vc_data* conp, struct display* p, int sy, int sx, int height, int width) {
  340. u_int32_t bgx;
  342. DBG("matrox_cfb8_clear")
  344. bgx = attr_bgcol_ec(p, conp);
  345. bgx |= bgx << 8;
  346. bgx |= bgx << 16;
  347. matrox_cfbX_clear(bgx, p, sy, sx, height, width);
  348. }
  349. #endif
  351. #ifdef FBCON_HAS_CFB16
  352. static void matrox_cfb16_clear(struct vc_data* conp, struct display* p, int sy, int sx, int height, int width) {
  353. u_int32_t bgx;
  355. DBG("matrox_cfb16_clear")
  357. bgx = ((u_int16_t*)p->dispsw_data)[attr_bgcol_ec(p, conp)];
  358. matrox_cfbX_clear((bgx << 16) | bgx, p, sy, sx, height, width);
  359. }
  360. #endif
  362. #if defined(FBCON_HAS_CFB32) || defined(FBCON_HAS_CFB24)
  363. static void matrox_cfb32_clear(struct vc_data* conp, struct display* p, int sy, int sx, int height, int width) {
  364. u_int32_t bgx;
  366. DBG("matrox_cfb32_clear")
  368. bgx = ((u_int32_t*)p->dispsw_data)[attr_bgcol_ec(p, conp)];
  369. matrox_cfbX_clear(bgx, p, sy, sx, height, width);
  370. }
  371. #endif
  373. static void matrox_cfbX_fastputc(u_int32_t fgx, u_int32_t bgx, struct display* p, int c, int yy, int xx) {
  374. unsigned int charcell;
  375. unsigned int ar3;
  376. CRITFLAGS
  377. MINFO_FROM_DISP(p);
  379. charcell = fontwidth(p) * fontheight(p);
  380. yy *= fontheight(p);
  381. xx *= fontwidth(p);
  383. CRITBEGIN
  385. mga_fifo(8);
  386. mga_outl(M_DWGCTL, M_DWG_BITBLT | M_DWG_SGNZERO | M_DWG_SHIFTZERO | M_DWG_BMONOWF | M_DWG_LINEAR | M_DWG_REPLACE);
  388. mga_outl(M_FCOL, fgx);
  389. mga_outl(M_BCOL, bgx);
  390. mga_outl(M_FXBNDRY, ((xx + fontwidth(p) - 1) << 16) | xx);
  391. ar3 = ACCESS_FBINFO(fastfont.mgabase) + (c & p->charmask) * charcell;
  392. mga_outl(M_AR3, ar3);
  393. mga_outl(M_AR0, (ar3 + charcell - 1) & 0x0003FFFF);
  394. mga_ydstlen(yy, fontheight(p));
  395. WaitTillIdle();
  397. CRITEND
  398. }
  400. static void matrox_cfbX_putc(u_int32_t fgx, u_int32_t bgx, struct display* p, int c, int yy, int xx) {
  401. u_int32_t ar0;
  402. u_int32_t step;
  403. CRITFLAGS
  404. MINFO_FROM_DISP(p);
  406. DBG_HEAVY("matrox_cfbX_putc");
  408. yy *= fontheight(p);
  409. xx *= fontwidth(p);
  411. CRITBEGIN
  413. #ifdef __BIG_ENDIAN
  414. WaitTillIdle();
  415. mga_outl(M_OPMODE, M_OPMODE_8BPP);
  416. #else
  417. mga_fifo(7);
  418. #endif
  419. ar0 = fontwidth(p) - 1;
  420. mga_outl(M_FXBNDRY, ((xx+ar0)<<16) | xx);
  421. if (fontwidth(p) <= 8)
  422. step = 1;
  423. else if (fontwidth(p) <= 16)
  424. step = 2;
  425. else
  426. step = 4;
  427. if (fontwidth(p) == step << 3) {
  428. size_t charcell = fontheight(p)*step;
  429. /* TODO: Align charcell to 4B for BE */
  430. mga_outl(M_DWGCTL, M_DWG_ILOAD | M_DWG_SGNZERO | M_DWG_SHIFTZERO | M_DWG_BMONOWF | M_DWG_LINEAR | M_DWG_REPLACE);
  431. mga_outl(M_FCOL, fgx);
  432. mga_outl(M_BCOL, bgx);
  433. mga_outl(M_AR3, 0);
  434. mga_outl(M_AR0, fontheight(p)*fontwidth(p)-1);
  435. mga_ydstlen(yy, fontheight(p));
  436. mga_memcpy_toio(ACCESS_FBINFO(mmio.vbase), 0, p->fontdata+(c&p->charmask)*charcell, charcell);
  437. } else {
  438. u8* chardata = p->fontdata+(c&p->charmask)*fontheight(p)*step;
  439. int i;
  441. mga_outl(M_DWGCTL, M_DWG_ILOAD | M_DWG_SGNZERO | M_DWG_SHIFTZERO | M_DWG_BMONOWF | M_DWG_REPLACE);
  442. mga_outl(M_FCOL, fgx);
  443. mga_outl(M_BCOL, bgx);
  444. mga_outl(M_AR5, 0);
  445. mga_outl(M_AR3, 0);
  446. mga_outl(M_AR0, ar0);
  447. mga_ydstlen(yy, fontheight(p));
  449. switch (step) {
  450. case 1:
  451. for (i = fontheight(p); i > 0; i--) {
  452. #ifdef __LITTLE_ENDIAN
  453. mga_outl(0, *chardata++);
  454. #else
  455. mga_outl(0, (*chardata++) << 24);
  456. #endif
  457. }
  458. break;
  459. case 2:
  460. for (i = fontheight(p); i > 0; i--) {
  461. #ifdef __LITTLE_ENDIAN
  462. mga_outl(0, *(u_int16_t*)chardata);
  463. #else
  464. mga_outl(0, (*(u_int16_t*)chardata) << 16);
  465. #endif
  466. chardata += 2;
  467. }
  468. break;
  469. case 4:
  470. mga_memcpy_toio(ACCESS_FBINFO(mmio.vbase), 0, chardata, fontheight(p) * 4);
  471. break;
  472. }
  473. }
  474. WaitTillIdle();
  475. #ifdef __BIG_ENDIAN
  476. mga_outl(M_OPMODE, ACCESS_FBINFO(accel.m_opmode));
  477. #endif
  478. CRITEND
  479. }
  481. #ifdef FBCON_HAS_CFB8
  482. static void matrox_cfb8_putc(struct vc_data* conp, struct display* p, int c, int yy, int xx) {
  483. u_int32_t fgx, bgx;
  484. MINFO_FROM_DISP(p);
  486. DBG_HEAVY("matroxfb_cfb8_putc");
  488. fgx = attr_fgcol(p, c);
  489. bgx = attr_bgcol(p, c);
  490. fgx |= (fgx << 8);
  491. fgx |= (fgx << 16);
  492. bgx |= (bgx << 8);
  493. bgx |= (bgx << 16);
  494. ACCESS_FBINFO(curr.putc)(fgx, bgx, p, c, yy, xx);
  495. }
  496. #endif
  498. #ifdef FBCON_HAS_CFB16
  499. static void matrox_cfb16_putc(struct vc_data* conp, struct display* p, int c, int yy, int xx) {
  500. u_int32_t fgx, bgx;
  501. MINFO_FROM_DISP(p);
  503. DBG_HEAVY("matroxfb_cfb16_putc");
  505. fgx = ((u_int16_t*)p->dispsw_data)[attr_fgcol(p, c)];
  506. bgx = ((u_int16_t*)p->dispsw_data)[attr_bgcol(p, c)];
  507. fgx |= (fgx << 16);
  508. bgx |= (bgx << 16);
  509. ACCESS_FBINFO(curr.putc)(fgx, bgx, p, c, yy, xx);
  510. }
  511. #endif
  513. #if defined(FBCON_HAS_CFB32) || defined(FBCON_HAS_CFB24)
  514. static void matrox_cfb32_putc(struct vc_data* conp, struct display* p, int c, int yy, int xx) {
  515. u_int32_t fgx, bgx;
  516. MINFO_FROM_DISP(p);
  518. DBG_HEAVY("matroxfb_cfb32_putc");
  520. fgx = ((u_int32_t*)p->dispsw_data)[attr_fgcol(p, c)];
  521. bgx = ((u_int32_t*)p->dispsw_data)[attr_bgcol(p, c)];
  522. ACCESS_FBINFO(curr.putc)(fgx, bgx, p, c, yy, xx);
  523. }
  524. #endif
  526. static void matrox_cfbX_fastputcs(u_int32_t fgx, u_int32_t bgx, struct display* p, const unsigned short* s, int count, int yy, int xx) {
  527. unsigned int charcell;
  528. CRITFLAGS
  529. MINFO_FROM_DISP(p);
  531. yy *= fontheight(p);
  532. xx *= fontwidth(p);
  533. charcell = fontwidth(p) * fontheight(p);
  535. CRITBEGIN
  537. mga_fifo(3);
  538. mga_outl(M_DWGCTL, M_DWG_BITBLT | M_DWG_SGNZERO | M_DWG_SHIFTZERO | M_DWG_BMONOWF | M_DWG_LINEAR | M_DWG_REPLACE);
  539. mga_outl(M_FCOL, fgx);
  540. mga_outl(M_BCOL, bgx);
  541. while (count--) {
  542. u_int32_t ar3 = ACCESS_FBINFO(fastfont.mgabase) + (scr_readw(s++) & p->charmask)*charcell;
  544. mga_fifo(4);
  545. mga_outl(M_FXBNDRY, ((xx + fontwidth(p) - 1) << 16) | xx);
  546. mga_outl(M_AR3, ar3);
  547. mga_outl(M_AR0, (ar3 + charcell - 1) & 0x0003FFFF);
  548. mga_ydstlen(yy, fontheight(p));
  549. xx += fontwidth(p);
  550. }
  551. WaitTillIdle();
  553. CRITEND
  554. }
  556. static void matrox_cfbX_putcs(u_int32_t fgx, u_int32_t bgx, struct display* p, const unsigned short* s, int count, int yy, int xx) {
  557. u_int32_t step;
  558. u_int32_t ydstlen;
  559. u_int32_t xlen;
  560. u_int32_t ar0;
  561. u_int32_t charcell;
  562. u_int32_t fxbndry;
  563. vaddr_t mmio;
  564. int easy;
  565. CRITFLAGS
  566. MINFO_FROM_DISP(p);
  568. DBG_HEAVY("matroxfb_cfbX_putcs");
  570. yy *= fontheight(p);
  571. xx *= fontwidth(p);
  572. if (fontwidth(p) <= 8)
  573. step = 1;
  574. else if (fontwidth(p) <= 16)
  575. step = 2;
  576. else
  577. step = 4;
  578. charcell = fontheight(p)*step;
  579. xlen = (charcell + 3) & ~3;
  580. ydstlen = (yy << 16) | fontheight(p);
  581. if (fontwidth(p) == step << 3) {
  582. ar0 = fontheight(p)*fontwidth(p) - 1;
  583. easy = 1;
  584. } else {
  585. ar0 = fontwidth(p) - 1;
  586. easy = 0;
  587. }
  589. CRITBEGIN
  591. #ifdef __BIG_ENDIAN
  592. WaitTillIdle();
  593. mga_outl(M_OPMODE, M_OPMODE_8BPP);
  594. #else
  595. mga_fifo(3);
  596. #endif
  597. if (easy)
  598. mga_outl(M_DWGCTL, M_DWG_ILOAD | M_DWG_SGNZERO | M_DWG_SHIFTZERO | M_DWG_BMONOWF | M_DWG_LINEAR | M_DWG_REPLACE);
  599. else
  600. mga_outl(M_DWGCTL, M_DWG_ILOAD | M_DWG_SGNZERO | M_DWG_SHIFTZERO | M_DWG_BMONOWF | M_DWG_REPLACE);
  601. mga_outl(M_FCOL, fgx);
  602. mga_outl(M_BCOL, bgx);
  603. fxbndry = ((xx + fontwidth(p) - 1) << 16) | xx;
  604. mmio = ACCESS_FBINFO(mmio.vbase);
  605. while (count--) {
  606. u_int8_t* chardata = p->fontdata + (scr_readw(s++) & p->charmask)*charcell;
  608. mga_fifo(6);
  609. mga_writel(mmio, M_FXBNDRY, fxbndry);
  610. mga_writel(mmio, M_AR0, ar0);
  611. mga_writel(mmio, M_AR3, 0);
  612. if (easy) {
  613. mga_writel(mmio, M_YDSTLEN | M_EXEC, ydstlen);
  614. mga_memcpy_toio(mmio, 0, chardata, xlen);
  615. } else {
  616. mga_writel(mmio, M_AR5, 0);
  617. mga_writel(mmio, M_YDSTLEN | M_EXEC, ydstlen);
  618. switch (step) {
  619. case 1: {
  620. u_int8_t* charend = chardata + charcell;
  621. for (; chardata != charend; chardata++) {
  622. #ifdef __LITTLE_ENDIAN
  623. mga_writel(mmio, 0, *chardata);
  624. #else
  625. mga_writel(mmio, 0, (*chardata) << 24);
  626. #endif
  627. }
  628. }
  629. break;
  630. case 2: {
  631. u_int8_t* charend = chardata + charcell;
  632. for (; chardata != charend; chardata += 2) {
  633. #ifdef __LITTLE_ENDIAN
  634. mga_writel(mmio, 0, *(u_int16_t*)chardata);
  635. #else
  636. mga_writel(mmio, 0, (*(u_int16_t*)chardata) << 16);
  637. #endif
  638. }
  639. }
  640. break;
  641. default:
  642. mga_memcpy_toio(mmio, 0, chardata, charcell);
  643. break;
  644. }
  645. }
  646. fxbndry += fontwidth(p) + (fontwidth(p) << 16);
  647. }
  648. WaitTillIdle();
  649. #ifdef __BIG_ENDIAN
  650. mga_outl(M_OPMODE, ACCESS_FBINFO(accel.m_opmode));
  651. #endif
  652. CRITEND
  653. }
  655. #ifdef FBCON_HAS_CFB8
  656. static void matrox_cfb8_putcs(struct vc_data* conp, struct display* p, const unsigned short* s, int count, int yy, int xx) {
  657. u_int16_t c;
  658. u_int32_t fgx, bgx;
  659. MINFO_FROM_DISP(p);
  661. DBG_HEAVY("matroxfb_cfb8_putcs");
  663. c = scr_readw(s);
  664. fgx = attr_fgcol(p, c);
  665. bgx = attr_bgcol(p, c);
  666. fgx |= (fgx << 8);
  667. fgx |= (fgx << 16);
  668. bgx |= (bgx << 8);
  669. bgx |= (bgx << 16);
  670. ACCESS_FBINFO(curr.putcs)(fgx, bgx, p, s, count, yy, xx);
  671. }
  672. #endif
  674. #ifdef FBCON_HAS_CFB16
  675. static void matrox_cfb16_putcs(struct vc_data* conp, struct display* p, const unsigned short* s, int count, int yy, int xx) {
  676. u_int16_t c;
  677. u_int32_t fgx, bgx;
  678. MINFO_FROM_DISP(p);
  680. DBG_HEAVY("matroxfb_cfb16_putcs");
  682. c = scr_readw(s);
  683. fgx = ((u_int16_t*)p->dispsw_data)[attr_fgcol(p, c)];
  684. bgx = ((u_int16_t*)p->dispsw_data)[attr_bgcol(p, c)];
  685. fgx |= (fgx << 16);
  686. bgx |= (bgx << 16);
  687. ACCESS_FBINFO(curr.putcs)(fgx, bgx, p, s, count, yy, xx);
  688. }
  689. #endif
  691. #if defined(FBCON_HAS_CFB32) || defined(FBCON_HAS_CFB24)
  692. static void matrox_cfb32_putcs(struct vc_data* conp, struct display* p, const unsigned short* s, int count, int yy, int xx) {
  693. u_int16_t c;
  694. u_int32_t fgx, bgx;
  695. MINFO_FROM_DISP(p);
  697. DBG_HEAVY("matroxfb_cfb32_putcs");
  699. c = scr_readw(s);
  700. fgx = ((u_int32_t*)p->dispsw_data)[attr_fgcol(p, c)];
  701. bgx = ((u_int32_t*)p->dispsw_data)[attr_bgcol(p, c)];
  702. ACCESS_FBINFO(curr.putcs)(fgx, bgx, p, s, count, yy, xx);
  703. }
  704. #endif
  706. #ifdef FBCON_HAS_CFB4
  707. static void matrox_cfb4_revc(struct display* p, int xx, int yy) {
  708. CRITFLAGS
  709. MINFO_FROM_DISP(p);
  711. DBG_LOOP("matroxfb_cfb4_revc");
  713. if (fontwidth(p) & 1) {
  714. fbcon_cfb4_revc(p, xx, yy);
  715. return;
  716. }
  717. yy *= fontheight(p);
  718. xx *= fontwidth(p);
  719. xx |= (xx + fontwidth(p)) << 16;
  720. xx >>= 1;
  722. CRITBEGIN
  724. mga_fifo(5);
  725. mga_outl(M_DWGCTL, ACCESS_FBINFO(accel.m_dwg_rect) | M_DWG_XOR);
  726. mga_outl(M_FCOL, 0xFFFFFFFF);
  727. mga_outl(M_FXBNDRY, xx);
  728. mga_outl(M_YDST, yy * p->var.xres_virtual >> 6);
  729. mga_outl(M_LEN | M_EXEC, fontheight(p));
  730. WaitTillIdle();
  732. CRITEND
  733. }
  734. #endif
  736. #ifdef FBCON_HAS_CFB8
  737. static void matrox_cfb8_revc(struct display* p, int xx, int yy) {
  738. CRITFLAGS
  739. MINFO_FROM_DISP(p);
  741. DBG_LOOP("matrox_cfb8_revc")
  743. yy *= fontheight(p);
  744. xx *= fontwidth(p);
  746. CRITBEGIN
  748. mga_fifo(4);
  749. mga_outl(M_DWGCTL, ACCESS_FBINFO(accel.m_dwg_rect) | M_DWG_XOR);
  750. mga_outl(M_FCOL, 0x0F0F0F0F);
  751. mga_outl(M_FXBNDRY, ((xx + fontwidth(p)) << 16) | xx);
  752. mga_ydstlen(yy, fontheight(p));
  753. WaitTillIdle();
  755. CRITEND
  756. }
  757. #endif
  759. static void matrox_cfbX_revc(struct display* p, int xx, int yy) {
  760. CRITFLAGS
  761. MINFO_FROM_DISP(p);
  763. DBG_LOOP("matrox_cfbX_revc")
  765. yy *= fontheight(p);
  766. xx *= fontwidth(p);
  768. CRITBEGIN
  770. mga_fifo(4);
  771. mga_outl(M_DWGCTL, ACCESS_FBINFO(accel.m_dwg_rect) | M_DWG_XOR);
  772. mga_outl(M_FCOL, 0xFFFFFFFF);
  773. mga_outl(M_FXBNDRY, ((xx + fontwidth(p)) << 16) | xx);
  774. mga_ydstlen(yy, fontheight(p));
  775. WaitTillIdle();
  777. CRITEND
  778. }
  780. static void matrox_cfbX_clear_margins(struct vc_data* conp, struct display* p, int bottom_only) {
  781. unsigned int bottom_height, right_width;
  782. unsigned int bottom_start, right_start;
  783. unsigned int cell_h, cell_w;
  785. DBG("matrox_cfbX_clear_margins")
  787. cell_w = fontwidth(p);
  788. if (!cell_w) return; /* PARANOID */
  789. right_width = p->var.xres % cell_w;
  790. right_start = p->var.xres - right_width;
  791. if (!bottom_only && right_width) {
  792. /* clear whole right margin, not only visible portion */
  793. matroxfb_accel_clear(     PMXINFO(p)
  794.      /* color */  0x00000000,
  795.      /* y */      0,
  796.      /* x */      p->var.xoffset + right_start,
  797.      /* height */ p->var.yres_virtual,
  798.      /* width */  right_width);
  799. }
  800. cell_h = fontheight(p);
  801. if (!cell_h) return; /* PARANOID */
  802. bottom_height = p->var.yres % cell_h;
  803. if (bottom_height) {
  804. bottom_start = p->var.yres - bottom_height;
  805. matroxfb_accel_clear(   PMXINFO(p)
  806.      /* color */  0x00000000,
  807.      /* y */   p->var.yoffset + bottom_start,
  808.      /* x */   p->var.xoffset,
  809.      /* height */ bottom_height,
  810.      /* width */  right_start);
  811. }
  812. }
  814. static void matrox_text_setup(struct display* p) {
  815. MINFO_FROM_DISP(p);
  817. p->next_line = p->line_length ? p->line_length : ((p->var.xres_virtual / (fontwidth(p)?fontwidth(p):8)) * ACCESS_FBINFO(devflags.textstep));
  818. p->next_plane = 0;
  819. }
  821. static void matrox_text_bmove(struct display* p, int sy, int sx, int dy, int dx,
  822. int height, int width) {
  823. unsigned int srcoff;
  824. unsigned int dstoff;
  825. unsigned int step;
  826. CRITFLAGS
  827. MINFO_FROM_DISP(p);
  829. CRITBEGIN
  831. step = ACCESS_FBINFO(devflags.textstep);
  832. srcoff = (sy * p->next_line) + (sx * step);
  833. dstoff = (dy * p->next_line) + (dx * step);
  834. if (dstoff < srcoff) {
  835. while (height > 0) {
  836. int i;
  837. for (i = width; i > 0; dstoff += step, srcoff += step, i--)
  838. mga_writew(ACCESS_FBINFO(video.vbase), dstoff, mga_readw(ACCESS_FBINFO(video.vbase), srcoff));
  839. height--;
  840. dstoff += p->next_line - width * step;
  841. srcoff += p->next_line - width * step;
  842. }
  843. } else {
  844. unsigned int off;
  846. off = (height - 1) * p->next_line + (width - 1) * step;
  847. srcoff += off;
  848. dstoff += off;
  849. while (height > 0) {
  850. int i;
  851. for (i = width; i > 0; dstoff -= step, srcoff -= step, i--)
  852. mga_writew(ACCESS_FBINFO(video.vbase), dstoff, mga_readw(ACCESS_FBINFO(video.vbase), srcoff));
  853. dstoff -= p->next_line - width * step;
  854. srcoff -= p->next_line - width * step;
  855. height--;
  856. }
  857. }
  858. CRITEND
  859. }
  861. static void matrox_text_clear(struct vc_data* conp, struct display* p, int sy, int sx,
  862. int height, int width) {
  863. unsigned int offs;
  864. unsigned int val;
  865. unsigned int step;
  866. CRITFLAGS
  867. MINFO_FROM_DISP(p);
  869. step = ACCESS_FBINFO(devflags.textstep);
  870. offs = sy * p->next_line + sx * step;
  871. val = ntohs((attr_bgcol(p, conp->vc_video_erase_char) << 4) | attr_fgcol(p, conp->vc_video_erase_char) | (' ' << 8));
  873. CRITBEGIN
  875. while (height > 0) {
  876. int i;
  877. for (i = width; i > 0; offs += step, i--)
  878. mga_writew(ACCESS_FBINFO(video.vbase), offs, val);
  879. offs += p->next_line - width * step;
  880. height--;
  881. }
  882. CRITEND
  883. }
  885. static void matrox_text_putc(struct vc_data* conp, struct display* p, int c, int yy, int xx) {
  886. unsigned int offs;
  887. unsigned int chr;
  888. unsigned int step;
  889. CRITFLAGS
  890. MINFO_FROM_DISP(p);
  892. step = ACCESS_FBINFO(devflags.textstep);
  893. offs = yy * p->next_line + xx * step;
  894. chr = attr_fgcol(p,c) | (attr_bgcol(p,c) << 4) | ((c & p->charmask) << 8);
  895. if (chr & 0x10000) chr |= 0x08;
  897. CRITBEGIN
  899. mga_writew(ACCESS_FBINFO(video.vbase), offs, ntohs(chr));
  901. CRITEND
  902. }
  904. static void matrox_text_putcs(struct vc_data* conp, struct display* p, const unsigned short* s,
  905. int count, int yy, int xx) {
  906. unsigned int offs;
  907. unsigned int attr;
  908. unsigned int step;
  909. u_int16_t c;
  910. CRITFLAGS
  911. MINFO_FROM_DISP(p);
  913. step = ACCESS_FBINFO(devflags.textstep);
  914. offs = yy * p->next_line + xx * step;
  915. c = scr_readw(s);
  916. attr = attr_fgcol(p, c) | (attr_bgcol(p, c) << 4);
  918. CRITBEGIN
  920. while (count-- > 0) {
  921. unsigned int chr = ((scr_readw(s++)) & p->charmask) << 8;
  922. if (chr & 0x10000) chr ^= 0x10008;
  923. mga_writew(ACCESS_FBINFO(video.vbase), offs, ntohs(attr|chr));
  924. offs += step;
  925. }
  927. CRITEND
  928. }
  930. static void matrox_text_revc(struct display* p, int xx, int yy) {
  931. unsigned int offs;
  932. unsigned int step;
  933. CRITFLAGS
  934. MINFO_FROM_DISP(p);
  936. step = ACCESS_FBINFO(devflags.textstep);
  937. offs = yy * p->next_line + xx * step + 1;
  939. CRITBEGIN
  941. mga_writeb(ACCESS_FBINFO(video.vbase), offs, mga_readb(ACCESS_FBINFO(video.vbase), offs) ^ 0x77);
  943. CRITEND
  944. }
  946. void matrox_text_createcursor(WPMINFO struct display* p) {
  947. CRITFLAGS
  949. if (ACCESS_FBINFO(currcon_display) != p)
  950. return;
  952. matroxfb_createcursorshape(PMINFO p, 0);
  954. CRITBEGIN
  956. mga_setr(M_CRTC_INDEX, 0x0A, ACCESS_FBINFO(cursor.u));
  957. mga_setr(M_CRTC_INDEX, 0x0B, ACCESS_FBINFO(cursor.d) - 1);
  959. CRITEND
  960. }
  962. static void matrox_text_cursor(struct display* p, int mode, int x, int y) {
  963. unsigned int pos;
  964. CRITFLAGS
  965. MINFO_FROM_DISP(p);
  967. if (ACCESS_FBINFO(currcon_display) != p)
  968. return;
  970. if (mode == CM_ERASE) {
  971. if (ACCESS_FBINFO(cursor.state) != CM_ERASE) {
  973. CRITBEGIN
  975. mga_setr(M_CRTC_INDEX, 0x0A, 0x20);
  977. CRITEND
  979. ACCESS_FBINFO(cursor.state) = CM_ERASE;
  980. }
  981. return;
  982. }
  983. if ((p->conp->vc_cursor_type & CUR_HWMASK) != ACCESS_FBINFO(cursor.type))
  984. matrox_text_createcursor(PMINFO p);
  986. /* DO NOT CHECK cursor.x != x because of matroxfb_vgaHWinit moves cursor to 0,0 */
  987. ACCESS_FBINFO(cursor.x) = x;
  988. ACCESS_FBINFO(cursor.y) = y;
  989. pos = p->next_line / ACCESS_FBINFO(devflags.textstep) * y + x;
  991. CRITBEGIN
  993. mga_setr(M_CRTC_INDEX, 0x0F, pos);
  994. mga_setr(M_CRTC_INDEX, 0x0E, pos >> 8);
  996. mga_setr(M_CRTC_INDEX, 0x0A, ACCESS_FBINFO(cursor.u));
  998. CRITEND
  1000. ACCESS_FBINFO(cursor.state) = CM_DRAW;
  1001. }
  1003. void matrox_text_round(CPMINFO struct fb_var_screeninfo* var, struct display* p) {
  1004. unsigned hf;
  1005. unsigned vf;
  1006. unsigned vxres;
  1007. unsigned ych;
  1009. hf = fontwidth(p);
  1010. if (!hf) hf = 8;
  1011. /* do not touch xres */
  1012. vxres = (var->xres_virtual + hf - 1) / hf;
  1013. if (vxres >= 256)
  1014. vxres = 255;
  1015. if (vxres < 16)
  1016. vxres = 16;
  1017. vxres = (vxres + 1) & ~1; /* must be even */
  1018. vf = fontheight(p);
  1019. if (!vf) vf = 16;
  1020. if (var->yres < var->yres_virtual) {
  1021. ych = ACCESS_FBINFO(devflags.textvram) / vxres;
  1022. var->yres_virtual = ych * vf;
  1023. } else
  1024. ych = var->yres_virtual / vf;
  1025. if (vxres * ych > ACCESS_FBINFO(devflags.textvram)) {
  1026. ych = ACCESS_FBINFO(devflags.textvram) / vxres;
  1027. var->yres_virtual = ych * vf;
  1028. }
  1029. var->xres_virtual = vxres * hf;
  1030. }
  1032. static int matrox_text_setfont(struct display* p, int width, int height) {
  1033. DBG("matrox_text_setfont");
  1035. if (p) {
  1036. MINFO_FROM_DISP(p);
  1038. matrox_text_round(PMINFO &p->var, p);
  1039. p->next_line = p->line_length = ((p->var.xres_virtual / (fontwidth(p)?fontwidth(p):8)) * ACCESS_FBINFO(devflags.textstep));
  1041. if (p->conp)
  1042. matrox_text_createcursor(PMINFO p);
  1043. }
  1044. return 0;
  1045. }
  1047. #define matrox_cfb16_revc matrox_cfbX_revc
  1048. #define matrox_cfb24_revc matrox_cfbX_revc
  1049. #define matrox_cfb32_revc matrox_cfbX_revc
  1051. #define matrox_cfb24_clear matrox_cfb32_clear
  1052. #define matrox_cfb24_putc matrox_cfb32_putc
  1053. #define matrox_cfb24_putcs matrox_cfb32_putcs
  1055. #ifdef FBCON_HAS_VGATEXT
  1056. static struct display_switch matroxfb_text = {
  1057. setup: matrox_text_setup,
  1058. bmove: matrox_text_bmove,
  1059. clear: matrox_text_clear,
  1060. putc: matrox_text_putc,
  1061. putcs: matrox_text_putcs,
  1062. revc: matrox_text_revc,
  1063. cursor: matrox_text_cursor,
  1064. set_font: matrox_text_setfont,
  1065. fontwidthmask: FONTWIDTH(8)|FONTWIDTH(9)
  1066. };
  1067. #endif
  1069. #ifdef FBCON_HAS_CFB4
  1070. static struct display_switch matroxfb_cfb4 = {
  1071. setup: fbcon_cfb4_setup,
  1072. bmove: matrox_cfb4_bmove,
  1073. clear: matrox_cfb4_clear,
  1074. putc: fbcon_cfb4_putc,
  1075. putcs: fbcon_cfb4_putcs,
  1076. revc: matrox_cfb4_revc,
  1077. fontwidthmask: FONTWIDTH(8) /* fix, fix, fix it */
  1078. };
  1079. #endif
  1081. #ifdef FBCON_HAS_CFB8
  1082. static struct display_switch matroxfb_cfb8 = {
  1083. setup: fbcon_cfb8_setup,
  1084. bmove: matrox_cfbX_bmove,
  1085. clear: matrox_cfb8_clear,
  1086. putc: matrox_cfb8_putc,
  1087. putcs: matrox_cfb8_putcs,
  1088. revc: matrox_cfb8_revc,
  1089. clear_margins: matrox_cfbX_clear_margins,
  1090. fontwidthmask: ~1 /* FONTWIDTHS */
  1091. };
  1092. #endif
  1094. #ifdef FBCON_HAS_CFB16
  1095. static struct display_switch matroxfb_cfb16 = {
  1096. setup: fbcon_cfb16_setup,
  1097. bmove: matrox_cfbX_bmove,
  1098. clear: matrox_cfb16_clear,
  1099. putc: matrox_cfb16_putc,
  1100. putcs: matrox_cfb16_putcs,
  1101. revc: matrox_cfb16_revc,
  1102. clear_margins: matrox_cfbX_clear_margins,
  1103. fontwidthmask: ~1 /* FONTWIDTHS */
  1104. };
  1105. #endif
  1107. #ifdef FBCON_HAS_CFB24
  1108. static struct display_switch matroxfb_cfb24 = {
  1109. setup: fbcon_cfb24_setup,
  1110. bmove: matrox_cfbX_bmove,
  1111. clear: matrox_cfb24_clear,
  1112. putc: matrox_cfb24_putc,
  1113. putcs: matrox_cfb24_putcs,
  1114. revc: matrox_cfb24_revc,
  1115. clear_margins: matrox_cfbX_clear_margins,
  1116. fontwidthmask: ~1 /* FONTWIDTHS */ /* TODO: and what about non-aligned access on BE? I think that there are no in my code */
  1117. };
  1118. #endif
  1120. #ifdef FBCON_HAS_CFB32
  1121. static struct display_switch matroxfb_cfb32 = {
  1122. setup: fbcon_cfb32_setup,
  1123. bmove: matrox_cfbX_bmove,
  1124. clear: matrox_cfb32_clear,
  1125. putc: matrox_cfb32_putc,
  1126. putcs: matrox_cfb32_putcs,
  1127. revc: matrox_cfb32_revc,
  1128. clear_margins: matrox_cfbX_clear_margins,
  1129. fontwidthmask: ~1 /* FONTWIDTHS */
  1130. };
  1131. #endif
  1133. void initMatrox(WPMINFO struct display* p) {
  1134. struct display_switch *swtmp;
  1136. DBG("initMatrox")
  1138. if (ACCESS_FBINFO(currcon_display) != p)
  1139. return;
  1140. if (p->dispsw && p->conp)
  1141. fb_con.con_cursor(p->conp, CM_ERASE);
  1142. p->dispsw_data = NULL;
  1143. if ((p->var.accel_flags & FB_ACCELF_TEXT) != FB_ACCELF_TEXT) {
  1144. if (p->type == FB_TYPE_TEXT) {
  1145. swtmp = &matroxfb_text;
  1146. } else {
  1147. switch (p->var.bits_per_pixel) {
  1148. #ifdef FBCON_HAS_CFB4
  1149. case 4:
  1150. swtmp = &fbcon_cfb4;
  1151. break;
  1152. #endif
  1153. #ifdef FBCON_HAS_CFB8
  1154. case 8:
  1155. swtmp = &fbcon_cfb8;
  1156. break;
  1157. #endif
  1158. #ifdef FBCON_HAS_CFB16
  1159. case 16:
  1160. p->dispsw_data = &ACCESS_FBINFO(cmap.cfb16);
  1161. swtmp = &fbcon_cfb16;
  1162. break;
  1163. #endif
  1164. #ifdef FBCON_HAS_CFB24
  1165. case 24:
  1166. p->dispsw_data = &ACCESS_FBINFO(cmap.cfb24);
  1167. swtmp = &fbcon_cfb24;
  1168. break;
  1169. #endif
  1170. #ifdef FBCON_HAS_CFB32
  1171. case 32:
  1172. p->dispsw_data = &ACCESS_FBINFO(cmap.cfb32);
  1173. swtmp = &fbcon_cfb32;
  1174. break;
  1175. #endif
  1176. default:
  1177. p->dispsw = &fbcon_dummy;
  1178. return;
  1179. }
  1180. }
  1181. dprintk(KERN_INFO "matroxfb: acceleration disabledn");
  1182. } else if (p->type == FB_TYPE_TEXT) {
  1183. swtmp = &matroxfb_text;
  1184. } else {
  1185. switch (p->var.bits_per_pixel) {
  1186. #ifdef FBCON_HAS_CFB4
  1187. case 4:
  1188. swtmp = &matroxfb_cfb4;
  1189. break;
  1190. #endif
  1191. #ifdef FBCON_HAS_CFB8
  1192. case 8:
  1193. swtmp = &matroxfb_cfb8;
  1194. break;
  1195. #endif
  1196. #ifdef FBCON_HAS_CFB16
  1197. case 16:
  1198. p->dispsw_data = &ACCESS_FBINFO(cmap.cfb16);
  1199. swtmp = &matroxfb_cfb16;
  1200. break;
  1201. #endif
  1202. #ifdef FBCON_HAS_CFB24
  1203. case 24:
  1204. p->dispsw_data = &ACCESS_FBINFO(cmap.cfb24);
  1205. swtmp = &matroxfb_cfb24;
  1206. break;
  1207. #endif
  1208. #ifdef FBCON_HAS_CFB32
  1209. case 32:
  1210. p->dispsw_data = &ACCESS_FBINFO(cmap.cfb32);
  1211. swtmp = &matroxfb_cfb32;
  1212. break;
  1213. #endif
  1214. default:
  1215. p->dispsw = &fbcon_dummy;
  1216. return;
  1217. }
  1218. }
  1219. memcpy(&ACCESS_FBINFO(dispsw), swtmp, sizeof(ACCESS_FBINFO(dispsw)));
  1220. p->dispsw = &ACCESS_FBINFO(dispsw);
  1221. if ((p->type != FB_TYPE_TEXT) && ACCESS_FBINFO(devflags.hwcursor)) {
  1222. ACCESS_FBINFO(hw_switch)->selhwcursor(PMINFO p);
  1223. }
  1224. }
  1226. void matrox_init_putc(WPMINFO struct display* p, void (*dac_createcursor)(WPMINFO struct display* p)) {
  1227. int i;
  1229. if (p && p->conp) {
  1230. if (p->type == FB_TYPE_TEXT) {
  1231. matrox_text_createcursor(PMINFO p);
  1232. matrox_text_loadfont(PMINFO p);
  1233. i = 0;
  1234. } else {
  1235. dac_createcursor(PMINFO p);
  1236. i = matroxfb_fastfont_tryset(PMINFO p);
  1237. }
  1238. } else
  1239. i = 0;
  1240. if (i) {
  1241. ACCESS_FBINFO(curr.putc) = matrox_cfbX_fastputc;
  1242. ACCESS_FBINFO(curr.putcs) = matrox_cfbX_fastputcs;
  1243. } else {
  1244. ACCESS_FBINFO(curr.putc) = matrox_cfbX_putc;
  1245. ACCESS_FBINFO(curr.putcs) = matrox_cfbX_putcs;
  1246. }
  1247. }
  1248. MODULE_LICENSE("GPL");