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

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

嵌入式Linux

开发平台：

Unix_Linux

tridentfb.c：源码内容
  1. /*
  2.  * Frame buffer driver for Trident Blade and Image series
  3.  *
  4.  * Copyright 2001,2002 - Jani Monoses   <jani@astechnix.ro>
  5.  *
  6.  * $Id: tridentfb.c,v 1.2 2002/02/13 17:44:14 marcelo Exp $
  7.  *
  8.  * CREDITS:(in order of appearance)
  9.  *  skeletonfb.c by Geert Uytterhoeven and other fb code in drivers/video
  10.  *  Special thanks ;) to Mattia Crivellini <tia@mclink.it>
  11.  *  much inspired by the XFree86 4.1.0 Trident driver sources by Alan Hourihane
  12.  *  the FreeVGA project
  13.  * Francesco Salvestrini <salvestrini@users.sf.net> XP support,code,suggestions
  14.  * NOTES:
  15.  *  Tested on Compaq Presario 12XL300 with CyberBladei1
  16.  *  Tested on Toshiba 1800-514 with CyberBladeXPAi1
  17.  *  No monitors were harmed during the writing of this driver
  18.  * TODO:
  19.  *  timing value tweaking so it looks good on every monitor in every mode
  20.  *  test text acceleration for the Image series
  21.  * test DPMS stuff
  22.  */
  24. #include <linux/config.h>
  25. #include <linux/module.h>
  26. #include <linux/fb.h>
  27. #include <linux/init.h>
  28. #include <linux/pci.h>
  30. #include <video/fbcon.h>
  31. #include <video/fbcon-cfb8.h>
  32. #include <video/fbcon-cfb16.h>
  33. #include <video/fbcon-cfb24.h>
  34. #include <video/fbcon-cfb32.h>
  36. #include "tridentfb.h"
  38. #define VERSION "0.6.8"
  40. struct tridentfb_par {
  41. struct fb_var_screeninfo var;
  42. int bpp;
  43. int hres;
  44. int vres;
  45. int linelength;
  46. int vclk; //in MHz
  48. int vtotal;
  49. int vdispend;
  50. int vsyncstart;
  51. int vsyncend;
  52. int vblankstart;
  53. int vblankend;
  55. int htotal;
  56. int hdispend;
  57. int hsyncstart;
  58. int hsyncend;
  59. int hblankstart;
  60. int hblankend;
  61. };
  63. struct tridentfb_info {
  64. struct fb_info_gen gen;
  65. unsigned int fbmem_virt; //framebuffer virtual memory address
  66. unsigned int fbmem; //framebuffer physical memory address
  67. unsigned int memsize; //size of fbmem
  68. unsigned int io; //io space address
  69. unsigned int io_virt; //iospace virtual memory address
  70. unsigned int nativex; //flat panel xres
  71. struct tridentfb_par currentmode;
  72. };
  74. static struct fb_ops tridentfb_ops;
  76. static struct tridentfb_info fb_info;
  77. static struct display disp;
  79. static struct { unsigned char red,green,blue,transp; } palette[256];
  81. static struct fb_var_screeninfo default_var;
  83. static char * tridentfb_name = "Trident";
  85. static int family;
  86. static int pci_id;
  88. static int defaultaccel;
  89. static int displaytype;
  91. static int pseudo_pal[16];
  94. /* defaults which are normally overriden by user values */
  96. /* video mode */
  97. static char * mode = "640x480";
  98. static int bpp = 8;
  100. static int noaccel;
  101. static int accel;
  103. static int center;
  104. static int stretch;
  106. static int fp;
  107. static int crt;
  109. static int memsize;
  110. static int memdiff;
  111. static int nativex;
  114. MODULE_PARM(mode,"s");
  115. MODULE_PARM(bpp,"i");
  116. MODULE_PARM(center,"i");
  117. MODULE_PARM(stretch,"i");
  118. MODULE_PARM(noaccel,"i");
  119. MODULE_PARM(accel,"i");
  120. MODULE_PARM(memsize,"i");
  121. MODULE_PARM(memdiff,"i");
  122. MODULE_PARM(nativex,"i");
  123. MODULE_PARM(fp,"i");
  124. MODULE_PARM(crt,"i");
  128. #define CRT 0x3D0 //CRTC registers offset for color display
  130. #ifndef TRIDENT_MMIO
  131. #define TRIDENT_MMIO 1
  132. #endif
  134. #if TRIDENT_MMIO
  135. #define t_outb(val,reg) writeb(val,fb_info.io_virt + reg)
  136. #define t_inb(reg) readb(fb_info.io_virt + reg)
  137. #else
  138. #define t_outb(val,reg) outb(val,reg)
  139. #define t_inb(reg) inb(reg)
  140. #endif
  143. static struct accel_switch {
  144. void (*init_accel)(int,int);
  145. void (*wait_engine)(void);
  146. void (*fill_rect)(int,int,int,int,int);
  147. void (*copy_rect)(int,int,int,int,int,int);
  148. } *acc;
  150. #define writemmr(r,v) writel(v, fb_info.io_virt + r)
  151. #define readmmr(r) readl(fb_info.io_virt + r)
  153. /*
  154.  * Blade specific acceleration.Not XP's though those are
  155.  * unaccelerated.
  156.  */
  158. #define point(x,y) ((y)<<16|(x))
  159. #define STA 0x2120
  160. #define CMD 0x2144
  161. #define ROP 0x2148
  162. #define CLR 0x2160
  163. #define SR1 0x2100
  164. #define SR2 0x2104
  165. #define DR1 0x2108
  166. #define DR2 0x210C
  168. #define REPL(x) x = x | x<<16
  169. #define ROP_S 0xCC
  171. static void blade_init_accel(int pitch,int bpp)
  172. {
  173. int v1 = (pitch>>3)<<20;
  174. int tmp = 0,v2;
  175. switch (bpp) {
  176. case 8:tmp = 0;break;
  177. case 15:tmp = 5;break;
  178. case 16:tmp = 1;break;
  179. case 24:
  180. case 32:tmp = 2;break;
  181. }
  182. v2 = v1 | (tmp<<29);
  183. writemmr(0x21C0,v2);
  184. writemmr(0x21C4,v2);
  185. writemmr(0x21B8,v2);
  186. writemmr(0x21BC,v2);
  187. writemmr(0x21D0,v1);
  188. writemmr(0x21D4,v1);
  189. writemmr(0x21C8,v1);
  190. writemmr(0x21CC,v1);
  191. writemmr(0x216C,0);
  192. }
  194. static void blade_wait_engine(void)
  195. {
  196. while(readmmr(STA) & 0xFA800000);
  197. }
  199. static void blade_fill_rect(int x,int y,int w,int h,int c)
  200. {
  201. writemmr(CLR,c);
  202. writemmr(ROP,ROP_S);
  203. writemmr(CMD,0x20000000|1<<19|1<<4|2<<2);
  205. writemmr(DR1,point(x,y));
  206. writemmr(DR2,point(x+w-1,y+h-1));
  207. }
  209. static void blade_copy_rect(int x1,int y1,int x2,int y2,int w,int h)
  210. {
  211. int s1,s2,d1,d2;
  212. int direction = 2;
  213. s1 = point(x1,y1);
  214. s2 = point(x1+w-1,y1+h-1);
  215. d1 = point(x2,y2);
  216. d2 = point(x2+w-1,y2+h-1);
  218. if ((y1 > y2) || ((y1 == y2) && (x1 >x2)))
  219. direction = 0;
  222. writemmr(ROP,ROP_S);
  223. writemmr(CMD,0xE0000000|1<<19|1<<4|1<<2|direction);
  225. writemmr(SR1,direction?s2:s1);
  226. writemmr(SR2,direction?s1:s2);
  227. writemmr(DR1,direction?d2:d1);
  228. writemmr(DR2,direction?d1:d2);
  229. }
  231. static struct accel_switch accel_blade = {
  232. blade_init_accel,
  233. blade_wait_engine,
  234. blade_fill_rect,
  235. blade_copy_rect,
  236. };
  238. /*
  239.  * Image specific acceleration functions
  240.  */
  241. static void image_init_accel(int pitch,int bpp)
  242. {
  243. int tmp = 0;
  244.     switch (bpp) {
  245. case 8:tmp = 0;break;
  246. case 15:tmp = 5;break;
  247. case 16:tmp = 1;break;
  248. case 24:
  249. case 32:tmp = 2;break;
  250. }
  251. writemmr(0x2120, 0xF0000000);
  252. writemmr(0x2120, 0x40000000|tmp);
  253. writemmr(0x2120, 0x80000000);
  254. writemmr(0x2144, 0x00000000);
  255. writemmr(0x2148, 0x00000000);
  256. writemmr(0x2150, 0x00000000);
  257. writemmr(0x2154, 0x00000000);
  258. writemmr(0x2120, 0x60000000 |(pitch<<16) |pitch);
  259. writemmr(0x216C, 0x00000000);
  260. writemmr(0x2170, 0x00000000);
  261. writemmr(0x217C, 0x00000000);
  262. writemmr(0x2120, 0x10000000);
  263. writemmr(0x2130, (2047 << 16) | 2047);
  264. }
  266. static void image_wait_engine(void)
  267. {
  268. while(readmmr(0x2164) & 0xF0000000);
  269. }
  271. static void image_fill_rect(int x,int y,int w,int h,int c)
  272. {
  273. writemmr(0x2120,0x80000000);
  274. writemmr(0x2120,0x90000000|ROP_S);
  276. writemmr(0x2144,c);
  278. writemmr(DR1,point(x,y));
  279. writemmr(DR2,point(x+w-1,y+h-1));
  281. writemmr(0x2124,0x80000000|3<<22|1<<10|1<<9);
  282. }
  284. static void image_copy_rect(int x1,int y1,int x2,int y2,int w,int h)
  285. {
  286. int s1,s2,d1,d2;
  287. int direction = 2;
  288. s1 = point(x1,y1);
  289. s2 = point(x1+w-1,y1+h-1);
  290. d1 = point(x2,y2);
  291. d2 = point(x2+w-1,y2+h-1);
  293. if ((y1 > y2) || ((y1 == y2) && (x1 >x2)))
  294. direction = 0;
  296. writemmr(0x2120,0x80000000);
  297. writemmr(0x2120,0x90000000|ROP_S);
  299. writemmr(SR1,direction?s2:s1);
  300. writemmr(SR2,direction?s1:s2);
  301. writemmr(DR1,direction?d2:d1);
  302. writemmr(DR2,direction?d1:d2);
  303. writemmr(0x2124,0x80000000|1<<22|1<<10|1<<7|direction);
  304. }
  307. static struct accel_switch accel_image = {
  308. image_init_accel,
  309. image_wait_engine,
  310. image_fill_rect,
  311. image_copy_rect,
  312. };
  314. /*
  315.  * Accel functions called by the upper layers
  316.  */
  318. static void trident_bmove (struct display *p, int sy, int sx,
  319. int dy, int dx, int height, int width)
  320. {
  321. sx *= fontwidth(p);
  322. dx *= fontwidth(p);
  323. width *= fontwidth(p);
  324. sy *= fontheight(p);
  325. dy *= fontheight(p);
  326. height *= fontheight(p);
  327. acc->copy_rect(sx,sy,dx,dy,width,height);
  328. acc->wait_engine();
  329. }
  330. static void trident_clear_helper (int c, struct display *p,
  331. int sy, int sx, int height, int width)
  332. {
  333. sx *= fontwidth(p);
  334. sy *= fontheight(p);
  335. width *= fontwidth(p);
  336. height *= fontheight(p);
  337. acc->fill_rect(sx,sy,width,height,c);
  338. acc->wait_engine();
  339. }
  342. #ifdef FBCON_HAS_CFB8
  343. static void trident_8bpp_clear (struct vc_data *conp, struct display *p,
  344. int sy, int sx, int height, int width)
  345. {
  346. int c;
  347. c = attr_bgcol_ec(p,conp) & 0xFF;
  348. c |= c<<8;
  349. c |= c<<16;
  350. trident_clear_helper(c,p,sy,sx,height,width);
  351. }
  353. static struct display_switch trident_8bpp = {
  354. setup: fbcon_cfb8_setup,
  355. bmove: trident_bmove,
  356. clear: trident_8bpp_clear,
  357. putc: fbcon_cfb8_putc,
  358. putcs: fbcon_cfb8_putcs,
  359. revc: fbcon_cfb8_revc,
  360. clear_margins: fbcon_cfb8_clear_margins,
  361. fontwidthmask: FONTWIDTH (4) | FONTWIDTH (8) | FONTWIDTH (12) | FONTWIDTH (16)
  362. };
  363. #endif
  364. #ifdef FBCON_HAS_CFB16
  365. static void trident_16bpp_clear (struct vc_data *conp, struct display *p,
  366. int sy, int sx, int height, int width)
  367. {
  368. int c;
  369. c = ((u16*)p->dispsw_data)[attr_bgcol_ec(p,conp)];
  370. c = c | c<<16;
  371. trident_clear_helper(c,p,sy,sx,height,width);
  372. }
  374. static struct display_switch trident_16bpp = {
  375. setup: fbcon_cfb16_setup,
  376. bmove: trident_bmove,
  377. clear: trident_16bpp_clear,
  378. putc: fbcon_cfb16_putc,
  379. putcs: fbcon_cfb16_putcs,
  380. revc: fbcon_cfb16_revc,
  381. clear_margins: fbcon_cfb16_clear_margins,
  382. fontwidthmask: FONTWIDTH (4) | FONTWIDTH (8) | FONTWIDTH (12) | FONTWIDTH (16)
  383. };
  384. #endif
  385. #ifdef FBCON_HAS_CFB32
  386. static void trident_32bpp_clear (struct vc_data *conp, struct display *p,
  387. int sy, int sx, int height, int width)
  388. {
  389. int c;
  390. c = ((u32*)p->dispsw_data)[attr_bgcol_ec(p,conp)];
  391. trident_clear_helper(c,p,sy,sx,height,width);
  392. }
  394. static struct display_switch trident_32bpp = {
  395. setup: fbcon_cfb32_setup,
  396. bmove: trident_bmove,
  397. clear: trident_32bpp_clear,
  398. putc: fbcon_cfb32_putc,
  399. putcs: fbcon_cfb32_putcs,
  400. revc: fbcon_cfb32_revc,
  401. clear_margins: fbcon_cfb32_clear_margins,
  402. fontwidthmask: FONTWIDTH (4) | FONTWIDTH (8) | FONTWIDTH (12) | FONTWIDTH (16)
  403. };
  404. #endif
  406. /*
  407.  * Hardware access functions
  408.  */
  410. static inline unsigned char read3X4(int reg)
  411. {
  412. writeb(reg, fb_info.io_virt + CRT + 4);
  413. return readb(fb_info.io_virt + CRT + 5);
  414. }
  416. static inline void write3X4(int reg, unsigned char val)
  417. {
  418. writeb(reg, fb_info.io_virt + CRT + 4);
  419. writeb(val, fb_info.io_virt + CRT + 5);
  420. }
  422. static inline unsigned char read3C4(int reg)
  423. {
  424. t_outb(reg, 0x3C4);
  425. return t_inb(0x3C5);
  426. }
  428. static inline void write3C4(int reg, unsigned char val)
  429. {
  430. t_outb(reg, 0x3C4);
  431. t_outb(val, 0x3C5);
  432. }
  434. static inline unsigned char read3CE(int reg)
  435. {
  436. t_outb(reg, 0x3CE);
  437. return t_inb(0x3CF);
  438. }
  440. static inline void writeAttr(int reg, unsigned char val)
  441. {
  442. readb(fb_info.io_virt + CRT + 0x0A); //flip-flop to index
  443. t_outb(reg, 0x3C0);
  444. t_outb(val, 0x3C0);
  445. }
  447. static inline unsigned char readAttr(int reg)
  448. {
  449. readb(fb_info.io_virt + CRT + 0x0A); //flip-flop to index
  450. t_outb(reg, 0x3C0);
  451. return t_inb(0x3C1);
  452. }
  454. static inline void write3CE(int reg, unsigned char val)
  455. {
  456. t_outb(reg, 0x3CE);
  457. t_outb(val, 0x3CF);
  458. }
  460. #define unprotect_all() write3C4(Protection, 0x92);unprotect()
  461. #define unprotect() write3C4(NewMode1,0xC2)
  462. #define bios_reg(reg)  write3CE(BiosReg, reg)
  463. #define enable_mmio() outb(PCIReg, 0x3D4); 
  464. outb(inb(0x3D5) | 0x01, 0x3D5)
  465. #define crtc_unlock() write3X4(CRTVSyncEnd, read3X4(CRTVSyncEnd) & 0x7F)
  467. /*  Return flat panel's maximum x resolution */
  468. static int __init get_nativex(void)
  469. {
  470. int x,y,tmp;
  472. if (nativex)
  473. return nativex;
  475.         tmp = (read3CE(VertStretch) >> 4) & 3;
  477. /* detection broken on XPAi ??? misdetects 1024 for 800 */
  478. if (pci_id == CYBERBLADEXPAi1 && tmp == 3)
  479. tmp = 2;
  481. switch (tmp) {
  482. case 0:x = 1280;y = 1024;break;
  483. case 1:x = 640;y = 480;break;
  484. case 2:x = 1024;y = 768;break;
  485. default:x = 800;y = 600;break;
  486. }
  488. output("%dx%d flat panel foundn", x, y);
  489. return x;
  490. }
  492. /* Set pitch */
  493. static void set_lwidth(int width)
  494. {
  495. write3X4(Offset, width & 0xFF);
  496. write3X4(AddColReg, (read3X4(AddColReg) & 0xCF) | ((width & 0x300) >>4));
  497. }
  499. /* For resolutions smaller than FP resolution stretch */
  500. static void screen_stretch(void)
  501. {
  502. write3CE(VertStretch,(read3CE(VertStretch) & 0x7C) | 1);
  503. write3CE(HorStretch,(read3CE(HorStretch) & 0x7C) | 1);
  504. }
  506. /* For resolutions smaller than FP resolution center */
  507. static void screen_center(void)
  508. {
  509. bios_reg(0); // no stretch
  510. write3CE(VertStretch,(read3CE(VertStretch) & 0x7C) | 0x80);
  511. write3CE(HorStretch,(read3CE(HorStretch) & 0x7C) | 0x80);
  512. }
  514. /* Address of first shown pixel in display memory */
  515. static void set_screen_start(int base)
  516. {
  517. write3X4(StartAddrLow, base & 0xFF);
  518. write3X4(StartAddrHigh, (base & 0xFF00) >>8);
  519. write3X4(CRTCModuleTest, (read3X4(CRTCModuleTest) & 0xDF) | ((base & 0x10000) >>11));
  520. write3X4(CRTHiOrd, (read3X4(CRTHiOrd) & 0xF8) | (base & 0xE0000) >> 17);
  521. }
  524. #error "Floating point maths. This needs fixing before the driver is safe"
  525. #define calc_freq(n,m,k) ((NTSC * (n+8))/((m+2)*(1<<k)))
  527. /* Set dotclock frequency */
  528. static void set_vclk(int freq)
  529. {
  530. int m,n,k;
  531. int f,fi,d,di;
  532. unsigned char lo=0,hi=0;
  534. d = 20;
  535. for(k = 2;k>=0;k--)
  536. for(m = 0;m<63;m++)
  537. for(n = 0;n<128;n++) {
  538. fi = calc_freq(n,m,k);
  539. if ((di = abs(fi - freq)) < d) {
  540. d = di;
  541. f = fi;
  542. lo = n;
  543. hi = (k<<6) | m;
  544. }
  545. }
  546. write3C4(ClockHigh,hi);
  547. write3C4(ClockLow,lo);
  548. debug("VCLK = %X %Xn",hi,lo);
  549. }
  551. /* Set number of lines for flat panels*/
  552. static void set_number_of_lines(int lines)
  553. {
  554. int tmp = read3CE(CyberEnhance) & 0x8F;
  555. if (lines > 768)
  556. tmp |= 0x30;
  557. else if (lines > 600)
  558. tmp |= 0x20;
  559. else if (lines > 480)
  560. tmp |= 0x10;
  561. write3CE(CyberEnhance, tmp);
  562. }
  564. /*
  565.  * If we see that FP is active we assume we have one.
  566.  * Otherwise we have a CRT display.User can override.
  567.  */
  568. static unsigned int __init get_displaytype(void)
  569. {
  570. if (fp)
  571. return DISPLAY_FP;
  572. if (crt)
  573. return DISPLAY_CRT;
  574. return (read3CE(FPConfig) & 0x10)?DISPLAY_FP:DISPLAY_CRT;
  575. }
  577. /* Try detecting the video memory size */
  578. static unsigned int __init get_memsize(void)
  579. {
  580. unsigned char tmp;
  581. unsigned int k;
  583. /* If memory size provided by user */
  584. if (memsize)
  585. k = memsize * Kb;
  586. else
  587. switch (pci_id) {
  588. case CYBER9525DVD:k = 2560 * Kb;break;
  589. case CYBERBLADEXPAi1:k = 16 * Mb;break;
  590. case CYBERBLADEXPm16:k = 16 * Mb;break;
  591. case CYBERBLADEXPm8:k = 8 * Mb;break;
  592. default:
  593. tmp = read3X4(SPR) & 0x0F;
  594. switch (tmp) {
  595. case 3:k = 1 * Mb;break;
  596. case 7:k = 2 * Mb;break;
  597. case 15:k = 4 * Mb;break;
  598. case 4:k = 8 * Mb;break;
  599. default:k = 1 * Mb;
  600. }
  601. }
  603. k -= memdiff * Kb;
  604. output("framebuffer size = %d Kbn", k/Kb);
  605. return k;
  606. }
  609. /* Fill in fix */
  610. static int trident_encode_fix(struct fb_fix_screeninfo *fix,
  611.   const void *par,
  612.   struct fb_info_gen *info)
  613. {
  614. struct tridentfb_info * i = (struct tridentfb_info *)info;
  615. struct tridentfb_par * p = (struct tridentfb_par *)par;
  617. debug("entern");
  619. memset(fix, 0, sizeof(struct fb_fix_screeninfo));
  620. strcpy(fix->id,tridentfb_name);
  622. fix->smem_start = i->fbmem;
  623. fix->smem_len = i->memsize;
  625. fix->type = FB_TYPE_PACKED_PIXELS;
  626. fix->type_aux = 0;
  628. fix->visual = p->bpp==8 ? FB_VISUAL_PSEUDOCOLOR:FB_VISUAL_TRUECOLOR;
  630. fix->xpanstep = fix->ywrapstep = 0;
  631. fix->ypanstep = 1;
  632. fix->line_length = p->linelength;
  633. fix->mmio_start = 0;
  634. fix->mmio_len = 0;
  636. fix->accel = FB_ACCEL_NONE;
  638. debug("exitn");
  639. return 0;
  640. }
  642. /* Fill in par from var */
  643. static int trident_decode_var(const struct fb_var_screeninfo *var,
  644.   void *par,
  645.   struct fb_info_gen *info)
  646. {
  647. struct tridentfb_par * p = (struct tridentfb_par *)par;
  648. struct tridentfb_info * i = (struct tridentfb_info *)info;
  649. int vres,vfront,vback,vsync;
  650. debug("entern");
  651. p->var = *var;
  652. p->bpp = var->bits_per_pixel;
  654. if (p->bpp == 24 )
  655. p->bpp = 32;
  657. p->linelength = var->xres_virtual * p->bpp/8;
  659. switch (p->bpp) {
  660. case 8:
  661. p->var.red.offset = 0;
  662. p->var.green.offset = 0;
  663. p->var.blue.offset = 0;
  664. p->var.red.length = 6;
  665. p->var.green.length = 6;
  666. p->var.blue.length = 6;
  667. break;
  668. case 16:
  669. p->var.red.offset = 11;
  670. p->var.green.offset = 5;
  671. p->var.blue.offset = 0;
  672. p->var.red.length = 5;
  673. p->var.green.length = 6;
  674. p->var.blue.length = 5;
  675. break;
  676. case 32:
  677. p->var.red.offset = 16;
  678. p->var.green.offset = 8;
  679. p->var.blue.offset = 0;
  680. p->var.red.length = 8;
  681. p->var.green.length = 8;
  682. p->var.blue.length = 8;
  683. break;
  684. default:
  685. return -EINVAL;
  686. }
  688. /* convert from picoseconds to MHz */
  689. p->vclk = 1000000/var->pixclock;
  691. if (p->bpp == 32)
  692. p->vclk *=2;
  694. p->hres = var->xres;
  695. vres = p->vres = var->yres;
  697. /* See if requested resolution is larger than flat panel */
  698. if (p->hres > i->nativex && flatpanel) {
  699. return -EINVAL;
  700. }
  702. /* See if requested resolution fits in available memory */
  703. if (p->hres * p->vres * p->bpp/8 > i->memsize) {
  704. return -EINVAL;
  705. }
  707. vfront = var->upper_margin;
  708. vback = var->lower_margin;
  709. vsync = var->vsync_len;
  711. /* Compute horizontal and vertical VGA CRTC timing values */
  712. if (var->vmode & FB_VMODE_INTERLACED) {
  713. vres /= 2;
  714. vfront /=2;
  715. vback /=2;
  716. vsync /=2;
  717. }
  719. if (var->vmode & FB_VMODE_DOUBLE) {
  720. vres *= 2;
  721. vfront *=2;
  722. vback *=2;
  723. vsync *=2;
  724. }
  726. p->htotal = (p->hres + var->left_margin + var->right_margin + var->hsync_len)/8 - 10;
  727. p->hdispend = p->hres/8 - 1;
  728. p->hsyncstart = (p->hres + var->right_margin)/8;
  729. p->hsyncend = var->hsync_len/8;
  730. p->hblankstart = p->hdispend + 1;
  731. p->hblankend = p->htotal + 5;
  733. p->vtotal = vres + vfront + vback + vsync - 2;
  734. p->vdispend = vres - 1;
  735. p->vsyncstart = vres + vback;
  736. p->vsyncend = vsync;
  737. p->vblankstart = vres;
  738. p->vblankend = p->vtotal + 2;
  740. debug("exitn");
  742. return 0;
  743. }
  746. /* Fill in var from info */
  747. static int trident_encode_var(struct fb_var_screeninfo *var,
  748.   const void *par,
  749.   struct fb_info_gen *info)
  750. {
  751. struct tridentfb_par * p = (struct tridentfb_par *)par;
  752. debug("entern");
  753. *var = p->var;
  754. var->bits_per_pixel = p->bpp;
  755. debug("exitn");
  756. return 0;
  757. }
  759. /* Fill in par from hardware */
  760. static void trident_get_par(void *par, struct fb_info_gen *info)
  761. {
  762. struct tridentfb_par * p = (struct tridentfb_par *)par;
  763. struct tridentfb_info * i = (struct tridentfb_info *)info;
  765. debug("entern");
  766. *p = i->currentmode;
  767. debug("exitn");
  768. }
  770. /* Pan the display */
  771. static int trident_pan_display(const struct fb_var_screeninfo *var,
  772.    struct fb_info_gen *info)
  773. {
  774. unsigned int offset;
  775. struct tridentfb_info * i = (struct tridentfb_info *)info;
  777. debug("entern");
  779. offset = (var->xoffset + (var->yoffset * var->xres))
  780. * var->bits_per_pixel/32;
  781. i->currentmode.var.xoffset = var->xoffset;
  782. i->currentmode.var.yoffset = var->yoffset;
  783. set_screen_start(offset);
  784. debug("exitn");
  785. return 0;
  786. }
  788. /* Set the hardware from par */
  789. static void trident_set_par(const void *par, struct fb_info_gen *info)
  790. {
  791. struct tridentfb_par * p = (struct tridentfb_par *)par;
  792. struct tridentfb_info * i = (struct tridentfb_info *)info;
  793. unsigned char tmp;
  794. debug("entern");
  796. i->currentmode = *p;
  797. unprotect_all();
  798. crtc_unlock();
  799. enable_mmio();
  801. write3CE(CyberControl,8);
  802. if (flatpanel && p->hres < i->nativex) {
  803. /*
  804.  * on flat panels with native size larger
  805.  * than requested resolution decide whether
  806.  * we stretch or center
  807.  */
  808. t_outb(0xEB,0x3C2);
  809. write3CE(CyberControl,0x81);
  810. if (center) //|| (p->bpp==32 && pci_id == CYBERBLADEi1D))
  811. screen_center();
  812. else if (stretch)
  813. screen_stretch();
  815. } else {
  816. t_outb(0x2B,0x3C2);
  817. write3CE(CyberControl,8);
  818. }
  820. /* vertical timing values */
  821. write3X4(CRTVTotal, p->vtotal & 0xFF);
  822. write3X4(CRTVDispEnd, p->vdispend & 0xFF);
  823. write3X4(CRTVSyncStart, p->vsyncstart & 0xFF);
  824. write3X4(CRTVSyncEnd, (p->vsyncend & 0x0F));
  825. write3X4(CRTVBlankStart, p->vblankstart & 0xFF);
  826. write3X4(CRTVBlankEnd, 0/*p->vblankend & 0xFF*/);
  828. /* horizontal timing values */
  829. write3X4(CRTHTotal, p->htotal & 0xFF);
  830. write3X4(CRTHDispEnd, p->hdispend & 0xFF);
  831. write3X4(CRTHSyncStart, p->hsyncstart & 0xFF);
  832. write3X4(CRTHSyncEnd, (p->hsyncend & 0x1F) | ((p->hblankend & 0x20)<<2));
  833. write3X4(CRTHBlankStart, p->hblankstart & 0xFF);
  834. write3X4(CRTHBlankEnd, 0/*(p->hblankend & 0x1F)*/);
  836. /* higher bits of vertical timing values */
  837. tmp = 0x10;
  838. if (p->vtotal & 0x100) tmp |= 0x01;
  839. if (p->vdispend & 0x100) tmp |= 0x02;
  840. if (p->vsyncstart & 0x100) tmp |= 0x04;
  841. if (p->vblankstart & 0x100) tmp |= 0x08;
  843. if (p->vtotal & 0x200) tmp |= 0x20;
  844. if (p->vdispend & 0x200) tmp |= 0x40;
  845. if (p->vsyncstart & 0x200) tmp |= 0x80;
  847. write3X4(CRTOverflow, tmp);
  850. tmp = read3X4(CRTHiOrd) | 0x08; //line compare bit 10
  852. if (p->vtotal & 0x400) tmp |= 0x80;
  853. if (p->vblankstart & 0x400) tmp |= 0x40;
  854. if (p->vsyncstart & 0x400) tmp |= 0x20;
  855. if (p->vdispend & 0x400) tmp |= 0x10;
  856. write3X4(CRTHiOrd, tmp);
  858. write3X4(HorizOverflow, 0);
  860. tmp = 0x40;
  861. if (p->vblankstart & 0x200) tmp |= 0x20;
  862. if (p->var.vmode & FB_VMODE_DOUBLE) tmp |= 0x80;  //double scan for 200 line modes
  863. write3X4(CRTMaxScanLine, tmp);
  864. write3X4(CRTLineCompare,0xFF);
  865. write3X4(CRTPRowScan,0);
  866. write3X4(CRTModeControl,0xC3);
  867. write3X4(LinearAddReg,0x20); //enable linear addressing
  868. tmp = (p->var.vmode & FB_VMODE_INTERLACED) ? 0x84:0x80;
  869. write3X4(CRTCModuleTest,tmp); //enable access extended memory
  870. write3X4(GraphEngReg, 0x80); //enable GE for text acceleration
  872. if (p->var.accel_flags & FB_ACCELF_TEXT)
  873. acc->init_accel(p->hres,p->bpp);
  875. switch (p->bpp) {
  876. case 8:tmp=0;break;
  877. case 16:tmp=5;break;
  878. case 24:
  879. /* tmp=0x29;break; */
  880. /* seems like 24bpp is same as 32bpp when using vesafb */
  881. case 32:tmp=9;break;
  882. }
  883. write3X4(PixelBusReg, tmp);
  885. write3X4(InterfaceSel, 0x5B); //32bit internal data path
  886. write3X4(DRAMControl, 0x30); //both IO,linear enable
  887. write3X4(Performance, 0xBF);
  888. write3X4(PCIReg,0x07); //MMIO & PCI read and write burst enable
  890. set_vclk(p->vclk);
  892. write3C4(0,3);
  893. write3C4(1,1); //set char clock 8 dots wide
  894. write3C4(2,0x0F); //enable 4 maps because needed in chain4 mode
  895. write3C4(3,0);
  896. write3C4(4,0x0E); //memory mode enable bitmaps ??
  898. write3CE(MiscExtFunc,(p->bpp==32)?0x1A:0x12); //divide clock by 2 if 32bpp
  899. //chain4 mode display and CPU path
  900. write3CE(0x5,0x40); //no CGA compat,allow 256 col
  901. write3CE(0x6,0x05); //graphics mode
  902. write3CE(0x7,0x0F); //planes?
  904. writeAttr(0x10,0x41); //graphics mode and support 256 color modes
  905. writeAttr(0x12,0x0F); //planes
  906. writeAttr(0x13,0); //horizontal pel panning
  908. //colors
  909. for(tmp = 0;tmp < 0x10;tmp++)
  910. writeAttr(tmp,tmp);
  911. readb(fb_info.io_virt + CRT + 0x0A); //flip-flop to index
  912. t_outb(0x20, 0x3C0); //enable attr
  914. switch (p->bpp) {
  915. case 8: tmp = 0;break; //256 colors
  916. case 15: tmp = 0x10;break;
  917. case 16: tmp = 0x30;break; //hicolor
  918. case 24:  //truecolor
  919. case 32: tmp = 0xD0;break;
  920. }
  922. t_inb(0x3C8);
  923. t_inb(0x3C6);
  924. t_inb(0x3C6);
  925. t_inb(0x3C6);
  926. t_inb(0x3C6);
  927. t_outb(tmp,0x3C6);
  928. t_inb(0x3C8);
  930. if (flatpanel)
  931. set_number_of_lines(p->vres);
  932. set_lwidth(p->hres*p->bpp/(4*16));
  934. trident_pan_display(&p->var,info);
  935. debug("exitn");
  936. }
  938. /* Get value of one color register */
  939. static int trident_getcolreg(unsigned regno, unsigned *red,
  940.  unsigned *green, unsigned *blue,
  941.  unsigned *transp, struct fb_info *info)
  942. {
  943. struct tridentfb_info * i = (struct tridentfb_info *)info;
  944. int m = i->currentmode.bpp==8?256:16;
  946. debug("enter %dn",regno);
  948. if (regno >= m)
  949. return 1;
  951. *red = palette[regno].red;
  952. *green = palette[regno].green;
  953. *blue = palette[regno].blue;
  954. *transp = palette[regno].transp;
  956. debug("exitn");
  957. return 0;
  958. }
  960. /* Set one color register */
  961. static int trident_setcolreg(unsigned regno, unsigned red, unsigned green,
  962.  unsigned blue, unsigned transp,
  963.  struct fb_info *info)
  964. {
  965. struct tridentfb_info * i = (struct tridentfb_info *)info;
  966. int bpp = i->currentmode.bpp;
  967. int m = bpp==8?256:16;
  969. debug("enter %dn",regno);
  971. if (regno >= m)
  972. return 1;
  974. palette[regno].red = red;
  975. palette[regno].green = green;
  976. palette[regno].blue = blue;
  977. palette[regno].transp = transp;
  979. if (bpp==8) {
  980. t_outb(0xFF,0x3C6);
  981. t_outb(regno,0x3C8);
  983. t_outb(red>>10,0x3C9);
  984. t_outb(green>>10,0x3C9);
  985. t_outb(blue>>10,0x3C9);
  987. } else
  988. if (bpp == 16)  /* RGB 565 */
  989. ((u16*)info->pseudo_palette)[regno] = (red & 0xF800) |
  990. ((green & 0xFC00) >> 5) | ((blue & 0xF800) >> 11);
  991. else
  992. if (bpp == 32) /* ARGB 8888 */
  993. ((u32*)info->pseudo_palette)[regno] =
  994. ((transp & 0xFF00) <<16)  |
  995. ((red & 0xFF00) << 8)  |
  996. ((green & 0xFF00)) |
  997. ((blue & 0xFF00)>>8);
  999. debug("exitn");
  1000. return 0;
  1001. }
  1003. /* Try blanking the screen.For flat panels it does nothing */
  1004. static int trident_blank(int blank_mode, struct fb_info_gen *info)
  1005. {
  1006. unsigned char PMCont,DPMSCont;
  1008. debug("entern");
  1009. if (flatpanel)
  1010. return 0;
  1011. t_outb(0x04,0x83C8); /* Read DPMS Control */
  1012. PMCont = t_inb(0x83C6) & 0xFC;
  1013. DPMSCont = read3CE(PowerStatus) & 0xFC;
  1014. switch (blank_mode)
  1015. {
  1016. case VESA_NO_BLANKING:
  1017. /* Screen: On, HSync: On, VSync: On */
  1018. PMCont |= 0x03;
  1019. DPMSCont |= 0x00;
  1020. break;
  1021. case VESA_HSYNC_SUSPEND:
  1022. /* Screen: Off, HSync: Off, VSync: On */
  1023. PMCont |= 0x02;
  1024. DPMSCont |= 0x01;
  1025. break;
  1026. case VESA_VSYNC_SUSPEND:
  1027. /* Screen: Off, HSync: On, VSync: Off */
  1028. PMCont |= 0x02;
  1029. DPMSCont |= 0x02;
  1030. break;
  1031. case VESA_POWERDOWN:
  1032. /* Screen: Off, HSync: Off, VSync: Off */
  1033. PMCont |= 0x00;
  1034. DPMSCont |= 0x03;
  1035. break;
  1036.      }
  1038. write3CE(PowerStatus,DPMSCont);
  1039.      t_outb(4,0x83C8);
  1040.      t_outb(PMCont,0x83C6);
  1042. debug("exitn");
  1043. return 0;
  1044. }
  1046. /* Set display switch used by console */
  1047. static void trident_set_disp(const void *par, struct display *disp,
  1048.  struct fb_info_gen *info)
  1049. {
  1050. struct tridentfb_info * i = (struct tridentfb_info *)info;
  1051. struct fb_info * ii = (struct fb_info *)info;
  1052. struct tridentfb_par * p = (struct tridentfb_par *)par;
  1053. int isaccel = p->var.accel_flags & FB_ACCELF_TEXT;
  1055. disp->screen_base = (char *)i->fbmem_virt;
  1056. debug("entern");
  1057. #ifdef FBCON_HAS_CFB8
  1058. if (p->bpp == 8 ) {
  1059. if (isaccel)
  1060. disp->dispsw = &trident_8bpp;
  1061. else
  1062. disp->dispsw = &fbcon_cfb8;
  1063. } else
  1064. #endif
  1065. #ifdef FBCON_HAS_CFB16
  1066. if (p->bpp == 16) {
  1067. if (isaccel)
  1068. disp->dispsw = &trident_16bpp;
  1069. else
  1070. disp->dispsw = &fbcon_cfb16;
  1071. disp->dispsw_data =ii->pseudo_palette; /* console palette */
  1072. } else
  1073. #endif
  1074. #ifdef FBCON_HAS_CFB32
  1075. if (p->bpp == 32) {
  1076. if (isaccel)
  1077. disp->dispsw = &trident_32bpp;
  1078. else
  1079. disp->dispsw = &fbcon_cfb32;
  1080. disp->dispsw_data =ii->pseudo_palette; /* console palette */
  1081. } else
  1082. #endif
  1083. disp->dispsw = &fbcon_dummy;
  1084. debug("exitn");
  1085. }
  1087. static struct fbgen_hwswitch trident_hwswitch = {
  1088. NULL, /* detect not needed */
  1089. trident_encode_fix,
  1090. trident_decode_var,
  1091. trident_encode_var,
  1092. trident_get_par,
  1093. trident_set_par,
  1094. trident_getcolreg,
  1095. trident_setcolreg,
  1096. trident_pan_display,
  1097. trident_blank,
  1098. trident_set_disp
  1099. };
  1101. /* List of boards that we are trying to support */
  1102. static struct almost_supported_board {
  1103. int pci_id;
  1104. int family;
  1105. struct accel_switch * acc;
  1106. char* board_name;
  1107. int accel;
  1108. } asb[] __initdata = {
  1109. { BLADE3D, BLADE, &accel_blade, "Blade3D", ACCEL },
  1110. { CYBERBLADEi7, BLADE, &accel_blade, "CyberBladei7", ACCEL },
  1111. { CYBERBLADEi7D, BLADE, &accel_blade, "CyberBladei7D", ACCEL },
  1112. { CYBERBLADEi1, BLADE, &accel_blade, "CyberBladei1", ACCEL },
  1113. { CYBERBLADEi1D, BLADE, &accel_blade, "CyberBladei1D", ACCEL },
  1114. { CYBERBLADEAi1, BLADE, &accel_blade, "CyberBladeAi1", ACCEL },
  1115. { CYBERBLADEAi1D, BLADE, &accel_blade, "CyberBladeAi1D", ACCEL },
  1116. { CYBERBLADEE4, BLADE, &accel_blade, "CyberBladeE4", ACCEL },
  1118. { IMAGE975, IMAGE, &accel_image, "IMAGE975", NOACCEL },
  1119. { IMAGE985, IMAGE, &accel_image, "IMAGE985", NOACCEL },
  1120. { CYBER9320, IMAGE, &accel_image, "Cyber9320", NOACCEL },
  1121. { CYBER9388, IMAGE, &accel_image, "Cyber9388", NOACCEL },
  1122. { CYBER9520, IMAGE, &accel_image, "Cyber9520", NOACCEL },
  1123. { CYBER9525DVD, IMAGE, &accel_image, "Cyber9525DVD", NOACCEL },
  1124. { CYBER9397, IMAGE, &accel_image, "Cyber9397", NOACCEL },
  1125. { CYBER9397DVD, IMAGE, &accel_image, "Cyber9397DVD", NOACCEL },
  1127. { CYBERBLADEXPAi1, XP, &accel_blade, "CyberBladeXPAi1", NOACCEL },
  1128. { CYBERBLADEXPm8, XP, &accel_blade, "CyberBladeXPm8", NOACCEL },
  1129. { CYBERBLADEXPm16, XP, &accel_blade, "CyberBladeXPm16", NOACCEL },
  1130. };
  1132. static __init int trident_find_board(void)
  1133. {
  1134. int i;
  1135. struct pci_dev * board;
  1137. for (i = 0;i < ARRAY_SIZE(asb);i++) {
  1138.        if ((board = pci_find_device(PCI_VENDOR_ID_TRIDENT,
  1139.    asb[i].pci_id,
  1140.    NULL))) {
  1141.   family = asb[i].family;
  1142.   acc = asb[i].acc;
  1143.   pci_id = asb[i].pci_id;
  1144.   defaultaccel = asb[i].accel;
  1146. fb_info.io = pci_resource_start(board,1);
  1147. fb_info.fbmem = pci_resource_start(board,0);
  1148.   output("%s board foundn", asb[i].board_name);
  1149.   return 1;
  1150.        }
  1151.     }
  1152. output("No Trident board foundn");
  1153. return 0;
  1154. }
  1156. int __init tridentfb_init(void)
  1157. {
  1159. output("Trident framebuffer  %s initializingn", VERSION);
  1161. if (!trident_find_board())
  1162.       return -1;
  1164. if (!request_mem_region(fb_info.io, TRIDENT_IOSIZE, "tridentfb")) {
  1165. debug("request_region failed!n");
  1166. return -1;
  1167. };
  1169. fb_info.io_virt = (unsigned int)ioremap_nocache(fb_info.io, TRIDENT_IOSIZE);
  1171. if (!fb_info.io_virt) {
  1172. release_region(fb_info.io, TRIDENT_IOSIZE);
  1173. debug("ioremap failedn");
  1174. return -1;
  1175. }
  1177. fb_info.memsize = get_memsize();
  1178. if (!request_mem_region(fb_info.fbmem, fb_info.memsize, "tridentfb")) {
  1179. debug("request_mem_region failed!n");
  1180. return -1;
  1181. }
  1183. fb_info.fbmem_virt = (unsigned int)ioremap_nocache(fb_info.fbmem, fb_info.memsize);
  1185. if (!fb_info.fbmem_virt) {
  1186. release_mem_region(fb_info.fbmem, fb_info.memsize);
  1187. debug("ioremap failedn");
  1188. return -1;
  1189. }
  1191. debug("Trident board found : mem = %X,io = %X, mem_v = %X, io_v = %Xn",
  1192. fb_info.fbmem, fb_info.io, fb_info.fbmem_virt, fb_info.io_virt);
  1194. fb_info.gen.parsize = sizeof (struct tridentfb_par);
  1195. fb_info.gen.fbhw = &trident_hwswitch;
  1197. strcpy(fb_info.gen.info.modename, tridentfb_name);
  1198. displaytype = get_displaytype();
  1199. if(flatpanel)
  1200. fb_info.nativex = get_nativex();
  1201. fb_info.gen.info.changevar = NULL;
  1202. fb_info.gen.info.node = NODEV;
  1203. fb_info.gen.info.fbops = &tridentfb_ops;
  1204. fb_info.gen.info.disp = &disp;
  1206. fb_info.gen.info.switch_con = &fbgen_switch;
  1207. fb_info.gen.info.updatevar = &fbgen_update_var;
  1208. fb_info.gen.info.blank = &fbgen_blank;
  1210. fb_info.gen.info.flags = FBINFO_FLAG_DEFAULT;
  1211. fb_info.gen.info.fontname[0] = '';
  1212. fb_info.gen.info.pseudo_palette = pseudo_pal;
  1214. /* This should give a reasonable default video mode */
  1215. fb_find_mode(&default_var,&fb_info.gen.info,mode,NULL,0,NULL,bpp);
  1216. /*
  1217.  * Unless user explicitly requires accel/noaccel use
  1218.  * per chip defaults.Accel has priority over noaccel.
  1219.  */
  1220. if (accel)
  1221. defaultaccel = ACCEL;
  1222. else if (noaccel)
  1223. defaultaccel = NOACCEL;
  1225. if (defaultaccel == ACCEL)
  1226. default_var.accel_flags |= FB_ACCELF_TEXT;
  1227. else
  1228. default_var.accel_flags &= ~FB_ACCELF_TEXT;
  1230. trident_decode_var(&default_var, &fb_info.currentmode, &fb_info.gen);
  1231. fbgen_get_var(&disp.var, -1, &fb_info.gen.info);
  1232. default_var.activate |= FB_ACTIVATE_NOW;
  1233. fbgen_set_disp(-1, &fb_info.gen);
  1235. if (register_framebuffer(&fb_info.gen.info) < 0) {
  1236. printk("Could not register Trident framebuffern");
  1237. return -EINVAL;
  1238. }
  1240. output("fb%d: %s frame buffer device %dx%d-%dbppn",
  1241.    GET_FB_IDX(fb_info.gen.info.node), fb_info.gen.info.modename,default_var.xres,
  1242.    default_var.yres,default_var.bits_per_pixel);
  1243. return 0;
  1244. }
  1246. void __exit tridentfb_exit(void)
  1247. {
  1248. unregister_framebuffer(&fb_info.gen.info);
  1249. iounmap((void *)fb_info.io_virt);
  1250. iounmap((void *)fb_info.fbmem_virt);
  1251. }
  1253. /*
  1254.  * Parse user specified options (`video=trident:')
  1255.  * example:
  1256.  *  video=trident:800x600,bpp=16,noaccel
  1257.  */
  1258. int tridentfb_setup(char *options)
  1259. {
  1260. char * opt;
  1261. if (!options || !*options)
  1262. return 0;
  1263. for(opt = strtok(options,",");opt;opt = strtok(NULL,",")){
  1264. if (!opt) continue;
  1265. if (!strncmp(opt,"noaccel",7))
  1266. noaccel = 1;
  1267. else if (!strncmp(opt,"accel",5))
  1268. accel = 1;
  1269. else if (!strncmp(opt,"fp",2))
  1270. displaytype = DISPLAY_FP;
  1271. else if (!strncmp(opt,"crt",3))
  1272. displaytype = DISPLAY_CRT;
  1273. else if (!strncmp(opt,"bpp=",4))
  1274. bpp = simple_strtoul(opt+4,NULL,0);
  1275. else if (!strncmp(opt,"center",6))
  1276. center = 1;
  1277. else if (!strncmp(opt,"stretch",7))
  1278. stretch = 1;
  1279. else if (!strncmp(opt,"memsize=",8))
  1280. memsize = simple_strtoul(opt+8,NULL,0);
  1281. else if (!strncmp(opt,"memdiff=",8))
  1282. memdiff = simple_strtoul(opt+8,NULL,0);
  1283. else if (!strncmp(opt,"nativex=",8))
  1284. nativex = simple_strtoul(opt+8,NULL,0);
  1285. else
  1286. mode = opt;
  1287. }
  1288. return 0;
  1289. }
  1291. static struct fb_ops tridentfb_ops = {
  1292. fb_get_fix:fbgen_get_fix,
  1293. fb_get_var:fbgen_get_var,
  1294. fb_set_var:fbgen_set_var,
  1295. fb_get_cmap:fbgen_get_cmap,
  1296. fb_set_cmap:fbgen_set_cmap,
  1297. fb_pan_display:fbgen_pan_display,
  1298. };
  1300. #ifdef MODULE
  1301. module_init(tridentfb_init);
  1302. #endif
  1303. module_exit(tridentfb_exit);
  1305. MODULE_AUTHOR("Jani Monoses <jani@astechnix.ro>");
  1306. MODULE_DESCRIPTION("Framebuffer driver for Trident cards");
  1307. MODULE_LICENSE("GPL");